diff --git a/CHANGELOG.md b/CHANGELOG.md
index 26e618f4..22ff416f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,70 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 > from git history and grouped by theme rather than exhaustive per-commit
 > detail.
 
+## [3.0.0] - 2026-06-30
+
+### Added
+- **Public-vehicle badge.** Vehicles marked *Show on profile* now carry a small
+  **Public** badge in the garage's Vehicles tab, so you can see at a glance which are
+  shared on your driver profile.
+- **Request a datalogger.** The contact form has a new **New datalogger connection**
+  category, and the "Download from logger" picker has a **Request additional
+  dataloggers** button that opens the contact form with that category preselected.
+- **Custom tracks ride along with leaderboard snapshots.** When you submit a snapshot
+  for a track that isn't in the built-in list, its layout + sectors are included with
+  the snapshot (so others can view the lap) and the track is **automatically submitted
+  to the community track database** for review — same flow as the manual submitter, no
+  CAPTCHA for signed-in users, deduped so it's only sent once.
+- **Alfano logger groundwork.** Picking the Alfano tile in the logger picker now
+  explains that Alfano transfers over Bluetooth serial (Classic Bluetooth SPP),
+  which browsers can't access in-browser, so it will require the native app. The
+  native-side download flow is scaffolded (`src/lib/loggers/alfano/`,
+  `AlfanoDownload`) against the shared native IPC client; the Rust backend that
+  drives it is still to come.
+- **Public driver profiles (plan 0006).** A new public `/driver/{name}` page (shareable,
+  viewable signed-out) shows a driver's **profile picture**, display name, their **opt-in
+  vehicles** (name/type/engine only — never weights or setups), and their uploaded
+  **leaderboard snapshots** as cards. URLs are case-insensitive. **Click a driver's
+  avatar on the Leaderboards** to open their profile, and **click any snapshot card** to
+  load that lap in the read-only viewer.
+- **Profile pictures.** Tap your profile picture on the Profile tab to upload one; it's
+  cropped to a centred square and downscaled to ≤256px on-device, then stored in the
+  cloud. Avatar thumbnails now appear next to names on the Leaderboards.
+- **Copy profile link.** A button under Sign out on the Profile tab copies your public
+  driver-profile link.
+- **Show a vehicle on your profile.** Each vehicle in the garage now has a *Show on
+  profile* toggle that publishes a public-safe projection (no weight, no setup).
+- A **← Back to home** button on the Leaderboards and driver-profile pages.
+- **Leaderboards (plan 0005).** A new public **Leaderboards** page (linked from the
+  landing page) where anyone — signed in or not — can browse fastest community laps
+  by **track → course → engine class**, with an optional **Group by weight** toggle
+  and a **Show top** selector (3/10/25/50/100/All). Picking a group launches the
+  normal telemetry viewer in a new **read-only mode** (alert-coloured header,
+  Coach/Tools/Setups + video/weather/snapshots hidden) where every submitted lap is
+  a row, fastest first, labelled by the submitter's name.
+- **Submit snapshots to the leaderboards.** From the Profile tab, signed-in users
+  with lap snapshots get a **Submit to leaderboards** dialog. GPS, engine name and a
+  **listed weight** are public; **engine-telemetry channels** (RPM, temps) stay
+  private unless you opt to share them. Setup data is never uploaded. The listed
+  weight defaults to the vehicle's weight and can be overridden (e.g. show a class
+  weight). Identical snapshots can't be resubmitted.
+- **Engine classification + moderation (admin).** A new admin **Leaderboards** tab
+  lists every submission with approve/deny (allow-by-default), a per-record engine
+  **class override**, and admin notes. Engine **classes** are keyword groups that
+  collapse free-text engine names ("Tillotson 225" / "225RS" / "Tilly") into one
+  class automatically, with a **Reclassify** action — without ever mutating the
+  user's raw engine string.
+
+### Changed
+- **An engine is now required on every vehicle.** The vehicle form won't save without
+  one (it drives leaderboard grouping and snapshot matching), and any existing
+  engine-less vehicle is flagged in the garage so you can fill it in.
+- **Display names are now unique case-insensitively** so a name can't be impersonated by
+  changing case (existing case-duplicates are auto-suffixed by the migration).
+- **Leaderboard names update live.** A submitter's name on the leaderboards now comes from
+  their current profile (linked by account) instead of a copy frozen at submit time, so
+  renaming your display name updates all your existing entries.
+
 ## [2.9.2] - 2026-06-25
 
 ### Added
diff --git a/CLAUDE.md b/CLAUDE.md
index b7b2d78e..61a6b9b9 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -80,12 +80,15 @@ telemetry viewer.
 ```
 src/
 ├── pages/
-│   ├── Index.tsx          # ★ Main SPA — file import, tab views, all state orchestration
+│   ├── Index.tsx          # ★ Main SPA — file import, tab views, all state orchestration. Also hosts the read-only Leaderboards viewer (plan 0005): consumes a leaderboardHandoff bundle on mount, injects its prebuilt laps/selection, flips a `readOnly` flag that alert-colours the header + hides Coach/Tools/Setups + video/weather/snapshots and labels laps by submitter.
+│   ├── Leaderboards.tsx   # ★ Public /leaderboards page (cloud-gated): Track→Course→engine/weight accordion (Group-by-weight + Show-top), opens a group into Index's read-only viewer via leaderboardHandoff; shows uploader avatar thumbnails
+│   ├── DriverProfile.tsx  # ★ Public /driver/:username page (plan 0006, anon, case-insensitive via .ilike): avatar + name + opt-in vehicles (no weights/setups) + the driver's approved leaderboard snapshots grouped by course/weight
 │   ├── Admin.tsx          # Admin panel (behind VITE_ENABLE_ADMIN)
 │   └── …                  # Login / Register / Privacy / Terms / NotFound
 ├── components/
 │   ├── ui/                # shadcn/ui primitives
-│   ├── admin/             # Admin tabs (Tracks, Courses, Submissions, Users, BannedIps, Tools, Messages)
+│   ├── SiteHeader.tsx     # ★ Shared sticky top banner (sponsor + settings + profile); LandingPage shows all, Leaderboards hides supported-files/about
+│   ├── admin/             # Admin tabs (Tracks, Courses, Submissions, Users, BannedIps, Tools, Messages, Leaderboards)
 │   ├── tabs/              # View tabs (GraphView, RaceLine, LapTimes, Coach, Tools; SetupsNotesPanel = Setups+Notes 50/50 split on md+, separate tabs on phones — bodies live in drawer/)
 │   ├── graphview/         # Pro mode: GraphPanel, GraphViewPanel, MiniMap, SingleSeriesChart, GGDiagram, InfoBox, PanelCard (resizable card chrome for relocated Video/Mini-Map panels). The left column collapses via a divider flag tab (any screen size), and Video/Mini-Map can be relocated into the resizable graph stack from the top of the "Add Graph" picker (GraphPanel reports which are active so the host drops its duplicate VideoPlayer — single shared video ref). Split graphs (tablet+): SecondaryGraphStack mirrors the main panel's graph set for a chosen overlay lap in a draggable two-up view, overriding PlaybackContext for its subtree (nested PlaybackProvider) so one cursor lands on the same track position in both laps (distance-mapped via lib/referenceUtils mapIndexByDistance); SecondaryVideo is a literal second, lap-synced <video> for in-session overlay laps.
 │   ├── drawer/            # File-manager drawer tabs (Files, Vehicles/Karts, Device*); SetupsTab + NotesTab also here but mounted as main-view tabs
@@ -115,6 +118,9 @@ src/
 │   ├── sampleData.ts      # ★ Bundled sample log seeded as an ordinary file (→ docs/subsystems.md)
 │   ├── lapOverlays.ts / lapAlignment.ts  # ★ Multi-lap overlay logic + Kabsch drift-align (→ docs/subsystems.md)
 │   ├── lapSnapshot*.ts    # ★ Snapshot types/buffer + IndexedDB CRUD (→ docs/subsystems.md)
+│   ├── leaderboard*.ts    # ★ Leaderboards (plan 0005): leaderboardTypes (shared), leaderboardBrowse (Track→Course→engine/weight tree), leaderboardSession (transpose entries → one read-only synthetic session, fastest=lap 1), leaderboardHandoff (one-shot page→Index handoff). Submission + Supabase access live in plugins/cloud-sync (leaderboardSubmission/leaderboardClient). → docs/backend.md
+│   ├── imageCrop.ts       # ★ Pure on-device avatar crop (1:1 centre + downscale ≤256, webp/jpeg) — no Supabase (plan 0006)
+│   ├── driverProfileGroups.ts # ★ Pure: one driver's leaderboard entries → Course→weight buckets (plan 0006, DriverProfile)
 │   ├── setupRevision*.ts  # ★ Content-addressed setup history + IndexedDB CRUD (→ docs/subsystems.md)
 │   ├── setupHistory.ts    # ★ Pure setup-history view-model (diff + fastest-lap aggregation) → drawer/SetupHistoryPanel (→ docs/subsystems.md)
 │   ├── vehicleHistory.ts  # ★ Pure vehicle-history view-model (per-vehicle setup revisions, fastest-lap first, course filter) → drawer/VehicleHistoryPanel; reuses setupHistory primitives; shared card chrome in drawer/HistoryCard.tsx
@@ -124,7 +130,7 @@ src/
 │   ├── fileLoadingState.ts # ★ Host pub/sub for the global file-load overlay
 │   ├── *Storage.ts        # IDB/localStorage store modules (file, vehicle, engine, template, note, setup, …)
 │   ├── gps/               # ★ Phone-as-datalogger layer: gpsFix, customGps, sessionGate, realtimeTimer, dovepWriter
-│   ├── loggers/           # ★ Generic LoggerConnection (listLogs/downloadLog/disconnect) + per-logger adapters — Fledgling=web BLE, mychron/=MyChron over native (Tauri) Wi-Fi IPC, doveslogger/=same Fledgling hardware over native (Tauri) BLE IPC (scan→connect→list→download); native/ipc.ts = shared kind-agnostic native IPC (both lazy; @tauri-apps/api dynamic-imported, native-only); Alfano later. progress.ts = transport-neutral formatters + computeProgress (→ docs/ble.md)
+│   ├── loggers/           # ★ Generic LoggerConnection (listLogs/downloadLog/disconnect) + per-logger adapters — Fledgling=web BLE, mychron/=MyChron over native (Tauri) Wi-Fi IPC, doveslogger/=same Fledgling hardware over native (Tauri) BLE IPC (scan→connect→list→download), alfano/=Alfano over native (Tauri) Bluetooth-serial IPC (SKELETON: web-side seam only, Rust backend TBD — Bluetooth serial can't be reached in-browser so there's no web path); native/ipc.ts = shared kind-agnostic native IPC (all lazy; @tauri-apps/api dynamic-imported, native-only). progress.ts = transport-neutral formatters + computeProgress (→ docs/ble.md)
 │   ├── speedHeatmap.ts / mapMarker.ts / brakingZones / gforceCalculation / …  # racing math
 │   ├── chartUtils / canvas2d / chartAxis / chartColors / videoExport / overlayCanvasRenderer  # charts/video
 │   ├── videoPlaylist.ts   # ★ Pure GoPro chunked-video model: parse/order GH/GX/GP/GOPR chunk names, build a virtual timeline (cumulative offsets) + virtual↔local time mapping + planAudioSegments (export audio stitch). useVideoSync swaps the <video> src per chunk; a single file is a 1-chunk playlist
@@ -384,6 +390,7 @@ and the seeder: **→ `docs/i18n.md`**.
 | `VITE_TURNSTILE_SITE_KEY` | Client | Cloudflare Turnstile site key (optional CAPTCHA) |
 | `TURNSTILE_SECRET_KEY` | Server (edge fn) | Turnstile secret — `???` |
 | `VITE_FIRMWARE_MANIFEST_URL` | Client | Override the logger firmware OTA manifest URL. Unset: `main` → production manifest, non-`main`/preview → beta channel (same `isPreviewBuild()` switch). |
+| `SUPABASE_ACCESS_TOKEN` | Build (secret) | Supabase PAT. On a **feature-branch** build (not `main`, not `BETA`), `vite.config.ts` resolves that branch's own Supabase **preview-branch DB** via the Management API (`scripts/resolveSupabaseBranch.ts`) and bakes its creds in, else falls back to the static `*_PREVIEW`/beta creds. Never on `main`/`BETA`/dev/runtime. → plan 0007. |
 | `DOVE_PLUGIN_PACKAGES` | Build | Comma-separated external plugin npm packages. Overrides the default when set. |
 | `ANTHROPIC_API_KEY` / `I18N_SEED_MODEL` | Maintainer tool | Used **only** by `bun run i18n:seed` (`ANTHROPIC_API_KEY` = `???`). Never in the app or CI build. |
 | `VITE_APP_VERSION` / `VITE_GIT_HASH` / `VITE_BUILD_DATE` / `VITE_GIT_BRANCH` / `VITE_GIT_COMMIT_DATE` | Build (auto) | Footer version stamp — **not hand-set**; baked from `package.json` + git in `vite.config.ts`. |
@@ -399,10 +406,14 @@ the dashboard). The beta domain `beta.lapwingdata.com` can't bind to a Branch
 Preview URL, so a separate thin reverse-proxy Worker in `beta-proxy/` owns it and
 forwards to `beta-lapwing.perchwerks.workers.dev` (auto-deployed by the
 `deploy-beta-proxy.yml` workflow on `BETA` pushes that touch `beta-proxy/**`;
-see `beta-proxy/README.md`). Per-branch preview backend: `vite.config.ts` `pick()`
-prefers `*_PREVIEW` Supabase creds on any non-`main` branch
-(`WORKERS_CI_BRANCH`/`CF_PAGES_BRANCH`), so beta deployments bake in a preview DB.
-`main` and local dev never read `_PREVIEW`. See README "Deployment".
+see `beta-proxy/README.md`). Backend by branch (`vite.config.ts` `pick()`, keyed on
+`WORKERS_CI_BRANCH`/`CF_PAGES_BRANCH`): **`main`** → base/production vars;
+**`BETA`** → static `*_PREVIEW` creds (the shared beta DB — never the resolver);
+**any other branch** → with a `SUPABASE_ACCESS_TOKEN` secret, that branch's own
+Supabase preview-branch DB via the Management API (`scripts/resolveSupabaseBranch.ts`,
+plan 0007), else the `*_PREVIEW`/beta fallback. Each build logs `[backend] Supabase
+URL baked: … — <tier>`. `main` and local dev never read `_PREVIEW`/the token. See
+README "Deployment".
 
 ---
 
diff --git a/README.md b/README.md
index 84c8e046..4457d3e2 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,7 @@
 - Pro graph view with multi-series telemetry charts
 - Reference lap overlay & pace delta comparison
 - Lap snapshots — save a "course fastest lap" per engine, frozen for cross-session comparison (local-first, optionally cloud-synced)
+- Public leaderboards — submit your snapshots and browse fastest community laps by track, course and engine class (with optional weight grouping); opens any group in a read-only viewer (cloud-enabled builds)
 - Video sync with telemetry playback (incl. GoPro chunked recordings — select all chapter files and they play as one continuous video)
 - 9 overlay gauge types (digital, analog, graph, bar, bubble, map, pace, sector, lap time)
 - MP4 video export with overlays & audio (H.264 + AAC)
@@ -166,6 +167,7 @@ view. Older JSON with only `sector_2_*`/`sector_3_*` is read as the two majors.
 | `STRIPE_SECRET_KEY` | No (required for paid tiers) | Stripe secret key used by the `create-checkout-session`, `stripe-webhook`, and `create-portal-session` edge functions (edge function secret — `???`) |
 | `STRIPE_WEBHOOK_SECRET` | No (required for paid tiers) | Signing secret for the `stripe-webhook` endpoint, from the Stripe dashboard webhook config (edge function secret — `???`) |
 | `DELETION_CRON_SECRET` | No (required for scheduled account deletion) | Shared secret the `process-account-deletions` edge function requires in the `x-cron-secret` header. Must match the Vault secret `deletion_cron_secret` that the daily pg_cron job sends (edge function secret — `???`) |
+| `SUPABASE_ACCESS_TOKEN` | No (preview-branch DBs) | Build-time secret: a Supabase **personal access token**. When set, a **feature-branch** build (not `main`, not `BETA`) resolves its own per-branch Supabase preview database via the Management API and bakes those creds in, falling back to the static `*_PREVIEW`/beta creds when the branch has no preview DB. See *Preview-branch backend* below. Never read by `main`/`BETA` builds, local dev, or the runtime app. |
 | `DOVE_PLUGIN_PACKAGES` | No | Build-time: comma-separated external plugin npm packages to load. Overrides the default (`@perchwerks/eye-in-the-sky`, the public AI coach) when set |
 | `ANTHROPIC_API_KEY` | No (translation tooling) | Required by `bun run i18n:seed` to machine-translate locale files (`scripts/seed-translations.mjs`). Maintainer tool only — never read by the app or the standard CI build (`???`). |
 | `I18N_SEED_MODEL` | No | Optional model override for `bun run i18n:seed` (default `claude-sonnet-4-6`). |
@@ -433,12 +435,22 @@ static frontend.
 
 #### Preview-branch backend (Supabase Branching → preview deployments)
 
-Pushes to a **non-production branch** produce a preview version/URL of the same
-Worker. To point those preview builds at a Supabase **preview-branch database**
-(so beta work doesn't touch production data), set parallel `*_PREVIEW` build
-variables. Workers Builds exposes `WORKERS_CI_BRANCH` (Pages: `CF_PAGES_BRANCH`)
-on every build; `vite.config.ts` prefers the `_PREVIEW` value of each key
-whenever that branch isn't `main`, and ignores them on `main` and in local dev.
+The build picks its Supabase backend by **git branch**, in three tiers:
+
+| Branch | Database | How it's chosen |
+|--------|----------|-----------------|
+| `main` | production | base build vars (`VITE_*` / `HTT_*`) |
+| `BETA` | the shared beta DB | the `*_PREVIEW` build vars |
+| any other branch | that branch's **own** Supabase preview-branch DB | resolved via the Management API, falling back to `*_PREVIEW`/beta when none exists |
+
+`BETA` is the shared integration database and is **never** routed onto a per-branch
+DB — only feature branches consult the resolver. Each build logs the result
+(`[backend] Supabase URL baked: … — <tier>`) so a deploy always states which DB it
+baked and why. Set the `*_PREVIEW` vars so non-`main` builds don't touch production:
+
+Workers Builds exposes `WORKERS_CI_BRANCH` (Pages: `CF_PAGES_BRANCH`) on every
+build; `vite.config.ts` prefers the `_PREVIEW` value of each key whenever the
+branch isn't `main`, and ignores them on `main` and in local dev.
 
 1. Enable **Branching** in Supabase, then copy the preview branch's URL, anon
    key, and project ref from the **Branches** panel.
@@ -455,6 +467,31 @@ whenever that branch isn't `main`, and ignores them on `main` and in local dev.
    is also accepted. Add the Cloudflare preview URL to the preview branch's
    **Auth → Redirect URLs** so cloud sign-in works there.
 
+##### Dynamic per-branch databases (feature branches)
+
+Without a token, every non-`main` preview (including feature branches) uses the
+static `*_PREVIEW`/beta DB. To instead give each **feature** branch its **own**
+Supabase preview-branch database — so its preview deployment exercises that
+branch's migrations without merging into beta first — add a `SUPABASE_ACCESS_TOKEN`
+build secret (`BETA` always stays on `*_PREVIEW` regardless):
+
+1. Create a Supabase **personal access token** (Account → Access Tokens).
+2. Worker → **Settings → Build → Variables and Secrets** → add it as a secret:
+   `SUPABASE_ACCESS_TOKEN` (keep the static `*_PREVIEW` values as the fallback).
+
+On a **feature-branch** build (not `main`, not `BETA`), `vite.config.ts` asks the
+Supabase **Management API** whether a preview branch exists for the build's git
+branch (`scripts/resolveSupabaseBranch.ts`). If one does and it's healthy, that
+branch's URL + anon key + ref are baked in; otherwise it falls back to the static
+`*_PREVIEW`/beta creds. The lookup never throws and times out fast, so it can't
+break a deploy. Full design: [`docs/plans/0007-dynamic-supabase-branch-db.md`](docs/plans/0007-dynamic-supabase-branch-db.md).
+
+> Supabase only generates a preview branch when the git branch carries **migration
+> changes**. Branches without DB changes simply fall back to beta. To force a DB
+> for a branch anyway, push a no-op migration or create the branch by hand in the
+> Supabase dashboard. Remember to add each preview URL to the branch's
+> **Auth → Redirect URLs** for cloud sign-in.
+
 #### Custom domains (production + beta)
 
 - **Production — `lapwingdata.com`:** `wrangler.jsonc` declares a
diff --git a/docs/backend.md b/docs/backend.md
index 7a496dff..dcfef97c 100644
--- a/docs/backend.md
+++ b/docs/backend.md
@@ -59,8 +59,11 @@ Backend (migrations `..._cloud_sync.sql`, `..._storage_quotas.sql`,
 | `enforce_sync_quota` | trigger | BEFORE INSERT/UPDATE on `sync_records`: rejects a write that pushes the caller's **pooled total** (this table + all `lap_snapshots`, minus the upserted row) over `tier_total_limit()` (`quota_exceeded`). |
 | `enforce_snapshot_quota` | trigger | BEFORE INSERT/UPDATE on `lap_snapshots`: same pooled check keyed off the snapshot's serialized size (`quota_exceeded`). |
 | `sync_storage_usage()` | RPC | Single row `(documents_bytes, logs_bytes, snapshots_bytes, total_limit_bytes)` for the caller — the limit reflects the caller's tier. |
-| `profiles` | table | `(user_id PK→auth.users, display_name unique, …)`. RLS: authenticated read-all, update/insert own. Display name is unique but **not** a key — user-editable. |
-| `handle_new_user` | trigger | On `auth.users` insert: creates a profile, using the sign-up `display_name` or a generated silly name (`SpeedyRac3r-546`). `unique_display_name()` auto-suffixes a taken name at creation; user edits get an explicit "taken" error instead. |
+| `profiles` | table | `(user_id PK→auth.users, display_name, avatar_path, avatar_updated_at, …)`. RLS: **public (anon) read** (so the `security_invoker` `public_profiles` view + leaderboard name embeds resolve for anon), update/insert own only. Display name is **unique case-insensitively** (`unique index on lower(display_name)`, plan 0006) but **not** a key — user-editable. |
+| `public_profiles` | view | Plan 0006. Anon-readable, column-limited (`user_id, display_name, avatar_path, avatar_updated_at`) — backs the public `/driver/:username` page + Leaderboards avatar thumbnails. A **`security_invoker`** view (not SECURITY DEFINER): it respects the caller's RLS, so `profiles` now has a public (anon) read policy. Writes stay owner-only. |
+| `public_vehicles` | table | Plan 0006. Opt-in public projection of a user's vehicles `(user_id, vehicle_id PK, name, type_name, engine, number)` — **never weight/setup**. RLS: anon read, owner write. Synced off the garage-change path (`publicVehicleSync`); cascades on account delete. |
+| `user-avatars` | Storage bucket | Plan 0006. **Public**. Avatar at `{user_id}/avatar.{webp\|jpg}` (cropped ≤256px client-side). Public read; owner-folder write. Not FK-cascaded — the deletion worker empties the folder. |
+| `handle_new_user` | trigger | On `auth.users` insert: creates a profile, using the sign-up `display_name` or a generated silly name (`SpeedyRac3r-546`). `unique_display_name()` auto-suffixes a taken name at creation (case-insensitively); user edits get an explicit "taken" error instead. |
 
 Synced stores (`syncStores.ts` — pure, unit-tested): `metadata`, `karts`,
 `setups`, `notes`, `graph-prefs`, `vehicle-types`, `setup-templates`, `engines`,
@@ -117,6 +120,37 @@ escape hatch confined to that one module.
 
 ---
 
+## Leaderboards (`..._leaderboards.sql`, plan 0005)
+
+Public community leaderboards built from submitted lap snapshots. **All access is
+through RLS** (no edge function); the client lives in
+`src/plugins/cloud-sync/leaderboardClient.ts`.
+
+| Table | Purpose |
+|-------|---------|
+| `leaderboard_entries` | One row per submitted snapshot. Holds the frozen `data` jsonb (clean-lap samples + **full course geometry incl. sectors/layout**; engine-telemetry channels stripped client-side unless shared — **setup data is never uploaded**), the raw `engine` + `engine_key`, the admin-overridable `engine_class_id` (+ `class_source`), the public `listed_weight`, `lap_time_ms`, a `content_hash`, and `status` (`approved` default / `denied`). The submitter's name is **not** stored: an FK `user_id→profiles(user_id)` lets reads embed the LIVE `profiles(display_name)` (plan 0006), so a rename propagates. The legacy `display_name` column is now nullable + unused. `unique (user_id, content_hash)` blocks identical resubmits. |
+| `engine_classes` | Admin-managed keyword groups (`name`, `keywords[]`, `sort_order`) that collapse free-text engine names into one class. |
+
+| Function / trigger | What it does |
+|---|---|
+| `classify_engine(text)` | SECURITY DEFINER — first class whose any keyword is a substring of the engine key (by `sort_order`). |
+| `leaderboard_set_class` | BEFORE INSERT on `leaderboard_entries`: auto-fills `engine_class_id` when the client didn't pin one. |
+| `reclassify_entries()` | Admin RPC — re-runs `classify_engine` for every `class_source='auto'` row (manual overrides are protected). |
+
+**RLS.** `leaderboard_entries`: `select` for **anon + authenticated** where
+`status='approved'` (or own); users `insert`/`delete` their own; admins
+(`has_role`) `select` all + `update` (status / class / notes). `engine_classes`:
+public `select`, admin-only writes. Moderation is **allow-by-default** — entries are
+visible immediately and only an admin **deny** hides them.
+
+**Browse model.** The page selects only the light columns (no `data`) for all
+approved rows and aggregates the Track→Course→engine/weight tree client-side
+(`lib/leaderboardBrowse.ts`); opening a group re-queries the chosen ids **with
+`data`** (`lib/leaderboardSession.ts` transposes them into one synthetic read-only
+session). Promote to RPCs / a materialized view if row volume grows.
+
+---
+
 ## Subscriptions / Stripe (`..._stripe_subscriptions.sql`, `..._subscription_grace_trim.sql` + 4 edge functions)
 
 Paid tiers scale **one pooled cloud-storage budget** that documents + logs +
@@ -213,7 +247,11 @@ tab (`src/components/admin/UsersTab.tsx`). Service-role actions:
 Submissions are attributed to a signed-in contributor via
 `submissions.submitted_by_user_id`, which the `submit-track` edge function derives
 from the caller's **verified JWT** (never a client-supplied id; anonymous stays
-`NULL`). The admin Submissions tab resolves it to a `profiles.display_name`.
+`NULL`). The admin Submissions tab resolves it to a `profiles.display_name`. The
+Turnstile CAPTCHA is **skipped for signed-in submitters** (they're accountable via
+their account; IP ban + rate limit still apply) — this lets a custom track
+auto-submit alongside a leaderboard snapshot (`plugins/cloud-sync/trackAutoSubmit`)
+with no interactive CAPTCHA.
 
 **Client wiring** (core, not the cloud-sync plugin — billing is account-level and
 PricingCards renders even with cloud disabled): `lib/billing.ts` is the pure,
@@ -269,9 +307,10 @@ JWT manually):
 - `request-account-deletion` — auth user → inserts an `account_deletions` row
   `scheduled_for = now()+7d` (idempotent; never shortens an in-flight request).
 - `process-account-deletions` — **cron-only** (`x-cron-secret` must equal
-  `DELETION_CRON_SECRET`). For each due user: removes their `user-files` Storage
-  objects, then `auth.admin.deleteUser` (cascades profiles/sync_records/
-  subscription/roles/account_deletions via FKs).
+  `DELETION_CRON_SECRET`). For each due user: `auth.admin.deleteUser` (cascades
+  profiles/sync_records/public_vehicles/subscription/roles/account_deletions via
+  FKs), then removes their `user-files` **and** `user-avatars` Storage objects
+  (buckets aren't FK-cascaded).
 
 Scheduling: the migration always schedules the IP purge (pure SQL). The deletion
 worker is auto-wired via `pg_cron` + `pg_net` **only if** a Vault secret
diff --git a/docs/ble.md b/docs/ble.md
index 365d863c..598202f3 100644
--- a/docs/ble.md
+++ b/docs/ble.md
@@ -19,9 +19,12 @@ tile mounts `DataloggerDownload` — the lazy Web Bluetooth flow — on demand,
 `lib/ble/*` stays out of the initial bundle while the menu still opens instantly.
 On the native (Tauri) shell the webview has no Web Bluetooth, so the Fledgling tile
 instead mounts the lazy `DovesloggerDownload` flow (BLE over native IPC: scan →
-pick device → connect → list → download), and the MyChron tile mounts the lazy
-`MyChronDownload` flow (Wi-Fi over native IPC — see `docs/android.md`); on the web
-the MyChron and Alfano tiles still open explanatory dialogs.
+pick device → connect → list → download), the MyChron tile mounts the lazy
+`MyChronDownload` flow (Wi-Fi over native IPC — see `docs/android.md`), and the
+Alfano tile mounts the lazy `AlfanoDownload` flow (Bluetooth serial over native IPC
+— SKELETON, Rust backend TBD); on the web the MyChron and Alfano tiles open
+explanatory dialogs instead (Alfano uses Bluetooth serial / Classic Bluetooth SPP,
+which Web Bluetooth — BLE GATT only — can't reach, so it has no web path at all).
 
 `DataloggerDownload` talks to the device only through the generic
 `LoggerConnection` interface (`src/lib/loggers/`): `listLogs` / `downloadLog` /
@@ -29,13 +32,15 @@ the MyChron and Alfano tiles still open explanatory dialogs.
 is the second adapter — `createMychronConnection()` (`src/lib/loggers/mychron/`),
 native-only, over the Tauri shell — and DovesLogger is the third —
 `createDovesloggerConnection()` (`src/lib/loggers/doveslogger/`), the native-BLE
-path for the same Fledgling hardware over the Tauri shell. Both native loggers share
-the kind-agnostic IPC client in `src/lib/loggers/native/ipc.ts` (only their
-`connect` / `scan` differ); Alfano (web BLE) will be a fourth. All satisfy the same
+path for the same Fledgling hardware over the Tauri shell. The Alfano adapter —
+`createAlfanoConnection()` (`src/lib/loggers/alfano/`), native Bluetooth-serial over
+the Tauri shell — is the fourth, a skeleton whose Rust backend is still TBD. The
+native loggers all share the kind-agnostic IPC client in
+`src/lib/loggers/native/ipc.ts` (only their `connect` / `scan` differ). All satisfy the same
 interface, and `DeviceContext.loggerKind` records which logger is connected so
 Fledgling-only surfaces (settings / tracks / firmware) can gate themselves
-(`supportsDeviceDetails` is `false` for MyChron and for the native DovesLogger path,
-whose settings/tracks/firmware stay on the Web Bluetooth build for now). The pure progress formatters
+(`supportsDeviceDetails` is `false` for MyChron, Alfano, and the native DovesLogger
+path, whose settings/tracks/firmware stay on the Web Bluetooth build for now). The pure progress formatters
 (`formatBytes` / `formatSpeed` / `formatTime`) and the `computeProgress()` helper now
 live transport-neutrally in `src/lib/loggers/progress.ts` (re-exported from
 `src/lib/ble/format.ts` for existing BLE callers) so both flows share them without
diff --git a/docs/plans/0005-leaderboards.md b/docs/plans/0005-leaderboards.md
new file mode 100644
index 00000000..25218814
--- /dev/null
+++ b/docs/plans/0005-leaderboards.md
@@ -0,0 +1,291 @@
+# Plan 0005 — Leaderboards
+
+## Context
+
+Dove's DataViewer / LapWing already lets a driver freeze a "course fastest lap"
+as a **snapshot** (`lib/lapSnapshot.ts`) — GPS samples ±5 s, frozen course
+geometry, engine string, and a copy of the vehicle/setup. Snapshots are
+per-(course, engine), immutable, and already cloud-synced (`lap_snapshots`
+table). They are the perfect unit for a **community leaderboard**: each one is a
+single verified lap with everything needed to compare and replay it.
+
+This plan adds a public **Leaderboards** feature: users opt-in submit their
+snapshots; anyone (signed-in or not) can browse tracks → courses → engine/weight
+groups; clicking a group launches the existing telemetry viewer in a new
+**read-only mode** showing every entry as a lap (fastest = lap 1). Admins get a
+moderation panel (approve/deny, default-allow) plus an engine **classification
+system** so "Tillotson 225" / "225RS" / "Tilly" collapse into one group without
+touching user data.
+
+Built almost entirely inside the existing **cloud-sync plugin** + **admin panel**
++ a new **`/leaderboards`** route, reusing the modular session/viewer pipeline.
+
+### Decisions locked with the maintainer
+- **Privacy:** GPS, engine name/class, and the **listed weight** are always
+  public. **Engine-telemetry channels** (`rpm`, `water_temp`, `oil_temp`, `egt`,
+  `temp_1`, `temp_2` — the Engine/sensors group in `channels.ts`) are **hidden by
+  default** with an opt-in "share publicly" toggle.
+  - **Post-launch amendment (migration `..._leaderboards_drop_setup.sql`):** setup
+    sharing was removed entirely — it made people uneasy. Setup data is never
+    uploaded; the `setup_public` column + the setup-share toggle were dropped.
+- **Weight:** comes from the vehicle's existing `weight`/`weightUnit` (`Kart` in
+  `kartStorage.ts`). Snapshot save must start capturing it. At submission the
+  **"Listed weight"** (public, groups exact-match) defaults to the vehicle weight;
+  the user may override it (privacy — e.g. show 365 lb when they're really 375).
+  If the vehicle has no weight, a Listed weight is **required** (non-zero) to
+  submit. (Term: **"Listed weight"**, not "mask weight".)
+- **Entry volume:** the Leaderboards page has a **"Show top"** selector
+  (3 / 10 / 25 / 50 / 100 / All, default **50**) controlling how many entries a
+  group loads into the viewer — user can choose to overload their own machine.
+- **Viewer delivery:** **reuse the main viewer** (`Index.tsx`) via an in-app
+  handoff; no separate viewer page, not URL-shareable in v1.
+
+---
+
+## Part A — Data model (Supabase)
+
+New migration `supabase/migrations/20260626000000_leaderboards.sql` (follow the
+patterns in `20260529000000_lap_snapshots.sql` and `submissions`):
+
+### Table `leaderboard_entries` — one row per submitted snapshot
+Columns: `id uuid pk`, `user_id uuid → auth.users on delete cascade`,
+`display_name text` (denormalized submitter profile name — the public label /
+lap label, stable across renames), `track_name`, `course_name`, `course_key`,
+`direction text null`, `engine text` (raw user string, never mutated),
+`engine_key text` (normalized), `engine_class_id uuid null → engine_classes`
+(auto-set by classifier, **admin-overridable** — the grouping key),
+`listed_weight numeric`, `listed_weight_unit text` (`'lb'|'kg'`),
+`lap_time_ms integer`, `content_hash text` (anti-resubmit),
+`setup_public boolean default false`, `engine_telemetry_public boolean default false`,
+`data jsonb` (clean-lap samples + frozen `Course` + `lapStartMs/lapEndMs`
+[+ `setup` only when `setup_public`]; engine-telemetry channels stripped from
+samples + fieldMappings unless `engine_telemetry_public`),
+`status text default 'approved' check (status in ('approved','denied'))`,
+`created_at`, `reviewed_at`, `reviewed_by uuid null`, `admin_notes text null`.
+- `unique (user_id, content_hash)` — a user can't resubmit an identical snapshot.
+- Indexes: `(course_key)`, `(status)`, `(engine_class_id)`.
+- **RLS:** `select` to `anon, authenticated` where `status='approved'`; `insert`
+  to `authenticated` with `auth.uid()=user_id`; `delete` own (withdraw); admins
+  (`has_role(auth.uid(),'admin')`) `select` all + `update` (status / class /
+  notes). No user UPDATE.
+
+### Table `engine_classes` — admin-managed classification
+Columns: `id uuid pk`, `name text` (canonical display, e.g. "Tillotson 225"),
+`keywords text[]` (substrings matched case-insensitively against `engine_key`),
+`sort_order int default 0`, `created_at`, `updated_at`.
+- **RLS:** `select` to `anon, authenticated` (labels + grouping); all writes
+  admin-only.
+
+### Classification (server-side, automatic)
+- SQL helper `classify_engine(p_engine_key text) returns uuid` — first
+  `engine_classes` row whose any keyword is a substring of the key (ordered by
+  `sort_order`), else null.
+- BEFORE INSERT trigger on `leaderboard_entries`: if `engine_class_id` is null,
+  set it via `classify_engine(NEW.engine_key)`.
+- Admin RPC `reclassify_entries()` (SECURITY DEFINER, admin-guarded) re-runs
+  classification across rows whose class was never admin-set — call after editing
+  classes. (Track admin-set vs auto via a nullable `class_locked boolean` or a
+  `reviewed_by`/explicit flag — use a `class_source text default 'auto'` set to
+  `'admin'` on override so reclassify skips locked rows.)
+
+### Browse aggregates
+For v1, **no custom aggregate RPCs**: the Leaderboards page selects only the
+**light columns** (everything except `data`) where `status='approved'` and
+aggregates client-side into the accordion (track list, course list, engine/weight
+groups, counts, fastest lap). Fetch `engine_classes` once for labels. Only when a
+group is opened do we re-query the chosen rows **with `data`**, ordered by
+`lap_time_ms asc`, `limit <Show-top N>`. Note this in the plan as the scaling
+seam — promote to RPCs/materialized view if volume explodes.
+
+### `config.toml`
+No new edge function needed (submission is a direct RLS insert, mirroring how
+`cloud-sync` already inserts `lap_snapshots`). Moderation rides RLS admin
+policies through the existing DB layer.
+
+---
+
+## Part B — Snapshot capture gains weight
+
+- `lib/lapSnapshot.ts`: extend `SnapshotVehicle` with `weight?: number` and
+  `weightUnit?: "lb" | "kg"`. No behavior change otherwise.
+- `hooks/useLapSnapshots.ts` (~line 122): include `weight`/`weightUnit` when
+  building the `vehicle` object passed to `buildSnapshot`.
+- Pure-logic test in `lib/lapSnapshot.test.ts` covering the new fields.
+- No `DB_VERSION` bump: snapshots are stored as jsonb (IndexedDB `lap-snapshots`
+  + cloud), so the added field is forward/back compatible.
+
+---
+
+## Part C — Submission (cloud-sync plugin, Profile tab)
+
+New first-party content under `src/plugins/cloud-sync/`:
+
+- **`leaderboardClient.ts`** — untyped table access mirroring `cloudClient.ts`
+  (`supabase.from("leaderboard_entries")`, `engine_classes`), plus `fetchMyEntries`,
+  `submitEntries(rows)`, `withdrawEntry(id)`.
+- **`lib/leaderboardSubmission.ts`** (pure, unit-tested):
+  - `contentHashForSnapshot(snap)` — stable hash over immutable identity
+    (`lapTimeMs` + `recordedAt` + `courseKey` + sample count + first/last coords).
+    Reuse the FNV-1a approach already in `lib/trackSubmission.ts`.
+  - `buildEntryPayload(snap, { setupPublic, engineTelemetryPublic, listedWeight,
+    listedWeightUnit, displayName })` — trims samples to the clean lap
+    (`snapshotLapSamples`), strips the engine-telemetry channel group from samples
+    + `fieldMappings` unless shared, drops `setup` unless shared, returns the
+    `leaderboard_entries` row.
+- **`LeaderboardSubmitPanel.tsx`** — a new `PanelSlot.Profile` panel (register in
+  `cloud-sync/index.ts` alongside `StoragePanel`/`LapSnapshotsPanel`). Visible only
+  when signed in **and** `listSnapshots()` returns ≥1. Shows a **"Submit to
+  leaderboards"** button → dialog listing each snapshot with: per-snapshot
+  **Listed weight** (prefilled from `snap.vehicle.weight`, required if missing),
+  **Share setup** toggle (default off), **Share engine data** toggle (default off),
+  and a persistent notice that **GPS, engine, and weight are public**. Already-
+  submitted snapshots (hash in the local submitted-set) show "Submitted" and are
+  disabled.
+- **Local submitted-set**: persist submitted content-hashes in the plugin KV store
+  (`ctx.storage`, same idea as `trackSubmission`'s submitted records) so the UI
+  can mark/disable resubmits offline, independent of the DB unique constraint.
+
+---
+
+## Part D — Browse page (`/leaderboards`)
+
+- **Reusable header refactor:** extract the Landing sticky banner into
+  `src/components/SiteHeader.tsx` (sponsor + settings slot + profile/sign-in, plus
+  optional `showSupportedFiles` / `showAbout`). `LandingPage.tsx` renders it with
+  both on; `Leaderboards.tsx` renders it with both **off**. Keeps Golden Rule #2
+  (reuse) and guarantees the banners stay identical.
+- **`src/pages/Leaderboards.tsx`** (lazy route, added in `App.tsx` above the
+  catch-all, gated `{enableCloud && <Route path="/leaderboards" .../>}`):
+  - Uses `useSettings()` for a standalone `<SettingsModal>` in the header; profile
+    button navigates `'/'` with `state:{ openProfile:true }` (Index opens the
+    profile drawer from that state — small addition to `Index.tsx`); sign-in →
+    `/login`.
+  - **"Show top"** selector (3/10/25/50/100/All, default 50) at the top.
+  - **Accordion hierarchy** (shadcn `Accordion`, reusing the data-bubble styling
+    already used elsewhere): **Track** rows (bubbles: engine count via class
+    grouping, record count, track fastest lap) → expand to **Course** rows → expand
+    to **engine/weight groups** with a **"Group by weight"** toggle (exact-weight
+    match only). Empty state: "No submissions yet :(".
+  - Group label = `engine_classes.name` when classified else raw `engine`
+    (+ ` · <weight><unit>` when grouped by weight).
+  - Clicking a group: fetch that group's rows **with `data`** (ordered fastest
+    first, `limit N`), call `buildLeaderboardSession(...)`, push the bundle to the
+    handoff store, `navigate('/')`.
+- **Landing entry point:** add a **"Leaderboards"** `ActionTile` (Route icon) to
+  the `LandingPage.tsx` action grid (gated `enableCloud`) → `navigate('/leaderboards')`.
+
+---
+
+## Part E — Read-only viewer (reuse `Index.tsx`)
+
+- **`lib/leaderboardSession.ts`** (pure, unit-tested) —
+  `buildLeaderboardSession(entries, course)` returns
+  `{ data: ParsedData, course, selection, laps: Lap[], lapLabels: Record<number,string>, descriptor }`:
+  - Concatenate each entry's clean-lap samples with **cumulative `t` offsets**
+    (fastest entry first → lap 1).
+  - One `Lap` per entry (`startIndex`/`endIndex`, `lapTimeMs`, speed stats);
+    `lapLabels[lapNumber] = entry.display_name`.
+  - Union all entries' `fieldMappings`; `bounds` via `calculateBounds`
+    (`lib/parserUtils.ts`); set `dovexMetadata.lapTimesMs`.
+  - `descriptor` = `{ courseName, engineLabel, weightLabel }` for the LapTimes
+    header text.
+- **`lib/leaderboardHandoff.ts`** — module-level singleton (same shape as
+  `lib/fileLoadingState.ts`): `setPendingLeaderboardSession(bundle)` /
+  `takePendingLeaderboardSession()` (consume-once).
+- **`Index.tsx` read-only mode:**
+  - On mount, `takePendingLeaderboardSession()`; if present, load its `data` via
+    the existing `handleDataLoaded` path and set `readOnly=true` holding the
+    injected bundle.
+  - **Feed `SessionContext` from the injected bundle when `readOnly`** (laps,
+    course, selection, plus new optional `lapLabels` + `readOnlyDescriptor` on
+    `SessionContextValue`), bypassing the `useLapManagement` detection output —
+    do **not** rewrite `useLapManagement`; just choose the source feeding the
+    memo'd `sessionContextValue` (and the header lap dropdown). This keeps the
+    concatenated multi-driver samples from being re-lap-detected.
+  - **Header:** alert/warning chrome via the existing `--warning` token (same
+    token the preview-build footer uses) + a "Read-only leaderboard view" label
+    and an **Exit** button (`navigate('/leaderboards')`).
+  - **Hide/disable when `readOnly`:** Coach / Tools / Setups&Notes tabs (extend
+    the `showCoach && …` pattern in the `TabBar`), the **snapshots** button
+    (`LapSnapshotControls`), **video** (skip the `VideoPlayer` mount / `useVideoSync`
+    load), and **weather** (skip `onWeatherStationResolved` / weather UI).
+  - **Lap labels:** in the header lap `<Select>` and in `LapTable.tsx`, render
+    `lapLabels[lap.lapNumber] ?? "Lap N"` instead of the bare number (read
+    `lapLabels` from `SessionContext`; falls back to the number when absent, so
+    normal sessions are unchanged).
+  - **LapTimes header text:** when `readOnlyDescriptor` is present, render a line
+    above the table — course name, engine class, weight class — using the empty
+    top space in `LapTimesTab`/`LapTable`.
+
+---
+
+## Part F — Admin panel
+
+- **DB layer** (`src/lib/db/types.ts` + `supabaseAdapter.ts`): extend
+  `ITrackDatabase` with leaderboard methods — `getLeaderboardEntries(filter)`,
+  `updateLeaderboardEntry(id, { status?, engineClassId?, adminNotes? })`,
+  `getEngineClasses()`, `createEngineClass`/`updateEngineClass`/`deleteEngineClass`,
+  `reclassifyEntries()`. All run under the admin RLS policies / RPC.
+- **`src/components/admin/LeaderboardsTab.tsx`** — new admin tab (register in
+  `Admin.tsx` tab list, mirroring `SubmissionsTab`): list entries with filters
+  (status / track / engine), per-row **Approve/Deny**, **engine-class override**
+  dropdown (sets `class_source='admin'`), and `admin_notes`. Shows `display_name`,
+  raw `engine`, listed weight, lap time. A small map/lap preview is optional v1.
+- **`EngineClassesTab.tsx`** (or a section within LeaderboardsTab) — CRUD for
+  `engine_classes` (name + keyword list) and a **"Reclassify"** button →
+  `reclassifyEntries()`.
+
+---
+
+## Part G — Docs, changelog, tests
+
+- **Plan doc:** save this as `docs/plans/0005-leaderboards.md`; cite `plan 0005`
+  in every related commit (Golden Rule #8).
+- **CHANGELOG.md:** open a new beta heading `## [2.10.0] - unreleased` (latest
+  released is `2.9.2`; maintainer confirms the number) and add the user-facing
+  Leaderboards entry there, appending as work lands (Golden Rule #4).
+- **Docs in sync (Golden Rule #5):** `docs/backend.md` (new tables, RLS,
+  classification), CLAUDE.md architecture map (new route/page, cloud-sync panel,
+  admin tab, `leaderboardSession`/`leaderboardHandoff`/`leaderboardSubmission`
+  modules), `README.md` feature list. No new FOSS dependency → CreditsDialog
+  untouched.
+- **Tests (Golden Rule #3):** Vitest for the pure modules —
+  `leaderboardSubmission` (hashing, payload trim/strip of setup + engine channels,
+  listed-weight validation), `leaderboardSession` (cumulative offsets, one lap per
+  entry, lap labels, fastest-first ordering), and the `lapSnapshot` weight capture.
+
+---
+
+## Files (representative)
+- **New SQL:** `supabase/migrations/20260626000000_leaderboards.sql`
+- **New libs:** `src/lib/leaderboardSession.ts`, `src/lib/leaderboardHandoff.ts`,
+  `src/plugins/cloud-sync/lib/leaderboardSubmission.ts`,
+  `src/plugins/cloud-sync/leaderboardClient.ts`
+- **New UI:** `src/pages/Leaderboards.tsx`, `src/components/SiteHeader.tsx`,
+  `src/plugins/cloud-sync/LeaderboardSubmitPanel.tsx`,
+  `src/components/admin/LeaderboardsTab.tsx` (+ engine classes)
+- **Edited:** `src/App.tsx` (route), `src/components/LandingPage.tsx` (SiteHeader +
+  tile), `src/pages/Index.tsx` (read-only mode, handoff consume, open-profile
+  state), `src/contexts/SessionContext.tsx` (`lapLabels`, `readOnlyDescriptor`),
+  `src/components/LapTable.tsx` + `tabs/LapTimesTab.tsx` (labels + header text),
+  `src/lib/lapSnapshot.ts` + `src/hooks/useLapSnapshots.ts` (weight capture),
+  `src/lib/db/types.ts` + `supabaseAdapter.ts`, `src/pages/Admin.tsx`,
+  `src/plugins/cloud-sync/index.ts` (register panel)
+
+## Verification
+- `bun run lint`, `bun run typecheck`, `bun run test:run`, `bun run build` all
+  green (Golden Rule #6).
+- New Vitest suites for `leaderboardSession`, `leaderboardSubmission`, snapshot
+  weight pass.
+- Apply the migration to the preview/beta Supabase; manual end-to-end on
+  `bun run dev`:
+  1. Assign a vehicle with a weight, snapshot a lap → snapshot carries weight.
+  2. Profile → "Submit to leaderboards" → toggles default to private; submit;
+     re-open shows "Submitted" and blocks an identical resubmit (unique hash).
+  3. `/leaderboards` lists the track → course → engine/weight group with correct
+     bubbles + "Group by weight" toggle; "Show top" changes loaded count.
+  4. Open a group → main viewer in read-only mode: warning header, Coach/Tools/
+     Setups hidden, no video/weather/snapshots; lap list + LapTable show submitter
+     names; LapTimes header shows course/engine/weight; lap 1 is the fastest.
+  5. Admin → Leaderboards tab: deny an entry (drops from public list), override
+     its engine class (regroups), edit engine classes + reclassify.
diff --git a/docs/plans/0006-user-profiles.md b/docs/plans/0006-user-profiles.md
new file mode 100644
index 00000000..6104bf22
--- /dev/null
+++ b/docs/plans/0006-user-profiles.md
@@ -0,0 +1,81 @@
+# Plan 0006 — User Profiles
+
+Status: implemented on branch `claude/user-profiles-images-fheq7s`.
+
+## Why
+
+Leaderboards (plan 0005) gave the app its first public, anonymous-readable cloud
+surface, but user identity was just a `display_name` on a `profiles` table that
+was authenticated-read only, case-sensitively unique, and had no avatar. This plan
+rounds out the web app with **public driver profiles**: a face (avatar), a name you
+can't impersonate by changing case, a sharable page showing a driver's vehicles and
+uploaded leaderboard snapshots, and avatar thumbnails on the Leaderboards.
+
+## What shipped
+
+1. **Avatars.** Tap the profile picture on the Profile tab → on-device 1:1 centre-crop +
+   downscale to ≤256px (`src/lib/imageCrop.ts`, pure + tested) → upload to a new **public**
+   `user-avatars` bucket. The fixed object path + an `avatar_updated_at` `?v=` cache-buster
+   make replacements repaint.
+2. **Case-insensitive unique display names.** A destructive pre-flight de-dups any
+   case-collisions (acceptable at ~5 users), then a `unique index on lower(display_name)`
+   replaces the case-sensitive constraint. The `random_display_name`/`unique_display_name`
+   SQL functions now compare case-insensitively. `/driver/:username` resolves via `.ilike`.
+3. **Public `/driver/:username` page** (`src/pages/DriverProfile.tsx`, lazy, anon): avatar +
+   name, the driver's **opt-in vehicles** (name/type/engine/number — never weight/setup), and
+   approved leaderboard entries grouped by **course → weight** (`src/lib/driverProfileGroups.ts`,
+   pure + tested). Unknown name → a "not found" state that keeps the header + back button.
+4. **Opt-in vehicle publishing.** `Vehicle.publicProfile` flag (a *Show on profile* toggle in
+   `VehiclesTab`) drives a public-safe projection into a new `public_vehicles` table, synced off
+   the existing garage-change path (`autoSync.pushOne` → `publicVehicleSync.ts`). Unflag/delete
+   removes the public row. Best-effort (self-heals on the next edit); the private `sync_records`
+   backup is unchanged.
+5. **Copy profile link** button under Sign out; **avatar thumbnails** left of names on
+   Leaderboards rows; **← Back to home** on both off-session pages (`BackToHome.tsx`).
+
+## Backend (two migrations)
+
+- `20260627120000_profiles_ci_avatars.sql` — de-dup, `lower(display_name)` unique index,
+  `avatar_path` + `avatar_updated_at` columns, CI name-resolution functions, and a
+  column-limited anon-readable `public_profiles` **view** (RLS can't restrict columns, so a
+  view is the right tool — exposes only `user_id, display_name, avatar_*`).
+- `20260627120100_public_vehicles_and_avatar_bucket.sql` — `public_vehicles` table (anon read,
+  owner write; FK-cascades on account delete), the public `user-avatars` bucket + owner-folder
+  write policies.
+- `process-account-deletions` now also empties the `user-avatars/{uid}/` folder (Storage objects
+  aren't FK-cascaded).
+
+## Key constraint honoured
+
+`vendor-supabase` stays off the eager Index/Landing graph: all new Supabase access lives in
+lazy `src/plugins/cloud-sync/*` (`publicProfile.ts`, `publicVehicleSync.ts`, avatar helpers in
+`profile.ts`) or the lazy `DriverProfile` page, reached only via dynamic import. Build confirms
+`DriverProfile`/`publicProfile` are their own chunks. `imageCrop.ts` is Supabase-free.
+
+## Files
+
+- Migrations: `supabase/migrations/20260627120000_*.sql`, `..._120100_*.sql`;
+  `supabase/functions/process-account-deletions/index.ts`.
+- New: `src/lib/imageCrop.ts`, `src/lib/driverProfileGroups.ts`, `src/pages/DriverProfile.tsx`,
+  `src/components/BackToHome.tsx`, `src/components/ProfileAvatar.tsx`,
+  `src/plugins/cloud-sync/publicProfile.ts`, `src/plugins/cloud-sync/publicVehicleSync.ts`,
+  `src/locales/*/driver.json` (+ tests for the pure utils).
+- Edited: `cloudClient.ts`, `profile.ts`, `leaderboardClient.ts`, `leaderboardBrowse.ts`
+  (`GroupEntry.userId`), `autoSync.ts`, `vehicleStorage.ts`, `VehiclesTab.tsx`, `StoragePanel.tsx`,
+  `Leaderboards.tsx`, `App.tsx`, i18n config/typing + `common`/`plugins`/`drawer` locales.
+
+## Verification
+
+`bun run lint`, `bun run typecheck`, `bun run test:run` (2051 pass), `bun run build` all green.
+Manual end-to-end (staging Supabase needed): apply both migrations; upload/replace an avatar;
+toggle a vehicle public on/off and confirm the `public_vehicles` row appears/disappears with no
+weight column; open `/driver/<Name>` signed-out incognito (and a different-case URL); copy the
+profile link; confirm the Leaderboards thumbnail and back-to-home button.
+
+## Follow-ups
+
+- Other languages were stop-gap seeded with the English strings (no API key in this
+  environment); run `bun run i18n:seed` to machine-translate the new `driver` namespace + the
+  added `common`/`plugins`/`drawer` keys (they carry no `_sourceHashes`, so they'll be picked up).
+- Confirm the `public_profiles` view's definer-vs-`security_invoker` semantics on the target
+  Postgres before relying on anon reads.
diff --git a/docs/plans/0007-dynamic-supabase-branch-db.md b/docs/plans/0007-dynamic-supabase-branch-db.md
new file mode 100644
index 00000000..48af5cd6
--- /dev/null
+++ b/docs/plans/0007-dynamic-supabase-branch-db.md
@@ -0,0 +1,102 @@
+# Plan 0007 — Dynamic per-branch Supabase preview database
+
+## Goal / problem
+
+Branch-specific front-end previews should talk to **branch-specific Supabase
+preview databases**, automatically, without merging into beta first.
+
+Today the wiring is half-built:
+
+- **Front-end:** Cloudflare Workers Builds deploys every non-`main` branch as a
+  preview. `vite.config.ts` bakes Supabase creds in **at build time**; on a
+  preview build the `pick()` helper prefers `*_PREVIEW` env vars.
+- **The catch:** those `*_PREVIEW` vars are a *single static set* configured once
+  in the Worker settings — they point at **one fixed DB (beta)**. So every branch
+  preview hits the same beta DB. The only way to exercise a migration is to merge
+  it into beta so the beta DB updates.
+- **Supabase side:** Branching is enabled, so Supabase spins up a fresh
+  **preview-branch database** per git branch — *but only when that branch carries
+  migration changes* — each with its own project ref, API URL and anon key.
+  Nothing told the front-end build those creds existed, so they went unused.
+
+The missing piece is the link between "this git branch's Supabase preview DB" and
+"this git branch's front-end build."
+
+## Approach & key decisions
+
+**Build-time resolution via the Supabase Management API.** During the Cloudflare
+build, ask the Management API whether a preview branch exists for the current git
+branch (`WORKERS_CI_BRANCH`); if so, bake *its* creds in. If not, fall back to the
+existing static `_PREVIEW`/beta creds — i.e. today's behaviour, untouched.
+
+Flow (`scripts/resolveSupabaseBranch.ts`):
+1. Skip entirely unless it's a **feature-branch** build with a `SUPABASE_ACCESS_TOKEN`
+   — i.e. a branch that is neither `main` nor `BETA`. (`BETA` is the shared
+   integration DB and always uses the static `*_PREVIEW` creds; only feature
+   branches get their own per-branch database.)
+2. `GET /v1/projects/{prodRef}/branches` → find the non-default branch whose
+   `git_branch` matches the build's branch.
+3. **No match** → return null. This is the common "no DB changes, so Supabase made
+   no branch" case — fall back to beta.
+4. Match but **not healthy** (`status` not in `MIGRATIONS_PASSED` /
+   `FUNCTIONS_DEPLOYED` / `ACTIVE_HEALTHY`) → null. Never point a front-end at a
+   half-provisioned or migration-failed DB.
+5. Healthy → URL `https://{branch.project_ref}.supabase.co`, anon key via
+   `GET /v1/projects/{branch.project_ref}/api-keys`. Return `{ url, anonKey, projectId }`.
+
+`vite.config.ts` calls this (the config factory is now `async`) and threads the
+result into `pick()` as the **top-precedence override** for the three Supabase
+keys only. Everything else flows through the existing precedence chain.
+
+**Why build-time, not a runtime `config.json`?** The whole app is offline-first
+with build-time-baked creds (see the `pick()` comment — "the only place to switch
+backends"). A runtime config endpoint would add a network dependency on load and
+fight that model. Build-time resolution drops into the existing seam with one new
+secret and zero runtime cost. Rejected: runtime config.
+
+**Safety — a backend lookup must never break a deploy.** The resolver never
+throws: it has a 10s timeout, treats any non-OK/parse/network error as "fall
+back", and returns null on every failure path. The static beta creds remain the
+floor, so the worst case is "preview points at beta" — exactly where we are today.
+
+**Why `scripts/`, not `src/`?** It's CI-only build tooling, never shipped to the
+client, so it stays out of the app source tree and out of the `src/`-scoped
+coverage report. `vitest.config.ts` gains a `scripts/**/*.test.ts` include so the
+pure logic is still unit-tested.
+
+## Touch points
+
+- `scripts/resolveSupabaseBranch.ts` — the resolver (new).
+- `scripts/resolveSupabaseBranch.test.ts` — unit tests (new).
+- `vite.config.ts` — async factory; `pick()` gains an override arg; resolves
+  `branchBackend` on preview builds and threads it into the 3 Supabase keys.
+- `vitest.config.ts` — include `scripts/**/*.test.ts`.
+- `README.md`, `CLAUDE.md` — `SUPABASE_ACCESS_TOKEN` env var + operator steps.
+
+## Operator setup (one-time)
+
+1. Create a Supabase **personal access token** (Account → Access Tokens) with
+   access to the project.
+2. Add it as a **secret** in the Worker → Settings → Build → Variables and
+   Secrets: `SUPABASE_ACCESS_TOKEN`. (The static `*_PREVIEW` beta creds stay as
+   the fallback.)
+3. Add each preview branch's Cloudflare preview URL to that branch's Supabase
+   **Auth → Redirect URLs** if cloud sign-in is needed on it.
+
+> **"Branches aren't always generated."** That's inherent to Supabase Branching —
+> a preview branch is created only when the branch has migration changes. This
+> design embraces that: branches *with* DB changes get their own DB; branches
+> without fall back to beta. If you want a branch DB regardless, push a no-op
+> migration, or create the branch manually in the Supabase dashboard so the
+> Management API lists it.
+
+## Status / phasing
+
+- **Done:** resolver + tests, vite wiring, docs. Green across lint / typecheck /
+  test / build. With no `SUPABASE_ACCESS_TOKEN` set, behaviour is byte-identical
+  to before (resolver short-circuits to null).
+- **Pending (operator):** add the `SUPABASE_ACCESS_TOKEN` secret in Cloudflare to
+  activate it.
+- **Follow-ups:** if the new publishable/secret API-key scheme fully replaces the
+  legacy `anon` key on branches, confirm `pickAnonKey` still finds a usable
+  publishable key (it already falls back to `name === "publishable"`).
diff --git a/docs/reviews/beta-release-review-2026-06-30.md b/docs/reviews/beta-release-review-2026-06-30.md
new file mode 100644
index 00000000..249b682f
--- /dev/null
+++ b/docs/reviews/beta-release-review-2026-06-30.md
@@ -0,0 +1,76 @@
+# Beta → Main Release Review — 2026-06-30
+
+> Posted as a comment on PR #307. This is the local record copy.
+> **Follow-up:** all six findings below were fixed on branch `fix/release-review-lows`
+> (PR into BETA) — see the CHANGELOG `[3.0.0]` engine entry, `Leaderboards.tsx` /
+> `ProfileAvatar.tsx` fixes, the new `publicProfile.test.ts` / `trackAutoSubmit.test.ts`,
+> and the `0006 → 0007` branch-db plan rename.
+
+## 🚦 Verdict: **GO**
+
+Safe to ship. All seven dimensions ran; every confirmed finding is **Low** severity and **none block the release**. Blockers: **0 Critical, 0 release-blocking High**.
+
+**PR:** #307 (`BETA` → `main`) · **Release:** v3.0.0 · **Since:** v2.9.2
+**Run:** multi-agent (7 finders, single adversarial verify per finding — 6/6 confirmed, 0 dropped) · **Diff:** 145 files, ~7,000 insertions across 17 merged PRs
+**Excluded:** `node_modules/`, `dist/`, generated `src/integrations/supabase/`, `bun.lock` line-noise
+
+### Release contract checklist
+| Gate | Status |
+|------|--------|
+| Coach on production npm (`@perchwerks/eye-in-the-sky@0.5.0`, both `package.json` + `vite.config.ts` + `bun.lock`) | ✅ |
+| `package.json` version (`3.0.0`) == topmost CHANGELOG heading (`[3.0.0]`) | ✅ |
+| CHANGELOG heading dated (`2026-06-30`, not `- unreleased`) | ✅ |
+| CHANGELOG complete vs commits in this release | ⚠️ one user-facing change missing (REL-01, Low) → since fixed |
+| No beta/preview-only config leaked into prod path (`main` → production creds; resolver gated to feature branches) | ✅ |
+| CI green (ESLint / tsc -b / Vitest / coverage / build / CodeQL) | ✅ 11/11 |
+
+> The coach pin is exact `0.5.0` rather than tilde `~0.5.0`. It is the published production package (not the BETA git dep), so the gate passes.
+
+## Summary
+
+| Severity | Count |
+|----------|-------|
+| Critical | 0 |
+| High     | 0 |
+| Medium   | 0 |
+| Low      | 6 |
+
+Large but well-structured release (leaderboards plan 0005 + user profiles plan 0006 + branch-tiered Supabase backend + Alfano scaffolding + request-datalogger + full i18n). **Security, performance/bundle-budget, and merge/migration integrity all came back clean.** The six findings are polish.
+
+## Findings (Low — by dimension)
+
+### REL-01 — CHANGELOG omits the "engine now required on every vehicle" change
+- `CHANGELOG.md:14` · Blocks release: no
+- Commit 49b1566 makes engine a required field (guard + disabled submit + inline hint) in `VehiclesTab.tsx` and flags pre-existing engine-less vehicles; no mention under `## [3.0.0]` (Golden Rule 4).
+- **Fix:** added a "Changed" bullet under `[3.0.0]`.
+
+### COR-01 — Leaderboards top-session loading key can cross-disable buttons across courses
+- `src/pages/Leaderboards.tsx:117` (disable check `:292`) · Blocks release: no
+- `loadingKey` was `top:${group.key}`, but `group.key` is unique only within a course; the disclosure key already namespaces by `courseKey`.
+- **Fix:** namespaced the loading key as `top:${course.courseKey}|${group.key}`.
+
+### COR-02 — `ProfileAvatar` has no broken-image fallback
+- `src/components/ProfileAvatar.tsx:28` · Blocks release: no
+- `<img>` had no `onError`; a 404 rendered a broken-image glyph instead of the `UserIcon` placeholder.
+- **Fix:** added a `failed` state + `onError` that degrades to the placeholder (resets on `url` change).
+
+### TST-01 — `escapeLike()` ships without a test
+- `src/plugins/cloud-sync/publicProfile.ts:32` · Blocks release: no
+- Pure `ilike`-metacharacter escaper for the `/driver/:username` lookup, untested (Golden Rule 3).
+- **Fix:** exported it + added `publicProfile.test.ts` (covers `_`, `%`, `\`, mixed, passthrough, empty).
+
+### TST-02 — `autoSubmitSnapshotTrack()` skip/dedupe branches untested
+- `src/plugins/cloud-sync/trackAutoSubmit.ts:15` · Blocks release: no
+- Three branches gate the `submit-track` edge call; the pure core was tested but the orchestration wasn't.
+- **Fix:** added `trackAutoSubmit.test.ts` mocking the dynamic imports + `functions.invoke` for every branch.
+
+### DOC-01 — Plan-numbering collision: two plans both numbered 0006
+- `docs/plans/0006-dynamic-supabase-branch-db.md:1` · Blocks release: no
+- The branch-db plan reused 0006 instead of 0007 (Golden Rule 8).
+- **Fix:** renamed to `0007-dynamic-supabase-branch-db.md` + updated its title and the "plan 0006" branch-db references in CLAUDE.md + README (user-profiles refs stay 0006).
+
+## What was not covered
+
+- Single adversarial verify per finding (default depth) — warranted given all findings are Low and verification was unanimous (6/6 survived).
+- The 6-language locale diffs were treated as data (parity enforced by the green `i18n.test.ts`), not line-reviewed for translation quality.
+- Migration runtime behavior was reasoned statically against the diff, not executed against live Postgres.
diff --git a/package.json b/package.json
index 51ec449a..dfc757e9 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "doves-dataviewer",
   "private": true,
-  "version": "2.9.2",
+  "version": "3.0.0",
   "description": "Open-source, offline-first motorsport telemetry viewer (Dove's DataViewer / LapWing).",
   "license": "GPL-3.0-or-later",
   "author": "TheAngryRaven",
diff --git a/scripts/resolveSupabaseBranch.test.ts b/scripts/resolveSupabaseBranch.test.ts
new file mode 100644
index 00000000..f3fee14f
--- /dev/null
+++ b/scripts/resolveSupabaseBranch.test.ts
@@ -0,0 +1,148 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  selectBranchForGit,
+  isBranchReady,
+  pickAnonKey,
+  resolveBranchBackend,
+  type ManagementBranch,
+} from "./resolveSupabaseBranch";
+
+const branch = (over: Partial<ManagementBranch>): ManagementBranch => ({
+  id: "b1",
+  project_ref: "preview123",
+  git_branch: "feature/x",
+  status: "MIGRATIONS_PASSED",
+  is_default: false,
+  ...over,
+});
+
+describe("selectBranchForGit", () => {
+  it("matches a non-default branch by git_branch", () => {
+    const list = [
+      branch({ id: "prod", is_default: true, git_branch: "main" }),
+      branch({ id: "feat", git_branch: "feature/x" }),
+    ];
+    expect(selectBranchForGit(list, "feature/x")?.id).toBe("feat");
+  });
+
+  it("never returns the default (production) branch", () => {
+    const list = [branch({ id: "prod", is_default: true, git_branch: "main" })];
+    expect(selectBranchForGit(list, "main")).toBeNull();
+  });
+
+  it("returns null when no branch tracks the git branch", () => {
+    expect(selectBranchForGit([branch({ git_branch: "other" })], "feature/x")).toBeNull();
+  });
+
+  it("returns null for an empty git branch", () => {
+    expect(selectBranchForGit([branch({})], "")).toBeNull();
+  });
+});
+
+describe("isBranchReady", () => {
+  it.each(["MIGRATIONS_PASSED", "FUNCTIONS_DEPLOYED", "ACTIVE_HEALTHY"])(
+    "treats %s as ready",
+    (status) => expect(isBranchReady(branch({ status }))).toBe(true),
+  );
+
+  it.each(["RUNNING_MIGRATIONS", "MIGRATIONS_FAILED", "CREATING_PROJECT", undefined])(
+    "treats %s as not ready",
+    (status) => expect(isBranchReady(branch({ status }))).toBe(false),
+  );
+});
+
+describe("pickAnonKey", () => {
+  it("prefers the anon key", () => {
+    expect(pickAnonKey([{ name: "service_role", api_key: "s" }, { name: "anon", api_key: "a" }])).toBe("a");
+  });
+  it("falls back to publishable", () => {
+    expect(pickAnonKey([{ name: "publishable", api_key: "p" }])).toBe("p");
+  });
+  it("returns null when neither is present", () => {
+    expect(pickAnonKey([{ name: "secret", api_key: "x" }])).toBeNull();
+  });
+});
+
+describe("resolveBranchBackend", () => {
+  const baseOpts = {
+    gitBranch: "feature/x",
+    prodProjectRef: "prodref",
+    accessToken: "token",
+    warn: () => {},
+  };
+
+  const okFetch = (branches: unknown, keys: unknown): typeof fetch =>
+    vi.fn(async (url: string | URL | Request) => {
+      const u = String(url);
+      const body = u.includes("/branches") ? branches : keys;
+      return new Response(JSON.stringify(body), { status: 200 });
+    }) as unknown as typeof fetch;
+
+  it("resolves a ready branch to its creds", async () => {
+    const res = await resolveBranchBackend({
+      ...baseOpts,
+      fetchImpl: okFetch(
+        [branch({ project_ref: "preview123", git_branch: "feature/x" })],
+        [{ name: "anon", api_key: "anonkey" }],
+      ),
+    });
+    expect(res).toEqual({
+      url: "https://preview123.supabase.co",
+      anonKey: "anonkey",
+      projectId: "preview123",
+    });
+  });
+
+  it("returns null without an access token", async () => {
+    expect(await resolveBranchBackend({ ...baseOpts, accessToken: "" })).toBeNull();
+  });
+
+  it("returns null on main", async () => {
+    expect(await resolveBranchBackend({ ...baseOpts, gitBranch: "main" })).toBeNull();
+  });
+
+  it("falls back when no branch matches (the no-DB-changes case)", async () => {
+    const res = await resolveBranchBackend({
+      ...baseOpts,
+      fetchImpl: okFetch([branch({ git_branch: "unrelated" })], []),
+    });
+    expect(res).toBeNull();
+  });
+
+  it("falls back when the branch is not ready", async () => {
+    const res = await resolveBranchBackend({
+      ...baseOpts,
+      fetchImpl: okFetch(
+        [branch({ git_branch: "feature/x", status: "MIGRATIONS_FAILED" })],
+        [{ name: "anon", api_key: "anonkey" }],
+      ),
+    });
+    expect(res).toBeNull();
+  });
+
+  it("falls back when the anon key is missing", async () => {
+    const res = await resolveBranchBackend({
+      ...baseOpts,
+      fetchImpl: okFetch([branch({ git_branch: "feature/x" })], [{ name: "secret", api_key: "x" }]),
+    });
+    expect(res).toBeNull();
+  });
+
+  it("never throws on a network error", async () => {
+    const res = await resolveBranchBackend({
+      ...baseOpts,
+      fetchImpl: vi.fn(async () => {
+        throw new Error("network down");
+      }) as unknown as typeof fetch,
+    });
+    expect(res).toBeNull();
+  });
+
+  it("falls back on a non-OK list response", async () => {
+    const res = await resolveBranchBackend({
+      ...baseOpts,
+      fetchImpl: vi.fn(async () => new Response("nope", { status: 500 })) as unknown as typeof fetch,
+    });
+    expect(res).toBeNull();
+  });
+});
diff --git a/scripts/resolveSupabaseBranch.ts b/scripts/resolveSupabaseBranch.ts
new file mode 100644
index 00000000..55c69053
--- /dev/null
+++ b/scripts/resolveSupabaseBranch.ts
@@ -0,0 +1,195 @@
+// Build-time resolver: map the CI git branch to its Supabase **preview-branch**
+// database via the Supabase Management API, so a per-branch front-end preview
+// talks to that branch's own ephemeral DB instead of the one static beta DB.
+//
+// Why this exists: Cloudflare Workers Builds deploys every non-`main` branch as a
+// preview, but `vite.config.ts` bakes a single fixed set of `*_PREVIEW` Supabase
+// creds (the beta DB) into all of them. Supabase Branching, meanwhile, spins up a
+// fresh preview database per git branch — but ONLY when that branch carries
+// migration changes — with its own project ref, API URL and anon key. Nothing
+// linked the two. This module is that link: at build time it asks the Management
+// API "is there a Supabase branch for this git branch?" and, if so, returns its
+// creds for vite.config to bake in. When there's no branch (no DB changes) or the
+// branch isn't healthy, it returns null and the caller falls back to the existing
+// static `_PREVIEW`/beta creds — i.e. today's behaviour, unchanged.
+//
+// This is pure build tooling (Node, runs in CI), never shipped to the client, so
+// it has zero bearing on the offline-first runtime.
+
+/** Supabase Management API base. */
+const MANAGEMENT_API = "https://api.supabase.com";
+
+/** How long to wait on the Management API before giving up and falling back. A
+ * slow/Down control plane must never stall or fail a deploy. */
+const REQUEST_TIMEOUT_MS = 10_000;
+
+/** Resolved creds for a branch's preview database. Mirrors the three Supabase
+ * `VITE_*` keys vite.config bakes in. */
+export interface BranchBackend {
+  /** `https://{ref}.supabase.co` */
+  url: string;
+  /** The preview branch's anon (publishable) key. */
+  anonKey: string;
+  /** The preview branch's own project ref. */
+  projectId: string;
+}
+
+/** Subset of a Management API branch object (`GET /v1/projects/{ref}/branches`)
+ * that we rely on. The API returns more fields; we only type what we read. */
+export interface ManagementBranch {
+  id: string;
+  /** The preview branch's OWN project ref (a distinct Supabase project). */
+  project_ref: string;
+  /** The git branch this preview branch tracks. */
+  git_branch?: string;
+  /** Provisioning/migration status — see READY_STATUSES. */
+  status?: string;
+  /** True for the production/default branch (parent project) — never a preview. */
+  is_default?: boolean;
+}
+
+/** One entry of `GET /v1/projects/{ref}/api-keys`. */
+interface ApiKey {
+  name?: string;
+  api_key?: string;
+}
+
+/** Branch statuses where the preview database is provisioned and safe to point a
+ * front-end at. A branch mid-provision or with failed migrations is deliberately
+ * skipped so we never bake creds for a half-built/broken DB — we fall back
+ * instead. Source: Supabase branch lifecycle statuses. */
+const READY_STATUSES: ReadonlySet<string> = new Set([
+  "MIGRATIONS_PASSED",
+  "FUNCTIONS_DEPLOYED",
+  "ACTIVE_HEALTHY",
+]);
+
+/**
+ * Pure selection: from a list of Management API branches, pick the (non-default)
+ * preview branch tracking `gitBranch`. Returns null when none matches. Extracted
+ * so the matching logic is unit-testable without any network.
+ */
+export function selectBranchForGit(
+  branches: ManagementBranch[],
+  gitBranch: string,
+): ManagementBranch | null {
+  if (!gitBranch) return null;
+  return (
+    branches.find((b) => !b.is_default && b.git_branch === gitBranch) ?? null
+  );
+}
+
+/** Pure: is this branch's database provisioned enough to use? */
+export function isBranchReady(branch: ManagementBranch): boolean {
+  return !!branch.status && READY_STATUSES.has(branch.status);
+}
+
+/** Pure: pick the anon/publishable key out of an api-keys response. */
+export function pickAnonKey(keys: ApiKey[]): string | null {
+  const anon = keys.find((k) => k.name === "anon");
+  if (anon?.api_key) return anon.api_key;
+  const publishable = keys.find((k) => k.name === "publishable");
+  return publishable?.api_key ?? null;
+}
+
+export interface ResolveOptions {
+  /** The CI git branch being built (e.g. `WORKERS_CI_BRANCH`). */
+  gitBranch: string;
+  /** The PRODUCTION project ref the branches hang off (parent project). */
+  prodProjectRef: string;
+  /** A Supabase personal access token with access to the project. */
+  accessToken: string;
+  /** Injectable fetch (for tests); defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Injectable logger (for tests); defaults to console.warn. */
+  warn?: (msg: string) => void;
+}
+
+async function getJson<T>(
+  fetchImpl: typeof fetch,
+  url: string,
+  accessToken: string,
+): Promise<T | null> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const res = await fetchImpl(url, {
+      headers: { Authorization: `Bearer ${accessToken}` },
+      signal: controller.signal,
+    });
+    if (!res.ok) return null;
+    return (await res.json()) as T;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Resolve the Supabase preview-branch database for the current git branch, or
+ * null to fall back to the static `_PREVIEW`/beta creds.
+ *
+ * Returns null (silently falls back) when: the access token or git branch is
+ * missing, the branch is `main`, no Supabase branch tracks this git branch (the
+ * common "no DB changes, so no branch was generated" case), the branch isn't
+ * healthy yet, the anon key can't be read, or the Management API errors/times
+ * out. It NEVER throws — a backend resolution problem must not break a build.
+ */
+export async function resolveBranchBackend(
+  opts: ResolveOptions,
+): Promise<BranchBackend | null> {
+  const {
+    gitBranch,
+    prodProjectRef,
+    accessToken,
+    fetchImpl = fetch,
+    warn = (m) => console.warn(m),
+  } = opts;
+
+  if (!accessToken || !gitBranch || gitBranch === "main" || !prodProjectRef) {
+    return null;
+  }
+
+  try {
+    const branches = await getJson<ManagementBranch[]>(
+      fetchImpl,
+      `${MANAGEMENT_API}/v1/projects/${prodProjectRef}/branches`,
+      accessToken,
+    );
+    if (!Array.isArray(branches)) {
+      warn(`[supabase-branch] could not list branches for ${prodProjectRef}`);
+      return null;
+    }
+
+    const branch = selectBranchForGit(branches, gitBranch);
+    if (!branch) {
+      // No DB changes on this branch → Supabase made no preview branch. Normal.
+      return null;
+    }
+    if (!isBranchReady(branch)) {
+      warn(
+        `[supabase-branch] branch "${gitBranch}" found but status=${branch.status}; falling back`,
+      );
+      return null;
+    }
+
+    const keys = await getJson<ApiKey[]>(
+      fetchImpl,
+      `${MANAGEMENT_API}/v1/projects/${branch.project_ref}/api-keys?reveal=true`,
+      accessToken,
+    );
+    const anonKey = Array.isArray(keys) ? pickAnonKey(keys) : null;
+    if (!anonKey) {
+      warn(`[supabase-branch] no anon key for branch project ${branch.project_ref}`);
+      return null;
+    }
+
+    return {
+      url: `https://${branch.project_ref}.supabase.co`,
+      anonKey,
+      projectId: branch.project_ref,
+    };
+  } catch (err) {
+    warn(`[supabase-branch] resolution failed, falling back: ${String(err)}`);
+    return null;
+  }
+}
diff --git a/src/App.tsx b/src/App.tsx
index e4f3754a..60a44c4d 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -25,6 +25,8 @@ const enableCloud = import.meta.env.VITE_ENABLE_CLOUD === 'true';
 const Login = lazy(() => import("./pages/Login"));
 const Admin = lazy(() => import("./pages/Admin"));
 const Register = lazy(() => import("./pages/Register"));
+const Leaderboards = lazy(() => import("./pages/Leaderboards"));
+const DriverProfile = lazy(() => import("./pages/DriverProfile"));
 const Privacy = lazy(() => import("./pages/Privacy"));
 const Terms = lazy(() => import("./pages/Terms"));
 // Public, no-login account-deletion request page. Mounted un-gated (below) so the
@@ -79,6 +81,8 @@ const App = () => {
               {(enableAdmin || enableCloud) && <Route path="/login" element={<Login />} />}
               {enableAdmin && <Route path="/admin" element={<Admin />} />}
               {enableCloud && <Route path="/register" element={<Register />} />}
+              {enableCloud && <Route path="/leaderboards" element={<Leaderboards />} />}
+              {enableCloud && <Route path="/driver/:username" element={<DriverProfile />} />}
               {enableCloud && <Route path="/forgot-password" element={<ForgotPassword />} />}
               {enableCloud && <Route path="/reset-password" element={<ResetPassword />} />}
               {enableCloud && <Route path="/auth/callback" element={<AuthCallback />} />}
diff --git a/src/components/AlfanoDownload.tsx b/src/components/AlfanoDownload.tsx
new file mode 100644
index 00000000..4e16c704
--- /dev/null
+++ b/src/components/AlfanoDownload.tsx
@@ -0,0 +1,230 @@
+import { useState, useCallback, useEffect, useRef } from "react";
+import { useTranslation } from "react-i18next";
+import { Bluetooth, Loader2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { DeviceListPanel, FileListPanel, ProgressPanel } from "@/components/loggers/DownloadPanels";
+import { createAlfanoConnection } from "@/lib/loggers/alfano/alfanoConnection";
+import { loggerScan, loggerConnect, type ScannedDevice } from "@/lib/loggers/alfano/ipc";
+import type { LoggerConnection, LoggerFile, LoggerDownloadProgress } from "@/lib/loggers";
+import { parseDatalogFile } from "@/lib/datalogParser";
+import { ParsedData } from "@/types/racing";
+
+type DownloadState =
+  | "idle"
+  | "scanning"
+  | "device-list"
+  | "connecting"
+  | "fetching-files"
+  | "file-list"
+  | "downloading"
+  | "error";
+
+interface AlfanoDownloadProps {
+  onDataLoaded: (data: ParsedData, fileName?: string) => void;
+  autoSave?: boolean;
+  autoSaveFile?: (name: string, blob: Blob) => Promise<void>;
+  /** Begin scanning as soon as the flow mounts (it's mounted on demand). */
+  autoStart?: boolean;
+  /** Called when the flow finishes or is dismissed so the host can unmount it. */
+  onClose: () => void;
+}
+
+/**
+ * The native (Tauri) Alfano download flow — SKELETON. Alfano talks over Bluetooth
+ * serial (Classic Bluetooth SPP), which the web can't reach, so this flow is
+ * native-only and is mounted on demand by `LoggerDownload` once the user picks
+ * Alfano on the native app, keeping `@tauri-apps/api` off the web/eager bundle.
+ * Mirrors `DovesloggerDownload`: scan → pick device → connect → list → download +
+ * import. Talks to the device only through the generic `LoggerConnection`
+ * surface, and owns the connection — it disconnects on every exit
+ * (close/cancel/error/unmount). The Rust backend it drives is still TBD.
+ */
+export function AlfanoDownload({ onDataLoaded, autoSave, autoSaveFile, autoStart, onClose }: AlfanoDownloadProps) {
+  const { t } = useTranslation("logger");
+  const [state, setState] = useState<DownloadState>("idle");
+  const [devices, setDevices] = useState<ScannedDevice[]>([]);
+  const [files, setFiles] = useState<LoggerFile[]>([]);
+  const [progress, setProgress] = useState<LoggerDownloadProgress | null>(null);
+  const [currentFile, setCurrentFile] = useState<string>("");
+  const [error, setError] = useState<string>("");
+  const loggerRef = useRef<LoggerConnection | null>(null);
+
+  const handleClose = useCallback(() => {
+    loggerRef.current?.disconnect();
+    loggerRef.current = null;
+    setState("idle");
+    setDevices([]);
+    setFiles([]);
+    setProgress(null);
+    setCurrentFile("");
+    setError("");
+    onClose();
+  }, [onClose]);
+
+  const handleScan = useCallback(async () => {
+    setError("");
+    // A fresh scan implies any prior connection is stale — drop it.
+    loggerRef.current?.disconnect();
+    loggerRef.current = null;
+    setState("scanning");
+    try {
+      const found = await loggerScan();
+      setDevices(found);
+      setState("device-list");
+    } catch (err) {
+      console.error("Alfano scan error:", err);
+      setError(err instanceof Error ? err.message : String(err));
+      setState("error");
+    }
+  }, []);
+
+  const handleDeviceSelect = useCallback(async (device: ScannedDevice) => {
+    setError("");
+    setState("connecting");
+    try {
+      const info = await loggerConnect({ host: device.id });
+      const logger = createAlfanoConnection(info);
+      loggerRef.current = logger;
+
+      setState("fetching-files");
+      const fileList = await logger.listLogs();
+      setFiles(fileList);
+      setState("file-list");
+    } catch (err) {
+      console.error("Alfano connect/list error:", err);
+      setError(err instanceof Error ? err.message : String(err));
+      setState("error");
+    }
+  }, []);
+
+  // Kick off the scan as soon as the flow is mounted (once).
+  const startedRef = useRef(false);
+  useEffect(() => {
+    if (autoStart && !startedRef.current) {
+      startedRef.current = true;
+      void handleScan();
+    }
+  }, [autoStart, handleScan]);
+
+  // Always release the device when this flow unmounts.
+  useEffect(() => () => void loggerRef.current?.disconnect(), []);
+
+  const handleFileSelect = useCallback(
+    async (file: LoggerFile) => {
+      const logger = loggerRef.current;
+      if (!logger) {
+        setError(t("alfano.flow.errorTitle"));
+        setState("error");
+        return;
+      }
+
+      setState("downloading");
+      setCurrentFile(file.name);
+      setProgress({ received: 0, total: file.size, percent: 0, speed: "0 B/s", eta: "--" });
+      setError("");
+
+      try {
+        const bytes = await logger.downloadLog(file.name, setProgress);
+        const blob = new Blob([bytes.buffer as ArrayBuffer]);
+
+        // Save the raw file first so it's never lost.
+        if (autoSave && autoSaveFile) {
+          try {
+            await autoSaveFile(file.name, blob);
+          } catch (e) {
+            console.warn("Auto-save failed:", e);
+          }
+        }
+
+        const data = await parseDatalogFile(new File([blob], file.name));
+        handleClose();
+        onDataLoaded(data, file.name);
+      } catch (err) {
+        console.error("Alfano download/parse error:", err);
+        const msg = err instanceof Error ? err.message : String(err);
+        setError(`${msg}${t("alfano.flow.savedHint")}`);
+        setState("error");
+      }
+    },
+    [autoSave, autoSaveFile, handleClose, onDataLoaded, t],
+  );
+
+  const isModalOpen = state !== "idle";
+
+  return (
+    <Dialog open={isModalOpen} onOpenChange={(open) => !open && handleClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <Bluetooth className="w-5 h-5" />
+            {state === "scanning" && t("alfano.flow.scanning")}
+            {state === "device-list" && t("alfano.flow.selectDevice")}
+            {state === "connecting" && t("alfano.flow.connecting")}
+            {state === "fetching-files" && t("alfano.flow.fetching")}
+            {state === "file-list" && t("alfano.flow.selectFile")}
+            {state === "downloading" && t("alfano.flow.downloading")}
+            {state === "error" && t("alfano.flow.errorTitle")}
+          </DialogTitle>
+        </DialogHeader>
+
+        {state === "scanning" && (
+          <div className="flex flex-col items-center gap-4 py-8">
+            <Loader2 className="w-12 h-12 animate-spin text-primary" />
+            <p className="text-muted-foreground">{t("alfano.flow.scanning")}</p>
+          </div>
+        )}
+
+        {state === "device-list" && (
+          <DeviceListPanel
+            devices={devices}
+            onSelect={handleDeviceSelect}
+            onRescan={handleScan}
+            instructions={t("alfano.flow.deviceInstructions")}
+            emptyText={t("alfano.flow.noDevices")}
+            rescanLabel={t("alfano.flow.rescan")}
+          />
+        )}
+
+        {state === "connecting" && (
+          <div className="flex flex-col items-center gap-4 py-8">
+            <Loader2 className="w-12 h-12 animate-spin text-primary" />
+            <p className="text-muted-foreground">{t("alfano.flow.connecting")}</p>
+          </div>
+        )}
+
+        {state === "fetching-files" && (
+          <div className="flex flex-col items-center gap-4 py-8">
+            <Loader2 className="w-12 h-12 animate-spin text-primary" />
+            <p className="text-muted-foreground">{t("alfano.flow.fetching")}</p>
+          </div>
+        )}
+
+        {state === "file-list" && (
+          <FileListPanel
+            files={files}
+            onSelect={handleFileSelect}
+            instructions={t("alfano.flow.instructions")}
+            emptyText={t("alfano.flow.empty")}
+          />
+        )}
+
+        {state === "downloading" && progress && (
+          <ProgressPanel currentFile={currentFile} progress={progress} />
+        )}
+
+        {state === "error" && (
+          <div className="flex flex-col items-center gap-4 py-4">
+            <p className="text-destructive text-center">{error}</p>
+            <div className="flex gap-2">
+              <Button variant="outline" onClick={handleClose}>
+                {t("alfano.flow.cancel")}
+              </Button>
+              <Button onClick={handleScan}>{t("alfano.flow.retry")}</Button>
+            </div>
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/src/components/BackToHome.tsx b/src/components/BackToHome.tsx
new file mode 100644
index 00000000..a427acc7
--- /dev/null
+++ b/src/components/BackToHome.tsx
@@ -0,0 +1,21 @@
+import { ArrowLeft } from "lucide-react";
+import { useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/components/ui/button";
+
+/** Shared "← back to home" link for the off-session pages (Leaderboards, driver profiles). */
+export function BackToHome({ className }: { className?: string }) {
+  const navigate = useNavigate();
+  const { t } = useTranslation("common");
+  return (
+    <Button
+      variant="ghost"
+      size="sm"
+      className={`gap-1.5 px-2 text-muted-foreground ${className ?? ""}`}
+      onClick={() => navigate("/")}
+    >
+      <ArrowLeft className="h-4 w-4" />
+      {t("actions.backToHome")}
+    </Button>
+  );
+}
diff --git a/src/components/ContactDialog.tsx b/src/components/ContactDialog.tsx
index 9964dbe1..25dfc638 100644
--- a/src/components/ContactDialog.tsx
+++ b/src/components/ContactDialog.tsx
@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useState, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { Mail } from "lucide-react";
 import { Dialog, DialogTrigger, DialogContent, DialogHeader, DialogTitle, DialogDescription } from "@/components/ui/dialog";
@@ -9,8 +9,13 @@ import { Label } from "@/components/ui/label";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import { toast } from "@/hooks/use-toast";
 
+// The "request a new datalogger" category — exported so the logger picker can
+// open this dialog with it preselected. Keep the VALUE in sync with the edge
+// function's ALLOWED_CATEGORIES + the admin MessagesTab category map.
+export const CATEGORY_NEW_DATALOGGER = "New Datalogger Connection";
+
 // eslint-disable-next-line react-refresh/only-export-components -- co-located with the dialog that owns the categories
-export const MESSAGE_CATEGORIES = ["Comment", "Feature Request", "Complaint", "Bug Report"] as const;
+export const MESSAGE_CATEGORIES = ["Comment", "Feature Request", "Complaint", "Bug Report", CATEGORY_NEW_DATALOGGER] as const;
 
 // The category VALUE submitted to the backend stays the English string above;
 // this only maps it to a locale key for display.
@@ -19,16 +24,33 @@ const CATEGORY_KEYS = {
   "Feature Request": "featureRequest",
   "Complaint": "complaint",
   "Bug Report": "bugReport",
+  [CATEGORY_NEW_DATALOGGER]: "newDatalogger",
 } as const;
 
-export function ContactDialog({ variant = "footer" }: { variant?: "header" | "footer" }) {
+export function ContactDialog({
+  variant = "footer",
+  trigger,
+  defaultCategory,
+}: {
+  variant?: "header" | "footer";
+  /** Custom trigger element (overrides the default header/footer button). */
+  trigger?: ReactNode;
+  /** Preselect a category when the dialog opens (e.g. from the logger picker). */
+  defaultCategory?: string;
+}) {
   const { t } = useTranslation("landing");
   const [open, setOpen] = useState(false);
-  const [category, setCategory] = useState<string>("");
+  const [category, setCategory] = useState<string>(defaultCategory ?? "");
   const [email, setEmail] = useState("");
   const [message, setMessage] = useState("");
   const [submitting, setSubmitting] = useState(false);
 
+  // Re-seed the preselected category each time the dialog opens.
+  const handleOpenChange = (next: boolean) => {
+    setOpen(next);
+    if (next && defaultCategory) setCategory(defaultCategory);
+  };
+
   const handleSubmit = async () => {
     if (!category || !message.trim()) {
       toast({ title: t("contact.missingFields"), description: t("contact.missingFieldsDesc"), variant: "destructive" });
@@ -55,7 +77,7 @@ export function ContactDialog({ variant = "footer" }: { variant?: "header" | "fo
       }
 
       toast({ title: t("contact.sent"), description: t("contact.sentDesc") });
-      setCategory("");
+      setCategory(defaultCategory ?? "");
       setEmail("");
       setMessage("");
       setOpen(false);
@@ -67,9 +89,11 @@ export function ContactDialog({ variant = "footer" }: { variant?: "header" | "fo
   };
 
   return (
-    <Dialog open={open} onOpenChange={setOpen}>
+    <Dialog open={open} onOpenChange={handleOpenChange}>
       <DialogTrigger asChild>
-        {variant === "header" ? (
+        {trigger ? (
+          trigger
+        ) : variant === "header" ? (
           <Button variant="default" size="sm" className="gap-2">
             <Mail className="w-4 h-4" />
             <span className="hidden sm:inline">{t("contact.trigger")}</span>
diff --git a/src/components/LandingPage.tsx b/src/components/LandingPage.tsx
index 1ac12a01..b6392261 100644
--- a/src/components/LandingPage.tsx
+++ b/src/components/LandingPage.tsx
@@ -1,29 +1,24 @@
 import { Fragment, type ReactNode } from "react";
 import {
-  Heart,
   Shield,
   Play,
-  LogIn,
-  User,
   FileText,
   Cpu,
   FolderOpen,
   Map,
   Bluetooth,
   Route,
+  Trophy,
 } from "lucide-react";
-import { BrandLogo } from "@/components/BrandLogo";
 import { Link, useNavigate } from "react-router-dom";
 import { useTranslation, Trans } from "react-i18next";
-import { Button } from "@/components/ui/button";
+import { SiteHeader } from "@/components/SiteHeader";
 import { FileImport } from "@/components/FileImport";
 import { ActionTile } from "@/components/ActionTile";
 import { TrackEditor } from "@/components/TrackEditor";
 import { LocalWeatherDialog } from "@/components/LocalWeatherDialog";
 import { BrowserCompatDialog } from "@/components/BrowserCompatDialog";
 import { ContactDialog } from "@/components/ContactDialog";
-import { SupportedFilesDialog } from "@/components/SupportedFilesDialog";
-import { AboutDialog } from "@/components/AboutDialog";
 import { CreditsDialog } from "@/components/CreditsDialog";
 import { PluginMount } from "@/plugins/PluginMount";
 import { MountSlot } from "@/plugins/mounts";
@@ -81,7 +76,7 @@ export function LandingPage({
   settingsButton,
 }: LandingPageProps) {
   const navigate = useNavigate();
-  const { user, isAdmin } = useAuth();
+  const { isAdmin } = useAuth();
   const { t } = useTranslation(["landing", "common"]);
 
   // On the native (Tauri/Android) shell the user has already installed the app,
@@ -92,6 +87,8 @@ export function LandingPage({
   const roadmapItems = t("landing:roadmap.items", { returnObjects: true }) as {
     text: string;
     sub?: string[];
+    /** Shipped — rendered struck through to show it's landed. */
+    done?: boolean;
   }[];
 
   // Group roadmap items by their trailing month/quarter parenthetical (works
@@ -104,49 +101,7 @@ export function LandingPage({
 
   return (
     <div className="min-h-screen bg-background flex flex-col safe-area-x">
-      <header className="sticky top-0 z-30 border-b border-border bg-background/95 backdrop-blur safe-area-top">
-        <div className="mx-auto flex w-full max-w-4xl items-center justify-between gap-3 px-6 py-4">
-          <div className="flex items-center gap-3">
-            <BrandLogo className="w-8 h-8" />
-            <h1 className="text-xl font-semibold text-foreground">LapWing</h1>
-            {/* Sponsor sits at the far left, next to the brand. */}
-            {!native && (
-              <a
-                href="https://github.com/sponsors/TheAngryRaven"
-                target="_blank"
-                rel="noopener noreferrer"
-                onClick={(e) => interceptExternal(e, "https://github.com/sponsors/TheAngryRaven")}
-              >
-                <Button variant="outline" size="sm" className="gap-2">
-                  <Heart className="w-4 h-4 text-pink-500" />
-                  <span className="hidden sm:inline">{t("common:actions.sponsor")}</span>
-                </Button>
-              </a>
-            )}
-          </div>
-          <div className="flex items-center gap-2">
-            <SupportedFilesDialog />
-            <AboutDialog />
-            {/* Settings sits just left of the account button. */}
-            {settingsButton}
-            {/* Account control at the far right: Profile when signed in (opens the
-                drawer's Profile tab), otherwise Sign in. */}
-            {enableCloud && (
-              user ? (
-                <Button size="sm" className="gap-2" onClick={onOpenProfile} title={user.email ?? undefined}>
-                  <User className="w-4 h-4" />
-                  <span className="hidden sm:inline">{t("common:actions.profile")}</span>
-                </Button>
-              ) : (
-                <Button size="sm" className="gap-2" onClick={() => navigate('/login')}>
-                  <LogIn className="w-4 h-4" />
-                  <span className="hidden sm:inline">{t("common:actions.signIn")}</span>
-                </Button>
-              )
-            )}
-          </div>
-        </div>
-      </header>
+      <SiteHeader settingsButton={settingsButton} enableCloud={enableCloud} onOpenProfile={onOpenProfile} />
 
       <main className="flex-1 px-6 py-10">
         <div className="mx-auto w-full max-w-4xl space-y-10">
@@ -227,6 +182,16 @@ export function LandingPage({
               }
             />
 
+            {/* Public leaderboards — only meaningful with the cloud backend. */}
+            {enableCloud && (
+              <ActionTile
+                icon={Trophy}
+                title={t("landing:tiles.leaderboards.title")}
+                description={t("landing:tiles.leaderboards.description")}
+                onClick={() => navigate('/leaderboards')}
+              />
+            )}
+
             <ActionTile
               icon={Cpu}
               title={t("landing:tiles.build.title")}
@@ -268,14 +233,14 @@ export function LandingPage({
                     <li className="text-sm text-muted-foreground">
                       <div className="flex items-start gap-2">
                         <span className="mt-1.5 h-1.5 w-1.5 shrink-0 rounded-full bg-primary/60" />
-                        <span>{item.text}</span>
+                        <span className={item.done ? "line-through opacity-70" : undefined}>{item.text}</span>
                       </div>
                       {item.sub && item.sub.length > 0 && (
                         <ul className="mt-1.5 space-y-1 pl-5">
                           {item.sub.map((sub) => (
                             <li key={sub} className="flex items-start gap-2">
                               <span className="mt-[7px] h-1 w-1 shrink-0 rounded-full bg-primary/40" />
-                              <span>{sub}</span>
+                              <span className={item.done ? "line-through opacity-70" : undefined}>{sub}</span>
                             </li>
                           ))}
                         </ul>
diff --git a/src/components/LapTable.tsx b/src/components/LapTable.tsx
index 21355e4d..beded7c1 100644
--- a/src/components/LapTable.tsx
+++ b/src/components/LapTable.tsx
@@ -46,9 +46,13 @@ interface LapTableProps {
   // Map overlays (extra racing lines)
   overlayLines?: OverlayLine[];
   onToggleOverlay?: (id: string) => void;
+  // Read-only leaderboard view (plan 0005): label laps by submitter + show a
+  // course/engine/weight descriptor above the table.
+  lapLabels?: Record<number, string>;
+  readOnlyDescriptor?: { courseName: string; engineLabel: string; weightLabel?: string };
 }
 
-export const LapTable = memo(function LapTable({ laps, course, samples, onLapSelect, selectedLapNumber, referenceLapNumber, onSetReference, externalRefLabel, savedFiles, onLoadFileForRef, onSelectExternalLap, onClearExternalRef, onRefreshSavedFiles, snapshotsForCourse, activeSnapshotId, canSnapshot, onLoadSnapshot, onClearSnapshot, onSaveSnapshot, overlayLines = [], onToggleOverlay }: LapTableProps) {
+export const LapTable = memo(function LapTable({ laps, course, samples, onLapSelect, selectedLapNumber, referenceLapNumber, onSetReference, externalRefLabel, savedFiles, onLoadFileForRef, onSelectExternalLap, onClearExternalRef, onRefreshSavedFiles, snapshotsForCourse, activeSnapshotId, canSnapshot, onLoadSnapshot, onClearSnapshot, onSaveSnapshot, overlayLines = [], onToggleOverlay, lapLabels, readOnlyDescriptor }: LapTableProps) {
   const { t } = useTranslation('session');
   const { useKph } = useSettingsContext();
 
@@ -206,6 +210,16 @@ export const LapTable = memo(function LapTable({ laps, course, samples, onLapSel
 
   return (
     <div className="h-full overflow-auto scrollbar-thin">
+      {/* Read-only leaderboard descriptor: course · engine · weight class. */}
+      {readOnlyDescriptor && (
+        <div className="border-b border-border bg-warning/10 px-4 py-2 text-sm">
+          <span className="font-medium text-foreground">{readOnlyDescriptor.courseName}</span>
+          <span className="text-muted-foreground"> · {readOnlyDescriptor.engineLabel}</span>
+          {readOnlyDescriptor.weightLabel && (
+            <span className="text-muted-foreground"> · {readOnlyDescriptor.weightLabel}</span>
+          )}
+        </div>
+      )}
       {/* The external-reference bar is superseded by the header "Overlays" menu
           (set references there) + the per-row Ref/Map controls below. Kept
           mounted-but-hidden for now in case we need to fall back. */}
@@ -332,7 +346,11 @@ export const LapTable = memo(function LapTable({ laps, course, samples, onLapSel
                 </td>
                 <td className="px-4 py-3">
                   <div className="flex items-center gap-2">
-                    <span className="font-mono text-sm">{lap.lapNumber}</span>
+                    {lapLabels?.[lap.lapNumber] ? (
+                      <span className="text-sm font-medium">{lapLabels[lap.lapNumber]}</span>
+                    ) : (
+                      <span className="font-mono text-sm">{lap.lapNumber}</span>
+                    )}
                     {isFastest && (
                       <Trophy className="w-4 h-4 text-racing-lapBest" />
                     )}
diff --git a/src/components/LoggerDownload.tsx b/src/components/LoggerDownload.tsx
index 7377a019..74db5cf3 100644
--- a/src/components/LoggerDownload.tsx
+++ b/src/components/LoggerDownload.tsx
@@ -28,6 +28,12 @@ const MyChronDownload = lazy(() =>
   import("@/components/MyChronDownload").then((m) => ({ default: m.MyChronDownload })),
 );
 
+// The native Alfano Bluetooth-serial flow (skeleton) is likewise lazy so
+// `@tauri-apps/api` (dynamic import inside it) never enters the web/eager bundle.
+const AlfanoDownload = lazy(() =>
+  import("@/components/AlfanoDownload").then((m) => ({ default: m.AlfanoDownload })),
+);
+
 interface LoggerDownloadProps {
   onDataLoaded: (data: ParsedData, fileName?: string) => void;
   autoSave?: boolean;
@@ -43,8 +49,9 @@ interface LoggerDownloadProps {
 /**
  * Entry point for "Download from logger": renders the trigger (button or a
  * caller-supplied tile) and the image-based `LoggerPicker`. Picking the
- * Fledgling mounts the lazy Bluetooth download flow; MyChron and Alfano are
- * handled inside the picker (explanatory dialogs).
+ * Fledgling mounts the lazy Bluetooth download flow. MyChron (Wi-Fi) and Alfano
+ * (Bluetooth serial) mount their native download flows on the native shell, and
+ * fall back to explanatory dialogs inside the picker on the web.
  */
 export function LoggerDownload({ onDataLoaded, autoSave, autoSaveFile, renderTrigger }: LoggerDownloadProps) {
   const { t } = useTranslation("logger");
@@ -55,6 +62,7 @@ export function LoggerDownload({ onDataLoaded, autoSave, autoSaveFile, renderTri
   const [pickerOpen, setPickerOpen] = useState(false);
   const [fledglingActive, setFledglingActive] = useState(false);
   const [mychronActive, setMychronActive] = useState(false);
+  const [alfanoActive, setAlfanoActive] = useState(false);
 
   const openPicker = useCallback(() => setPickerOpen(true), []);
 
@@ -83,6 +91,10 @@ export function LoggerDownload({ onDataLoaded, autoSave, autoSaveFile, renderTri
           setPickerOpen(false);
           setMychronActive(true);
         }}
+        onSelectAlfano={() => {
+          setPickerOpen(false);
+          setAlfanoActive(true);
+        }}
       />
 
       {fledglingActive && (
@@ -118,6 +130,18 @@ export function LoggerDownload({ onDataLoaded, autoSave, autoSaveFile, renderTri
           />
         </Suspense>
       )}
+
+      {alfanoActive && (
+        <Suspense fallback={null}>
+          <AlfanoDownload
+            autoStart
+            onDataLoaded={onDataLoaded}
+            autoSave={autoSave}
+            autoSaveFile={autoSaveFile}
+            onClose={() => setAlfanoActive(false)}
+          />
+        </Suspense>
+      )}
     </>
   );
 }
diff --git a/src/components/LoggerPicker.tsx b/src/components/LoggerPicker.tsx
index 8b2cf234..6566435c 100644
--- a/src/components/LoggerPicker.tsx
+++ b/src/components/LoggerPicker.tsx
@@ -8,7 +8,9 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
+import { MailPlus } from "lucide-react";
 import { Button } from "@/components/ui/button";
+import { ContactDialog, CATEGORY_NEW_DATALOGGER } from "@/components/ContactDialog";
 import { isNativeApp } from "@/lib/platform";
 import { cn } from "@/lib/utils";
 
@@ -34,6 +36,12 @@ interface LoggerPickerProps {
    * native shell; on web the MyChron card keeps its explanatory dialog.
    */
   onSelectMychron?: () => void;
+  /**
+   * Begin the native Alfano Bluetooth-serial flow. Only supplied (and only fired)
+   * on the native shell; on web the Alfano card keeps its explanatory dialog
+   * (Bluetooth serial can't be reached in-browser).
+   */
+  onSelectAlfano?: () => void;
 }
 
 interface LoggerCardProps {
@@ -82,11 +90,12 @@ function LoggerCard({ image, name, tag, onClick, disabled, badge, hint }: Logger
 
 /**
  * Image-based logger chooser shown before any download begins. PerchWerks
- * Fledgling runs the normal Web Bluetooth flow; MyChron and Alfano are not yet
- * downloadable and open an explanatory dialog instead (MyChron's copy differs
- * between the native shell and the web app — see `isNativeApp`).
+ * Fledgling runs the normal Web Bluetooth flow; MyChron (Wi-Fi) and Alfano
+ * (Bluetooth serial) only download on the native shell, so on web they open an
+ * explanatory dialog instead (copy differs between the native shell and the web
+ * app — see `isNativeApp`).
  */
-export function LoggerPicker({ open, onOpenChange, bleSupported, onSelectFledgling, onSelectMychron }: LoggerPickerProps) {
+export function LoggerPicker({ open, onOpenChange, bleSupported, onSelectFledgling, onSelectMychron, onSelectAlfano }: LoggerPickerProps) {
   const { t } = useTranslation("logger");
   const [info, setInfo] = useState<"mychron" | "alfano" | null>(null);
   const native = isNativeApp();
@@ -126,11 +135,24 @@ export function LoggerPicker({ open, onOpenChange, bleSupported, onSelectFledgli
               image={ALFANO_IMAGE}
               name={ALFANO_NAME}
               tag={t("tags.alfano")}
-              badge={t("comingSoon")}
-              onClick={() => setInfo("alfano")}
+              // Bluetooth serial only works in the (not-yet-public) native app, so
+              // flag it "coming soon" to web users; on native it runs the flow.
+              badge={native ? undefined : t("comingSoon")}
+              onClick={() => (native && onSelectAlfano ? onSelectAlfano() : setInfo("alfano"))}
             />
           </div>
 
+          {/* Don't see your logger? Open the contact form pre-set to request one. */}
+          <ContactDialog
+            defaultCategory={CATEGORY_NEW_DATALOGGER}
+            trigger={
+              <Button variant="outline" className="w-full gap-2">
+                <MailPlus className="h-4 w-4" />
+                {t("requestLogger")}
+              </Button>
+            }
+          />
+
           <p className="text-[11px] leading-relaxed text-muted-foreground/70">
             {t("trademarks")}
           </p>
@@ -156,7 +178,7 @@ export function LoggerPicker({ open, onOpenChange, bleSupported, onSelectFledgli
         </DialogContent>
       </Dialog>
 
-      {/* Alfano — Bluetooth, no native app needed; coming soon. */}
+      {/* Alfano — Bluetooth serial, web can't reach it; explains the native app. */}
       <Dialog open={info === "alfano"} onOpenChange={(o) => !o && setInfo(null)}>
         <DialogContent className="sm:max-w-md">
           <DialogHeader>
diff --git a/src/components/ProfileAvatar.tsx b/src/components/ProfileAvatar.tsx
new file mode 100644
index 00000000..81b5ebd2
--- /dev/null
+++ b/src/components/ProfileAvatar.tsx
@@ -0,0 +1,47 @@
+import { useEffect, useState } from "react";
+import { User as UserIcon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+interface ProfileAvatarProps {
+  /** Public avatar URL (with cache-buster), or null for the placeholder. */
+  url: string | null | undefined;
+  alt?: string;
+  /** Tailwind size classes for the circle (e.g. "h-12 w-12"). */
+  sizeClassName?: string;
+  className?: string;
+}
+
+/**
+ * Round avatar with a UserIcon fallback. Presentational only — shared by the
+ * profile panel, the driver page, and the leaderboard rows so they stay visually
+ * identical. The icon scales to roughly half the circle.
+ */
+export function ProfileAvatar({ url, alt = "", sizeClassName = "h-12 w-12", className }: ProfileAvatarProps) {
+  // Fall back to the placeholder when the avatar object 404s (swept path or a
+  // transient CDN miss) instead of rendering the browser's broken-image glyph.
+  // Reset on url change so a fresh upload (new ?v= buster) gets another chance.
+  const [failed, setFailed] = useState(false);
+  useEffect(() => setFailed(false), [url]);
+
+  return (
+    <div
+      className={cn(
+        "flex shrink-0 items-center justify-center overflow-hidden rounded-full bg-muted text-muted-foreground",
+        sizeClassName,
+        className,
+      )}
+    >
+      {url && !failed ? (
+        <img
+          src={url}
+          alt={alt}
+          className="h-full w-full object-cover"
+          loading="lazy"
+          onError={() => setFailed(true)}
+        />
+      ) : (
+        <UserIcon className="h-1/2 w-1/2" />
+      )}
+    </div>
+  );
+}
diff --git a/src/components/RaceLineView.tsx b/src/components/RaceLineView.tsx
index 562be9ea..40acbd0b 100644
--- a/src/components/RaceLineView.tsx
+++ b/src/components/RaceLineView.tsx
@@ -65,6 +65,8 @@ interface RaceLineViewProps {
   sessionFileName?: string | null;
   cachedWeatherStation?: WeatherStation | null;
   onWeatherStationResolved?: (station: WeatherStation) => void;
+  /** Read-only leaderboard view: hide/disable the weather panel + fetch. */
+  readOnly?: boolean;
   isAllLaps?: boolean;
   parserStats?: ParserStats | null;
   /** Extra racing lines (other laps / snapshots) to overlay, beneath the current lap. */
@@ -111,7 +113,7 @@ function createSpeedEventIcon(event: SpeedEvent, useKph: boolean): L.DivIcon {
   });
 }
 
-export function RaceLineView({ samples, allSamples, referenceSamples = [], course, bounds, paceDiff = null, paceDiffLabel = 'best', deltaTopSpeed = null, deltaMinSpeed = null, referenceLapNumber = null, lapToFastestDelta = null, showOverlays = true, lapTimeMs = null, refAvgTopSpeed = null, refAvgMinSpeed = null, sessionGpsPoint, sessionStartDate, sessionFileName, cachedWeatherStation, onWeatherStationResolved, isAllLaps, parserStats, overlayLines = [], rangeStart = 0, onRemoveOverlay, alignOverlays, onToggleAlignOverlays, showOverlayLegend = true, onToggleOverlayLegend }: RaceLineViewProps) {
+export function RaceLineView({ samples, allSamples, referenceSamples = [], course, bounds, paceDiff = null, paceDiffLabel = 'best', deltaTopSpeed = null, deltaMinSpeed = null, referenceLapNumber = null, lapToFastestDelta = null, showOverlays = true, lapTimeMs = null, refAvgTopSpeed = null, refAvgMinSpeed = null, sessionGpsPoint, sessionStartDate, sessionFileName, cachedWeatherStation, onWeatherStationResolved, readOnly = false, isAllLaps, parserStats, overlayLines = [], rangeStart = 0, onRemoveOverlay, alignOverlays, onToggleAlignOverlays, showOverlayLegend = true, onToggleOverlayLegend }: RaceLineViewProps) {
   const { t } = useTranslation('session');
   const { useKph, brakingZoneSettings } = useSettingsContext();
   const { currentIndex } = usePlaybackContext();
@@ -677,33 +679,38 @@ export function RaceLineView({ samples, allSamples, referenceSamples = [], cours
         </div>
       )}
 
-      {/* Session METAR detail button - bottom right, left of weather toggle */}
-      {showWeather && sessionWeatherData && (
-        <button
-          onClick={() => setSessionMetarOpen(true)}
-          className="absolute bottom-4 right-14 z-[1000] p-2 rounded bg-card/90 backdrop-blur-sm border border-border transition-colors hover:bg-muted/50 text-primary"
-          title={t('map.metarDetail')}
-        >
-          <FileText className="w-4 h-4" />
-        </button>
+      {/* Weather UI — hidden entirely in the read-only leaderboard view. */}
+      {!readOnly && (
+        <>
+          {/* Session METAR detail button - bottom right, left of weather toggle */}
+          {showWeather && sessionWeatherData && (
+            <button
+              onClick={() => setSessionMetarOpen(true)}
+              className="absolute bottom-4 right-14 z-[1000] p-2 rounded bg-card/90 backdrop-blur-sm border border-border transition-colors hover:bg-muted/50 text-primary"
+              title={t('map.metarDetail')}
+            >
+              <FileText className="w-4 h-4" />
+            </button>
+          )}
+
+          {/* Weather toggle button - bottom right */}
+          <button
+            onClick={() => setShowWeather(prev => !prev)}
+            className={`absolute bottom-4 right-4 z-[1000] p-2 rounded bg-card/90 backdrop-blur-sm border border-border transition-colors hover:bg-muted/50 ${showWeather ? 'text-primary' : 'text-muted-foreground'}`}
+            title={showWeather ? t('map.weatherHide') : t('map.weatherShow')}
+          >
+            <CloudSun className="w-4 h-4" />
+          </button>
+
+          {/* Session METAR dialog */}
+          <LocalWeatherDialog
+            sessionWeather={sessionWeatherData}
+            externalOpen={sessionMetarOpen}
+            onExternalOpenChange={setSessionMetarOpen}
+          />
+        </>
       )}
 
-      {/* Weather toggle button - bottom right */}
-      <button
-        onClick={() => setShowWeather(prev => !prev)}
-        className={`absolute bottom-4 right-4 z-[1000] p-2 rounded bg-card/90 backdrop-blur-sm border border-border transition-colors hover:bg-muted/50 ${showWeather ? 'text-primary' : 'text-muted-foreground'}`}
-        title={showWeather ? t('map.weatherHide') : t('map.weatherShow')}
-      >
-        <CloudSun className="w-4 h-4" />
-      </button>
-
-      {/* Session METAR dialog */}
-      <LocalWeatherDialog
-        sessionWeather={sessionWeatherData}
-        externalOpen={sessionMetarOpen}
-        onExternalOpenChange={setSessionMetarOpen}
-      />
-      
       {/* Speed legend and stats panel */}
       {showOverlays && (
         <div className="absolute top-4 right-4 bg-card/90 backdrop-blur-sm border border-border rounded p-2 z-[1000] min-w-[120px] transition-opacity duration-200">
@@ -802,7 +809,7 @@ export function RaceLineView({ samples, allSamples, referenceSamples = [], cours
           })()}
           
           {/* Weather panel - below delta section */}
-          {showWeather && (
+          {!readOnly && showWeather && (
             <div className="mt-3 pt-2 border-t border-border">
               <WeatherPanel
                 lat={sessionGpsPoint?.lat}
diff --git a/src/components/SiteHeader.tsx b/src/components/SiteHeader.tsx
new file mode 100644
index 00000000..33ebac77
--- /dev/null
+++ b/src/components/SiteHeader.tsx
@@ -0,0 +1,87 @@
+import { type ReactNode } from "react";
+import { Heart, LogIn, User } from "lucide-react";
+import { useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { BrandLogo } from "@/components/BrandLogo";
+import { Button } from "@/components/ui/button";
+import { SupportedFilesDialog } from "@/components/SupportedFilesDialog";
+import { AboutDialog } from "@/components/AboutDialog";
+import { useAuth } from "@/contexts/AuthContext";
+import { interceptExternal, isNativeApp } from "@/lib/platform";
+
+interface SiteHeaderProps {
+  /** The settings modal (trigger + dialog), rendered just left of the account button. */
+  settingsButton: ReactNode;
+  enableCloud: boolean;
+  /** Opens the Profile (account) surface. */
+  onOpenProfile: () => void;
+  /** Show the "Supported files" reference dialog button (default true). */
+  showSupportedFiles?: boolean;
+  /** Show the "About" dialog button (default true). */
+  showAbout?: boolean;
+  /** Extra controls rendered between the brand and the right-hand button cluster. */
+  children?: ReactNode;
+}
+
+/**
+ * The shared sticky top banner: brand + sponsor on the left, and a reference /
+ * settings / account cluster on the right. Used by the landing page (everything
+ * shown) and the Leaderboards page (supported-files + about hidden), so the two
+ * banners stay identical by construction.
+ */
+export function SiteHeader({
+  settingsButton,
+  enableCloud,
+  onOpenProfile,
+  showSupportedFiles = true,
+  showAbout = true,
+  children,
+}: SiteHeaderProps) {
+  const navigate = useNavigate();
+  const { user } = useAuth();
+  const { t } = useTranslation(["common"]);
+  const native = isNativeApp();
+
+  return (
+    <header className="sticky top-0 z-30 border-b border-border bg-background/95 backdrop-blur safe-area-top">
+      <div className="mx-auto flex w-full max-w-4xl items-center justify-between gap-3 px-6 py-4">
+        <div className="flex items-center gap-3">
+          <BrandLogo className="w-8 h-8" />
+          <h1 className="text-xl font-semibold text-foreground">LapWing</h1>
+          {!native && (
+            <a
+              href="https://github.com/sponsors/TheAngryRaven"
+              target="_blank"
+              rel="noopener noreferrer"
+              onClick={(e) => interceptExternal(e, "https://github.com/sponsors/TheAngryRaven")}
+            >
+              <Button variant="outline" size="sm" className="gap-2">
+                <Heart className="w-4 h-4 text-pink-500" />
+                <span className="hidden sm:inline">{t("common:actions.sponsor")}</span>
+              </Button>
+            </a>
+          )}
+        </div>
+        <div className="flex items-center gap-2">
+          {children}
+          {showSupportedFiles && <SupportedFilesDialog />}
+          {showAbout && <AboutDialog />}
+          {settingsButton}
+          {enableCloud && (
+            user ? (
+              <Button size="sm" className="gap-2" onClick={onOpenProfile} title={user.email ?? undefined}>
+                <User className="w-4 h-4" />
+                <span className="hidden sm:inline">{t("common:actions.profile")}</span>
+              </Button>
+            ) : (
+              <Button size="sm" className="gap-2" onClick={() => navigate('/login')}>
+                <LogIn className="w-4 h-4" />
+                <span className="hidden sm:inline">{t("common:actions.signIn")}</span>
+              </Button>
+            )
+          )}
+        </div>
+      </div>
+    </header>
+  );
+}
diff --git a/src/components/admin/LeaderboardsTab.tsx b/src/components/admin/LeaderboardsTab.tsx
new file mode 100644
index 00000000..97eabb15
--- /dev/null
+++ b/src/components/admin/LeaderboardsTab.tsx
@@ -0,0 +1,254 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
+} from "@/components/ui/select";
+import { formatLapTime } from "@/lib/lapCalculation";
+import type { EngineClass, LeaderboardEntry } from "@/lib/leaderboardTypes";
+import {
+  fetchAllEntriesAdmin, updateEntryAdmin, reclassifyEntries,
+  createEngineClass, updateEngineClass, deleteEngineClass,
+} from "@/plugins/cloud-sync/leaderboardClient";
+import { fetchEngineClasses } from "@/plugins/cloud-sync/leaderboardClient";
+
+type StatusFilter = "all" | "approved" | "denied";
+const UNCLASSIFIED = "__none__";
+
+export function LeaderboardsTab() {
+  const { t } = useTranslation("admin");
+  const [entries, setEntries] = useState<LeaderboardEntry[] | null>(null);
+  const [classes, setClasses] = useState<EngineClass[]>([]);
+  const [filter, setFilter] = useState<StatusFilter>("all");
+  const [error, setError] = useState<string | null>(null);
+  const [busy, setBusy] = useState<string | null>(null);
+
+  const classesById = useMemo(() => new Map(classes.map((c) => [c.id, c])), [classes]);
+
+  const refresh = useCallback(async () => {
+    try {
+      const [e, c] = await Promise.all([fetchAllEntriesAdmin(), fetchEngineClasses()]);
+      setEntries(e);
+      setClasses(c);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : t("leaderboards.loadFailed"));
+    }
+  }, [t]);
+
+  useEffect(() => { void refresh(); }, [refresh]);
+
+  const patch = async (id: string, p: Parameters<typeof updateEntryAdmin>[1]) => {
+    setBusy(id);
+    try {
+      await updateEntryAdmin(id, p);
+      toast.success(t("leaderboards.updated"));
+      await refresh();
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : t("leaderboards.updateFailed"));
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const visible = useMemo(
+    () => (entries ?? []).filter((e) => filter === "all" || e.status === filter),
+    [entries, filter],
+  );
+
+  if (error) return <p className="text-sm text-destructive">{error}</p>;
+  if (!entries) return <p className="text-sm text-muted-foreground">{t("leaderboards.loading")}</p>;
+
+  return (
+    <div className="space-y-8">
+      <EngineClassesEditor classes={classes} onChanged={refresh} />
+
+      <div className="space-y-3">
+        <div className="flex items-center justify-between">
+          <h3 className="text-lg font-semibold">{t("leaderboards.title")}</h3>
+          <Select value={filter} onValueChange={(v) => setFilter(v as StatusFilter)}>
+            <SelectTrigger className="h-8 w-36"><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="all">{t("leaderboards.filterAll")}</SelectItem>
+              <SelectItem value="approved">{t("leaderboards.filterApproved")}</SelectItem>
+              <SelectItem value="denied">{t("leaderboards.filterDenied")}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+
+        {visible.length === 0 ? (
+          <p className="text-sm text-muted-foreground">{t("leaderboards.empty")}</p>
+        ) : (
+          <div className="overflow-x-auto">
+            <table className="w-full text-sm">
+              <thead className="text-left text-muted-foreground">
+                <tr className="border-b border-border">
+                  <th className="px-2 py-2">{t("leaderboards.colDriver")}</th>
+                  <th className="px-2 py-2">{t("leaderboards.colTrack")}</th>
+                  <th className="px-2 py-2">{t("leaderboards.colEngine")}</th>
+                  <th className="px-2 py-2">{t("leaderboards.colClass")}</th>
+                  <th className="px-2 py-2">{t("leaderboards.colWeight")}</th>
+                  <th className="px-2 py-2">{t("leaderboards.colTime")}</th>
+                  <th className="px-2 py-2">{t("leaderboards.colStatus")}</th>
+                  <th className="px-2 py-2" />
+                </tr>
+              </thead>
+              <tbody>
+                {visible.map((e) => (
+                  <tr key={e.id} className="border-b border-border/60 align-top">
+                    <td className="px-2 py-2">{e.displayName}</td>
+                    <td className="px-2 py-2 text-muted-foreground">{e.trackName}<br />{e.courseName}</td>
+                    <td className="px-2 py-2">{e.engine}</td>
+                    <td className="px-2 py-2">
+                      <Select
+                        value={e.engineClassId ?? UNCLASSIFIED}
+                        onValueChange={(v) => patch(e.id, { engineClassId: v === UNCLASSIFIED ? null : v })}
+                      >
+                        <SelectTrigger className="h-8 w-40"><SelectValue /></SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value={UNCLASSIFIED}>{t("leaderboards.unclassified")}</SelectItem>
+                          {classes.map((c) => (
+                            <SelectItem key={c.id} value={c.id}>{c.name}</SelectItem>
+                          ))}
+                        </SelectContent>
+                      </Select>
+                    </td>
+                    <td className="px-2 py-2 whitespace-nowrap">
+                      {e.listedWeight != null ? `${e.listedWeight} ${e.listedWeightUnit ?? ""}` : "—"}
+                    </td>
+                    <td className="px-2 py-2 font-mono whitespace-nowrap">{formatLapTime(e.lapTimeMs)}</td>
+                    <td className="px-2 py-2">
+                      <span className={e.status === "denied" ? "text-destructive" : "text-green-600"}>{e.status}</span>
+                    </td>
+                    <td className="px-2 py-2">
+                      {e.status === "approved" ? (
+                        <Button size="sm" variant="outline" className="h-7 text-xs" disabled={busy === e.id} onClick={() => patch(e.id, { status: "denied" })}>
+                          {t("leaderboards.deny")}
+                        </Button>
+                      ) : (
+                        <Button size="sm" variant="outline" className="h-7 text-xs" disabled={busy === e.id} onClick={() => patch(e.id, { status: "approved" })}>
+                          {t("leaderboards.approve")}
+                        </Button>
+                      )}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/** Engine-class keyword groups + a reclassify trigger. */
+function EngineClassesEditor({ classes, onChanged }: { classes: EngineClass[]; onChanged: () => Promise<void> }) {
+  const { t } = useTranslation("admin");
+  const [name, setName] = useState("");
+  const [keywords, setKeywords] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  const parseKeywords = (s: string) => s.split(",").map((k) => k.trim()).filter(Boolean);
+
+  const add = async () => {
+    if (!name.trim()) return;
+    setBusy(true);
+    try {
+      await createEngineClass(name.trim(), parseKeywords(keywords), classes.length);
+      setName(""); setKeywords("");
+      toast.success(t("leaderboards.classSaved"));
+      await onChanged();
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : t("leaderboards.classFailed"));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const reclassify = async () => {
+    setBusy(true);
+    try {
+      const n = await reclassifyEntries();
+      toast.success(t("leaderboards.reclassified", { count: n }));
+      await onChanged();
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : t("leaderboards.classFailed"));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="space-y-3 rounded-lg border border-border p-4">
+      <div className="flex items-center justify-between">
+        <h3 className="text-lg font-semibold">{t("leaderboards.classesTitle")}</h3>
+        <Button size="sm" variant="outline" disabled={busy} onClick={() => void reclassify()}>
+          {t("leaderboards.reclassify")}
+        </Button>
+      </div>
+      <p className="text-xs text-muted-foreground">{t("leaderboards.classesHint")}</p>
+
+      <div className="space-y-2">
+        {classes.map((c) => (
+          <EngineClassRow key={c.id} cls={c} onChanged={onChanged} />
+        ))}
+      </div>
+
+      <div className="flex flex-wrap items-end gap-2 border-t border-border pt-3">
+        <div className="flex-1 min-w-[140px]">
+          <label className="text-xs text-muted-foreground">{t("leaderboards.className")}</label>
+          <Input className="h-8" value={name} onChange={(e) => setName(e.target.value)} placeholder={t("leaderboards.classNamePlaceholder")} />
+        </div>
+        <div className="flex-[2] min-w-[180px]">
+          <label className="text-xs text-muted-foreground">{t("leaderboards.keywords")}</label>
+          <Input className="h-8" value={keywords} onChange={(e) => setKeywords(e.target.value)} placeholder={t("leaderboards.keywordsPlaceholder")} />
+        </div>
+        <Button size="sm" disabled={busy || !name.trim()} onClick={() => void add()}>{t("leaderboards.addClass")}</Button>
+      </div>
+    </div>
+  );
+}
+
+function EngineClassRow({ cls, onChanged }: { cls: EngineClass; onChanged: () => Promise<void> }) {
+  const { t } = useTranslation("admin");
+  const [name, setName] = useState(cls.name);
+  const [keywords, setKeywords] = useState(cls.keywords.join(", "));
+  const [busy, setBusy] = useState(false);
+
+  const save = async () => {
+    setBusy(true);
+    try {
+      await updateEngineClass(cls.id, { name: name.trim(), keywords: keywords.split(",").map((k) => k.trim()).filter(Boolean) });
+      toast.success(t("leaderboards.classSaved"));
+      await onChanged();
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : t("leaderboards.classFailed"));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const remove = async () => {
+    setBusy(true);
+    try {
+      await deleteEngineClass(cls.id);
+      await onChanged();
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : t("leaderboards.classFailed"));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="flex flex-wrap items-end gap-2">
+      <Input className="h-8 flex-1 min-w-[120px]" value={name} onChange={(e) => setName(e.target.value)} />
+      <Input className="h-8 flex-[2] min-w-[160px]" value={keywords} onChange={(e) => setKeywords(e.target.value)} />
+      <Button size="sm" variant="outline" className="h-8" disabled={busy} onClick={() => void save()}>{t("leaderboards.saveClass")}</Button>
+      <Button size="sm" variant="ghost" className="h-8 text-destructive" disabled={busy} onClick={() => void remove()}>{t("leaderboards.deleteClass")}</Button>
+    </div>
+  );
+}
diff --git a/src/components/admin/MessagesTab.tsx b/src/components/admin/MessagesTab.tsx
index fe15e5fd..8be84005 100644
--- a/src/components/admin/MessagesTab.tsx
+++ b/src/components/admin/MessagesTab.tsx
@@ -24,6 +24,7 @@ const categoryColors: Record<string, string> = {
   "Feature Request": "bg-green-500/20 text-green-400 border-green-500/30",
   "Complaint": "bg-red-500/20 text-red-400 border-red-500/30",
   "Bug Report": "bg-orange-500/20 text-orange-400 border-orange-500/30",
+  "New Datalogger Connection": "bg-purple-500/20 text-purple-400 border-purple-500/30",
 };
 
 // Map the English category value stored in the DB to its locale key.
@@ -32,6 +33,7 @@ const categoryKeys = {
   "Feature Request": "featureRequest",
   "Complaint": "complaint",
   "Bug Report": "bugReport",
+  "New Datalogger Connection": "newDatalogger",
 } as const;
 
 export function MessagesTab({ onUnreadCount }: { onUnreadCount?: (count: number) => void }) {
diff --git a/src/components/drawer/VehiclesTab.tsx b/src/components/drawer/VehiclesTab.tsx
index 9d41a223..f331650f 100644
--- a/src/components/drawer/VehiclesTab.tsx
+++ b/src/components/drawer/VehiclesTab.tsx
@@ -1,6 +1,6 @@
 import { useState, useCallback, useEffect, useMemo } from "react";
 import { useTranslation } from "react-i18next";
-import { Pencil, Trash2, Car, History, Plus } from "lucide-react";
+import { Pencil, Trash2, Car, History, Plus, Globe } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
@@ -31,6 +31,7 @@ const emptyForm = (defaultTypeId: string): Omit<Vehicle, "id"> => ({
   number: 0,
   weight: 0,
   weightUnit: "lb",
+  publicProfile: false,
 });
 
 export function VehiclesTab({ vehicles, vehicleTypes, onAdd, onUpdate, onRemove, onOpenFile, onCreateVehicleType }: VehiclesTabProps) {
@@ -73,11 +74,14 @@ export function VehiclesTab({ vehicles, vehicleTypes, onAdd, onUpdate, onRemove,
       number: vehicle.number,
       weight: vehicle.weight,
       weightUnit: vehicle.weightUnit,
+      publicProfile: vehicle.publicProfile ?? false,
     });
   };
 
   const handleSubmit = useCallback(async () => {
-    if (!form.name.trim()) return;
+    // Name + engine are both required — the engine powers leaderboards and
+    // snapshot matching, so a vehicle must always carry one.
+    if (!form.name.trim() || !form.engine.trim()) return;
     if (editingId) {
       await onUpdate({ id: editingId, ...form });
     } else {
@@ -132,12 +136,26 @@ export function VehiclesTab({ vehicles, vehicleTypes, onAdd, onUpdate, onRemove,
                 className={`flex items-center gap-2 p-2 rounded-md hover:bg-muted/50 transition-colors ${editingId === vehicle.id ? "ring-1 ring-primary bg-primary/5" : ""}`}
               >
                 <div className="flex-1 min-w-0">
-                  <div className="text-sm font-medium truncate text-foreground">
-                    #{vehicle.number} — {vehicle.name}
+                  <div className="flex items-center gap-1.5 min-w-0">
+                    <span className="text-sm font-medium truncate text-foreground">
+                      #{vehicle.number} — {vehicle.name}
+                    </span>
+                    {vehicle.publicProfile && (
+                      <span
+                        className="flex shrink-0 items-center gap-1 rounded-full bg-primary/15 px-1.5 py-0.5 text-[10px] font-medium text-primary"
+                        title={t("vehicles.publicHint")}
+                      >
+                        <Globe className="h-2.5 w-2.5" /> {t("vehicles.publicBadge")}
+                      </span>
+                    )}
                   </div>
                   <div className="text-xs text-muted-foreground">
-                    {vt?.name ?? t("vehicles.unknownType")} · {vehicle.engine} · {vehicle.weight} {vehicle.weightUnit}
+                    {vt?.name ?? t("vehicles.unknownType")}
+                    {vehicle.engine ? ` · ${vehicle.engine}` : ""} · {vehicle.weight} {vehicle.weightUnit}
                   </div>
+                  {!vehicle.engine.trim() && (
+                    <div className="text-xs text-destructive">{t("vehicles.needsEngine")}</div>
+                  )}
                 </div>
                 <Button variant="ghost" size="icon" className="h-7 w-7 shrink-0 opacity-60 hover:opacity-100" onClick={() => setHistoryVehicle(vehicle)} title={t("vehicleHistory.openTitle")}>
                   <History className="w-3.5 h-3.5" />
@@ -203,8 +221,22 @@ export function VehiclesTab({ vehicles, vehicleTypes, onAdd, onUpdate, onRemove,
             </div>
           </div>
         </div>
+        <div className="flex items-center justify-between gap-2 rounded-md border border-border/60 px-3 py-2">
+          <div className="min-w-0">
+            <Label className="text-xs">{t("vehicles.showOnProfile")}</Label>
+            <p className="text-[11px] text-muted-foreground">{t("vehicles.showOnProfileHint")}</p>
+          </div>
+          <Switch
+            checked={!!form.publicProfile}
+            onCheckedChange={checked => setForm(f => ({ ...f, publicProfile: checked }))}
+            className="shrink-0"
+          />
+        </div>
+        {form.name.trim() && !form.engine.trim() && (
+          <p className="text-xs text-destructive">{t("vehicles.engineRequired")}</p>
+        )}
         <div className="flex items-center gap-2">
-          <Button className="flex-1" size="sm" onClick={handleSubmit} disabled={!form.name.trim()}>
+          <Button className="flex-1" size="sm" onClick={handleSubmit} disabled={!form.name.trim() || !form.engine.trim()}>
             {editingId ? t("vehicles.update") : t("vehicles.add")}
           </Button>
           {editingId && (
diff --git a/src/components/graphview/GraphViewPanel.tsx b/src/components/graphview/GraphViewPanel.tsx
index 4e805dda..64959300 100644
--- a/src/components/graphview/GraphViewPanel.tsx
+++ b/src/components/graphview/GraphViewPanel.tsx
@@ -42,6 +42,8 @@ export interface GraphViewPanelProps {
   sessionStartDate?: Date;
   cachedWeatherStation: WeatherStation | null;
   onWeatherStationResolved: (station: WeatherStation) => void;
+  /** Read-only leaderboard view: disable the video player + weather panel. */
+  readOnly?: boolean;
   // Vehicle/setup
   vehicles: Vehicle[];
   setups: VehicleSetup[];
@@ -149,7 +151,7 @@ export function GraphViewPanel(props: GraphViewPanelProps) {
   }, [onCombineSplit]);
 
   const { videoState, videoActions, onVideoLoadedMetadata } = props;
-  const canRenderVideo = !!(videoState && videoActions && onVideoLoadedMetadata);
+  const canRenderVideo = !props.readOnly && !!(videoState && videoActions && onVideoLoadedMetadata);
   const renderVideo = useCallback(() => (
     <VideoPlayer
       state={videoState!}
@@ -265,6 +267,7 @@ export function GraphViewPanel(props: GraphViewPanelProps) {
             <ResizablePanel defaultSize={70} minSize={30}>
               <InfoBox
                 hideVideoTab={relocated.video}
+                readOnly={props.readOnly}
                 filteredSamples={props.filteredSamples}
                 course={props.course}
                 lapTimeMs={props.lapTimeMs}
diff --git a/src/components/graphview/InfoBox.tsx b/src/components/graphview/InfoBox.tsx
index f384bd25..0240cfba 100644
--- a/src/components/graphview/InfoBox.tsx
+++ b/src/components/graphview/InfoBox.tsx
@@ -52,6 +52,8 @@ interface InfoBoxProps {
   /** Hide the Video tab — the player was relocated into the graph stack (mobile),
    *  and two players can't share the single video element ref. */
   hideVideoTab?: boolean;
+  /** Read-only leaderboard view: hide the Video tab + weather panel. */
+  readOnly?: boolean;
 }
 
 type InfoTab = 'data' | 'vehicle' | 'video';
@@ -63,7 +65,7 @@ export function InfoBox({
   vehicles, setups, templates, sessionKartId, sessionSetupId, onSaveSessionSetup, onOpenSetupEditor, onOpenGarage,
   videoState, videoActions, onVideoLoadedMetadata,
   visibleSamples, allSamples, fieldMappings, laps, selectedLapNumber,
-  referenceSamples, paceData, sessionFileName, hideVideoTab,
+  referenceSamples, paceData, sessionFileName, hideVideoTab, readOnly = false,
 }: InfoBoxProps) {
   const { t } = useTranslation('session');
   const { useKph } = useSettingsContext();
@@ -74,7 +76,7 @@ export function InfoBox({
   useEffect(() => { setSelectedVehicleId(sessionKartId); setSelectedSetupId(sessionSetupId); }, [sessionKartId, sessionSetupId]);
 
   // If the video panel was relocated while this tab was open, fall back to data.
-  useEffect(() => { if (hideVideoTab && tab === 'video') setTab('data'); }, [hideVideoTab, tab]);
+  useEffect(() => { if ((hideVideoTab || readOnly) && tab === 'video') setTab('data'); }, [hideVideoTab, readOnly, tab]);
 
   const unit = useKph ? 'kph' : 'mph';
   const convertSpeed = (speed: number) => useKph ? speed * 1.60934 : speed;
@@ -116,7 +118,7 @@ export function InfoBox({
       <div className="flex shrink-0 border-b border-border">
         <button onClick={() => setTab('data')} className={`flex-1 px-3 py-1.5 text-xs font-medium transition-colors ${tab === 'data' ? 'text-primary border-b-2 border-primary bg-primary/5' : 'text-muted-foreground hover:text-foreground'}`}>{t('infoBox.tabData')}</button>
         <button onClick={() => setTab('vehicle')} className={`flex-1 px-3 py-1.5 text-xs font-medium transition-colors ${tab === 'vehicle' ? 'text-primary border-b-2 border-primary bg-primary/5' : 'text-muted-foreground hover:text-foreground'}`}>{t('infoBox.tabVehicle')}</button>
-        {!hideVideoTab && (
+        {!hideVideoTab && !readOnly && (
           <button onClick={() => setTab('video')} className={`flex-1 px-3 py-1.5 text-xs font-medium transition-colors ${tab === 'video' ? 'text-primary border-b-2 border-primary bg-primary/5' : 'text-muted-foreground hover:text-foreground'}`}>{t('infoBox.tabVideo')}</button>
         )}
       </div>
@@ -190,9 +192,11 @@ export function InfoBox({
                 )}
               </div>
             )}
-            <div className="pt-2 border-t border-border">
-              <WeatherPanel lat={sessionGpsPoint?.lat} lon={sessionGpsPoint?.lon} sessionDate={sessionStartDate} cachedStation={cachedWeatherStation} onStationResolved={onWeatherStationResolved} detailed />
-            </div>
+            {!readOnly && (
+              <div className="pt-2 border-t border-border">
+                <WeatherPanel lat={sessionGpsPoint?.lat} lon={sessionGpsPoint?.lon} sessionDate={sessionStartDate} cachedStation={cachedWeatherStation} onStationResolved={onWeatherStationResolved} detailed />
+              </div>
+            )}
           </>
         ) : (
           /* Vehicle tab */
diff --git a/src/components/tabs/GraphViewTab.tsx b/src/components/tabs/GraphViewTab.tsx
index 745c0e3d..669a31ae 100644
--- a/src/components/tabs/GraphViewTab.tsx
+++ b/src/components/tabs/GraphViewTab.tsx
@@ -24,6 +24,7 @@ export const GraphViewTab = memo(function GraphViewTab() {
       sessionStartDate={s.sessionStartDate}
       cachedWeatherStation={s.cachedWeatherStation}
       onWeatherStationResolved={s.onWeatherStationResolved}
+      readOnly={s.readOnly}
       vehicles={s.vehicles}
       setups={s.setups}
       templates={s.templates}
diff --git a/src/components/tabs/LapTimesTab.tsx b/src/components/tabs/LapTimesTab.tsx
index b1728d86..aa2ab03c 100644
--- a/src/components/tabs/LapTimesTab.tsx
+++ b/src/components/tabs/LapTimesTab.tsx
@@ -28,6 +28,8 @@ export const LapTimesTab = memo(function LapTimesTab() {
         onSaveSnapshot={s.onSaveSnapshot}
         overlayLines={s.overlayLines}
         onToggleOverlay={s.onToggleOverlay}
+        lapLabels={s.lapLabels}
+        readOnlyDescriptor={s.readOnlyDescriptor}
       />
     </div>
   );
diff --git a/src/components/tabs/RaceLineTab.tsx b/src/components/tabs/RaceLineTab.tsx
index 51c180e0..709895c0 100644
--- a/src/components/tabs/RaceLineTab.tsx
+++ b/src/components/tabs/RaceLineTab.tsx
@@ -55,6 +55,7 @@ export const RaceLineTab = memo(function RaceLineTab({ showOverlays }: RaceLineT
           sessionFileName={s.sessionFileName}
           cachedWeatherStation={s.cachedWeatherStation}
           onWeatherStationResolved={s.onWeatherStationResolved}
+          readOnly={s.readOnly}
           isAllLaps={s.isAllLaps}
           parserStats={s.parserStats}
           overlayLines={s.overlayLines}
diff --git a/src/contexts/SessionContext.tsx b/src/contexts/SessionContext.tsx
index b19982e6..ab58e797 100644
--- a/src/contexts/SessionContext.tsx
+++ b/src/contexts/SessionContext.tsx
@@ -12,6 +12,7 @@ import type { LapSnapshot } from '@/lib/lapSnapshot';
 import type { OverlayLine } from '@/lib/lapOverlays';
 import type { SaveSnapshotResult } from '@/hooks/useLapSnapshots';
 import type { PluginSnapshot } from '@/plugins/panels';
+import type { LeaderboardDescriptor } from '@/lib/leaderboardSession';
 
 /**
  * Session-scoped state and handlers shared by the three main view tabs
@@ -49,6 +50,15 @@ export interface SessionContextValue {
   referenceLapNumber: number | null;
   isAllLaps: boolean;
 
+  // ── Read-only leaderboard view (plan 0005) ────────────────────────────────
+  /** True when this is a synthetic, read-only leaderboard session (no saving,
+   *  no video/weather/snapshots, alert-coloured header). */
+  readOnly?: boolean;
+  /** lapNumber → submitter display name, shown instead of "Lap N" in read-only. */
+  lapLabels?: Record<number, string>;
+  /** Course / engine / weight context shown above the read-only lap table. */
+  readOnlyDescriptor?: LeaderboardDescriptor;
+
   // ── Reference comparison ──────────────────────────────────────────────────
   hasReference: boolean;
   paceDiff: number | null;
diff --git a/src/hooks/useLapSnapshots.ts b/src/hooks/useLapSnapshots.ts
index 20ac622d..29650bb9 100644
--- a/src/hooks/useLapSnapshots.ts
+++ b/src/hooks/useLapSnapshots.ts
@@ -119,7 +119,9 @@ export function useLapSnapshots(params: UseLapSnapshotsParams) {
         engine,
         sourceFileName: currentFileName ?? "session",
         recordedAt: data.startDate?.getTime(),
-        vehicle: vehicle ? { id: vehicle.id, name: vehicle.name, number: vehicle.number } : undefined,
+        vehicle: vehicle
+          ? { id: vehicle.id, name: vehicle.name, number: vehicle.number, weight: vehicle.weight, weightUnit: vehicle.weightUnit }
+          : undefined,
         setup: setup ?? undefined,
         createdAt: existing?.createdAt,
       });
diff --git a/src/lib/driverProfileGroups.test.ts b/src/lib/driverProfileGroups.test.ts
new file mode 100644
index 00000000..883c5574
--- /dev/null
+++ b/src/lib/driverProfileGroups.test.ts
@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import { groupEntriesByCourseWeight } from "./driverProfileGroups";
+import type { EngineClass, LeaderboardEntry } from "./leaderboardTypes";
+
+function entry(over: Partial<LeaderboardEntry>): LeaderboardEntry {
+  return {
+    id: "e",
+    userId: "u",
+    displayName: "Racer",
+    trackName: "Track A",
+    courseName: "Course 1",
+    courseKey: "ck1",
+    engine: "X30",
+    engineKey: "x30",
+    engineClassId: null,
+    listedWeight: 165,
+    listedWeightUnit: "lb",
+    lapTimeMs: 60000,
+    contentHash: "h",
+    engineTelemetryPublic: false,
+    status: "approved",
+    createdAt: "2026-01-01T00:00:00Z",
+    ...over,
+  };
+}
+
+const classes: EngineClass[] = [{ id: "c1", name: "Senior", keywords: [], sortOrder: 0 }];
+
+describe("groupEntriesByCourseWeight", () => {
+  it("returns nothing for no entries", () => {
+    expect(groupEntriesByCourseWeight([], classes)).toEqual([]);
+  });
+
+  it("groups by course then by exact weight, fastest-first", () => {
+    const groups = groupEntriesByCourseWeight(
+      [
+        entry({ id: "a", lapTimeMs: 61000, listedWeight: 165 }),
+        entry({ id: "b", lapTimeMs: 59000, listedWeight: 165 }),
+        entry({ id: "c", lapTimeMs: 58000, listedWeight: 180 }),
+      ],
+      classes,
+    );
+    expect(groups).toHaveLength(1);
+    const course = groups[0];
+    expect(course.courseKey).toBe("ck1");
+    expect(course.recordCount).toBe(3);
+    // Two weight buckets; the 180 lb bucket is faster so it sorts first.
+    expect(course.weightGroups.map((w) => w.weightLabel)).toEqual(["180 lb", "165 lb"]);
+    // Laps within the 165 bucket are ranked fastest-first.
+    const w165 = course.weightGroups.find((w) => w.weightLabel === "165 lb")!;
+    expect(w165.laps.map((l) => l.id)).toEqual(["b", "a"]);
+  });
+
+  it("orders courses by fastest lap and labels engine via class", () => {
+    const groups = groupEntriesByCourseWeight(
+      [
+        entry({ id: "slow", courseKey: "ckSlow", courseName: "Slow", lapTimeMs: 90000 }),
+        entry({ id: "fast", courseKey: "ckFast", courseName: "Fast", lapTimeMs: 50000, engineClassId: "c1" }),
+      ],
+      classes,
+    );
+    expect(groups.map((g) => g.courseKey)).toEqual(["ckFast", "ckSlow"]);
+    expect(groups[0].weightGroups[0].laps[0].engineLabel).toBe("Senior");
+  });
+
+  it("buckets entries with no listed weight under a null label", () => {
+    const groups = groupEntriesByCourseWeight(
+      [entry({ id: "x", listedWeight: null, listedWeightUnit: null })],
+      classes,
+    );
+    expect(groups[0].weightGroups[0].weightLabel).toBeNull();
+    expect(groups[0].weightGroups[0].key).toBe("none");
+  });
+});
diff --git a/src/lib/driverProfileGroups.ts b/src/lib/driverProfileGroups.ts
new file mode 100644
index 00000000..8151a00d
--- /dev/null
+++ b/src/lib/driverProfileGroups.ts
@@ -0,0 +1,104 @@
+// Pure grouping for the driver profile page (plan 0006): one user's approved
+// leaderboard entries → Course → weight buckets → ranked laps. Simpler than the
+// full Leaderboards browse tree (no track level, weight always split, no top-N) —
+// the profile just answers "what has this driver posted, by course and weight".
+// No React / network so it stays unit-testable.
+
+import type { EngineClass, LeaderboardEntry } from "./leaderboardTypes";
+import { engineLabelFor } from "./leaderboardBrowse";
+
+export interface DriverLap {
+  id: string;
+  engineLabel: string;
+  lapTimeMs: number;
+}
+
+export interface DriverWeightGroup {
+  /** Stable key within the course (weight+unit, or "none"). */
+  key: string;
+  /** "165 lb" etc., or null when the entry carried no listed weight. */
+  weightLabel: string | null;
+  /** Laps fastest-first. */
+  laps: DriverLap[];
+  fastestMs: number;
+}
+
+export interface DriverCourseGroup {
+  courseKey: string;
+  courseName: string;
+  trackName: string;
+  fastestMs: number;
+  recordCount: number;
+  weightGroups: DriverWeightGroup[];
+}
+
+function weightKey(e: LeaderboardEntry): string {
+  return e.listedWeight == null ? "none" : `${e.listedWeight}|${e.listedWeightUnit ?? "lb"}`;
+}
+
+function weightLabel(e: LeaderboardEntry): string | null {
+  if (e.listedWeight == null) return null;
+  return `${e.listedWeight} ${e.listedWeightUnit ?? "lb"}`;
+}
+
+const fastestOf = (es: { lapTimeMs: number }[]) =>
+  es.reduce((m, e) => Math.min(m, e.lapTimeMs), Infinity);
+
+/** Group a driver's entries by course, then by exact listed weight, each fastest-first. */
+export function groupEntriesByCourseWeight(
+  entries: LeaderboardEntry[],
+  classes: EngineClass[],
+): DriverCourseGroup[] {
+  const classesById = new Map(classes.map((c) => [c.id, c]));
+
+  interface Bucket {
+    courseName: string;
+    trackName: string;
+    weights: Map<string, LeaderboardEntry[]>;
+  }
+  const courses = new Map<string, Bucket>();
+  for (const e of entries) {
+    const bucket = courses.get(e.courseKey) ?? {
+      courseName: e.courseName,
+      trackName: e.trackName,
+      weights: new Map<string, LeaderboardEntry[]>(),
+    };
+    courses.set(e.courseKey, bucket);
+    const wk = weightKey(e);
+    const list = bucket.weights.get(wk) ?? [];
+    bucket.weights.set(wk, list);
+    list.push(e);
+  }
+
+  const result: DriverCourseGroup[] = [];
+  for (const [courseKey, bucket] of courses) {
+    const weightGroups: DriverWeightGroup[] = [];
+    let recordCount = 0;
+    for (const [wk, es] of bucket.weights) {
+      recordCount += es.length;
+      const ranked = [...es].sort((a, b) => a.lapTimeMs - b.lapTimeMs);
+      weightGroups.push({
+        key: wk,
+        weightLabel: weightLabel(es[0]),
+        laps: ranked.map((e) => ({
+          id: e.id,
+          engineLabel: engineLabelFor(e, classesById),
+          lapTimeMs: e.lapTimeMs,
+        })),
+        fastestMs: fastestOf(es),
+      });
+    }
+    weightGroups.sort((a, b) => a.fastestMs - b.fastestMs);
+    result.push({
+      courseKey,
+      courseName: bucket.courseName,
+      trackName: bucket.trackName,
+      fastestMs: weightGroups.reduce((m, w) => Math.min(m, w.fastestMs), Infinity),
+      recordCount,
+      weightGroups,
+    });
+  }
+
+  result.sort((a, b) => a.fastestMs - b.fastestMs);
+  return result;
+}
diff --git a/src/lib/fnv1a.ts b/src/lib/fnv1a.ts
new file mode 100644
index 00000000..a3540dd3
--- /dev/null
+++ b/src/lib/fnv1a.ts
@@ -0,0 +1,13 @@
+/**
+ * FNV-1a 32-bit string hash → 8-char hex. Deterministic and dependency-free;
+ * used for content-addressed dedupe (track submissions, leaderboard entries).
+ * Not cryptographic — collision resistance is "good enough for change detection".
+ */
+export function fnv1a(str: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
diff --git a/src/lib/i18n/config.ts b/src/lib/i18n/config.ts
index 646fd4c0..8d120947 100644
--- a/src/lib/i18n/config.ts
+++ b/src/lib/i18n/config.ts
@@ -35,7 +35,7 @@ export const DEFAULT_LANGUAGE: SupportedLanguage = "en";
  * migrated (see docs/plans/0004-i18n-translation-system.md). `common` is always
  * loaded; the rest load on demand for their surface.
  */
-export const NAMESPACES = ["common", "landing", "settings", "session", "video", "drawer", "weather", "tracks", "plugins", "auth", "admin", "logger"] as const;
+export const NAMESPACES = ["common", "landing", "settings", "session", "video", "drawer", "weather", "tracks", "plugins", "auth", "admin", "logger", "leaderboard", "driver"] as const;
 export type Namespace = (typeof NAMESPACES)[number];
 
 export const DEFAULT_NAMESPACE: Namespace = "common";
diff --git a/src/lib/imageCrop.test.ts b/src/lib/imageCrop.test.ts
new file mode 100644
index 00000000..894099da
--- /dev/null
+++ b/src/lib/imageCrop.test.ts
@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { computeSquareCrop } from "./imageCrop";
+
+describe("computeSquareCrop", () => {
+  it("centers the crop on a landscape image and caps the output", () => {
+    // 800x400 → 400 square, offset 200 on x, downscaled to 256.
+    expect(computeSquareCrop(800, 400, 256)).toEqual({ sx: 200, sy: 0, side: 400, target: 256 });
+  });
+
+  it("centers the crop on a portrait image", () => {
+    expect(computeSquareCrop(400, 800, 256)).toEqual({ sx: 0, sy: 200, side: 400, target: 256 });
+  });
+
+  it("keeps a square image unchanged except for the cap", () => {
+    expect(computeSquareCrop(500, 500, 256)).toEqual({ sx: 0, sy: 0, side: 500, target: 256 });
+  });
+
+  it("never upscales below the cap", () => {
+    // A 120x90 image: square side 90, target stays 90 (not 256).
+    expect(computeSquareCrop(120, 90, 256)).toEqual({ sx: 15, sy: 0, side: 90, target: 90 });
+  });
+
+  it("floors odd offsets so the crop stays inside the source", () => {
+    // 401x400 → side 400, (401-400)/2 = 0.5 → floored to 0.
+    expect(computeSquareCrop(401, 400, 256)).toEqual({ sx: 0, sy: 0, side: 400, target: 256 });
+  });
+});
diff --git a/src/lib/imageCrop.ts b/src/lib/imageCrop.ts
new file mode 100644
index 00000000..2e92b568
--- /dev/null
+++ b/src/lib/imageCrop.ts
@@ -0,0 +1,123 @@
+// Client-side avatar cropping: take any uploaded image, crop a centered square,
+// downscale so neither side exceeds a cap (256 px), and re-encode small. Pure
+// browser work — no upload, no Supabase — so profile pictures never need a
+// server-side image pipeline (Golden Rule 1: don't do on the server what the
+// client can do). The geometry is split into `computeSquareCrop` so it can be
+// unit-tested without a real canvas.
+
+export interface SquareCrop {
+  /** Source-x of the centered square crop. */
+  sx: number;
+  /** Source-y of the centered square crop. */
+  sy: number;
+  /** Side length of the square crop in source pixels. */
+  side: number;
+  /** Output side length (<= side, capped at `max`). */
+  target: number;
+}
+
+/**
+ * Geometry for a centered 1:1 crop downscaled to at most `max` px per side.
+ * Never upscales: `target` is the smaller of the crop side and `max`.
+ */
+export function computeSquareCrop(width: number, height: number, max: number): SquareCrop {
+  const side = Math.max(0, Math.min(width, height));
+  const sx = Math.floor((width - side) / 2);
+  const sy = Math.floor((height - side) / 2);
+  const target = Math.max(1, Math.min(side, max));
+  return { sx, sy, side, target };
+}
+
+export interface CroppedImage {
+  blob: Blob;
+  width: number;
+  height: number;
+  type: string;
+}
+
+export interface CropOptions {
+  /** Max output side in px (default 256). */
+  max?: number;
+  /** Encoder quality 0..1 (default 0.85). */
+  quality?: number;
+  /** Preferred output type; falls back to JPEG if unsupported (default webp). */
+  type?: "image/webp" | "image/jpeg";
+}
+
+interface LoadedImage {
+  source: CanvasImageSource;
+  width: number;
+  height: number;
+  close: () => void;
+}
+
+/** Decode a Blob to a drawable image, preferring createImageBitmap. */
+async function loadImage(file: Blob): Promise<LoadedImage> {
+  if (typeof createImageBitmap === "function") {
+    const bitmap = await createImageBitmap(file);
+    return {
+      source: bitmap,
+      width: bitmap.width,
+      height: bitmap.height,
+      close: () => bitmap.close(),
+    };
+  }
+  // Fallback for older webviews without createImageBitmap.
+  const url = URL.createObjectURL(file);
+  try {
+    const img = await new Promise<HTMLImageElement>((resolve, reject) => {
+      const el = new Image();
+      el.onload = () => resolve(el);
+      el.onerror = () => reject(new Error("Failed to decode image"));
+      el.src = url;
+    });
+    return {
+      source: img,
+      width: img.naturalWidth || img.width,
+      height: img.naturalHeight || img.height,
+      close: () => undefined,
+    };
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+
+function canvasToBlob(canvas: HTMLCanvasElement, type: string, quality: number): Promise<Blob | null> {
+  return new Promise((resolve) => canvas.toBlob(resolve, type, quality));
+}
+
+/**
+ * Crop `file` to a centered square, downscale to at most `max` px (default 256),
+ * and re-encode (webp when supported, else jpeg). Throws on an undecodable image.
+ */
+export async function cropToSquareAvatar(file: Blob, opts: CropOptions = {}): Promise<CroppedImage> {
+  const max = opts.max ?? 256;
+  const quality = opts.quality ?? 0.85;
+  const preferred = opts.type ?? "image/webp";
+
+  const img = await loadImage(file);
+  try {
+    if (!img.width || !img.height) throw new Error("Image has no dimensions");
+    const { sx, sy, side, target } = computeSquareCrop(img.width, img.height, max);
+
+    const canvas = document.createElement("canvas");
+    canvas.width = target;
+    canvas.height = target;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Canvas 2D context unavailable");
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = "high";
+    ctx.drawImage(img.source, sx, sy, side, side, 0, 0, target, target);
+
+    // Prefer webp; if the platform can't encode it, toBlob yields null → jpeg.
+    let blob = await canvasToBlob(canvas, preferred, quality);
+    if (!blob || (preferred === "image/webp" && !blob.type.includes("webp"))) {
+      blob = await canvasToBlob(canvas, "image/jpeg", quality);
+    }
+    if (!blob) throw new Error("Failed to encode cropped image");
+
+    return { blob, width: target, height: target, type: blob.type || "image/jpeg" };
+  } finally {
+    img.close();
+  }
+}
diff --git a/src/lib/lapCalculation.test.ts b/src/lib/lapCalculation.test.ts
index 96b98609..6b8fe5ce 100644
--- a/src/lib/lapCalculation.test.ts
+++ b/src/lib/lapCalculation.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import {
   calculateLaps,
+  computeLapSectors,
   formatLapTime,
   formatSectorTime,
   calculateOptimalLap,
@@ -370,6 +371,36 @@ describe("calculateLaps - sectors", () => {
   });
 });
 
+describe("computeLapSectors", () => {
+  it("returns empty when the course defines no sectors", () => {
+    const samples = makeRacePath(2, 10000);
+    expect(computeLapSectors(samples, sfCourse)).toEqual({});
+  });
+
+  it("computes sector splits for a pre-delimited lap slice (anchored at index 0)", () => {
+    // A clean lap whose first sample IS the lap start (just past S/F), crossing
+    // S2 (lon 0.003) then S3 (lon 0.006) before looping back — exactly the shape
+    // a leaderboard entry feeds in (no lead-in for start/finish re-detection).
+    const lap = [
+      makeSample(0, 0, 0.0005),
+      makeSample(1000, 0, 0.002),
+      makeSample(2000, 0, 0.004), // cross S2
+      makeSample(3000, 0, 0.005),
+      makeSample(4000, 0, 0.007), // cross S3
+      makeSample(5000, 0.01, 0.007),
+      makeSample(7000, 0.01, -0.001),
+      makeSample(9000, 0, -0.0005),
+    ];
+    const sec = computeLapSectors(lap, sectorCourse);
+    expect(sec.sectors).toBeDefined();
+    expect(sec.sectors!.s1).toBeGreaterThan(0);
+    expect(sec.sectors!.s2).toBeGreaterThan(0);
+    expect(sec.sectors!.s3).toBeGreaterThan(0);
+    expect(sec.sectorTimes).toHaveLength(3);
+    expect(sec.sectorBoundaries![0]).toBe(0); // lap start anchored at the slice start
+  });
+});
+
 // ─── formatLapTime ───────────────────────────────────────────────────────────
 
 describe("formatLapTime", () => {
diff --git a/src/lib/lapCalculation.ts b/src/lib/lapCalculation.ts
index c3b97936..7b584b10 100644
--- a/src/lib/lapCalculation.ts
+++ b/src/lib/lapCalculation.ts
@@ -295,6 +295,62 @@ export function calculateLaps(samples: GpsSample[], inputCourse: Course): Lap[]
   return laps;
 }
 
+/**
+ * Compute sector splits for ONE already-delimited lap whose samples span exactly
+ * the lap (index 0 = lap start, last index = lap end) — e.g. a leaderboard entry
+ * transposed from a snapshot. Unlike calculateLaps it does NOT re-detect the
+ * start/finish crossing (the slice has no lead-in), it anchors the lap at the
+ * slice ends and only locates the intermediate sector-line crossings. Boundary
+ * indices are relative to the passed `samples`. Returns empty when the course
+ * defines no sectors. Mirrors the per-lap sector logic in calculateLaps.
+ */
+export function computeLapSectors(
+  samples: GpsSample[],
+  inputCourse: Course,
+): { sectors?: SectorTimes; sectorTimes?: (number | undefined)[]; sectorBoundaries?: (number | undefined)[] } {
+  if (samples.length < 2) return {};
+  const course = normalizeCourseSectors(inputCourse);
+  const courseSectors = course.sectors ?? [];
+  if (courseSectors.length === 0) return {};
+
+  const centerLat = (course.startFinishA.lat + course.startFinishB.lat) / 2;
+  const centerLon = (course.startFinishA.lon + course.startFinishB.lon) / 2;
+
+  const startT = samples[0].t;
+  const endT = samples[samples.length - 1].t;
+  const lineCount = courseSectors.length + 1;
+
+  const boundaryTimes: (number | undefined)[] = new Array(lineCount);
+  const boundaryIdx: (number | undefined)[] = new Array(lineCount);
+  boundaryTimes[0] = startT; // line 0 = start/finish = the slice start
+  boundaryIdx[0] = 0;
+  let prevTime = startT;
+
+  for (let j = 0; j < courseSectors.length; j++) {
+    const line = projectSectorLine(courseSectors[j].line, centerLat, centerLon);
+    const crossings = detectLineCrossings(
+      samples, line.a, line.b, centerLat, centerLon, j, MIN_SECTOR_CROSSING_INTERVAL_MS,
+    );
+    const cross = crossings.find((c) => c.crossingTime > prevTime && c.crossingTime < endT);
+    if (cross) {
+      boundaryTimes[j + 1] = cross.crossingTime;
+      boundaryIdx[j + 1] = cross.sampleIndex;
+      prevTime = cross.crossingTime;
+    } else {
+      boundaryTimes[j + 1] = undefined;
+      boundaryIdx[j + 1] = undefined;
+    }
+  }
+
+  const sectorTimes: (number | undefined)[] = new Array(lineCount);
+  for (let k = 0; k < lineCount; k++) {
+    const tStart = boundaryTimes[k];
+    const tEnd = k + 1 < lineCount ? boundaryTimes[k + 1] : endT;
+    sectorTimes[k] = tStart !== undefined && tEnd !== undefined ? tEnd - tStart : undefined;
+  }
+  return { sectors: rollupMajorSectors(course, sectorTimes), sectorTimes, sectorBoundaries: boundaryIdx };
+}
+
 // Format lap time as mm:ss.sss
 export function formatLapTime(ms: number): string {
   const totalSeconds = ms / 1000;
diff --git a/src/lib/lapSnapshot.test.ts b/src/lib/lapSnapshot.test.ts
index ea06c35d..4d32d362 100644
--- a/src/lib/lapSnapshot.test.ts
+++ b/src/lib/lapSnapshot.test.ts
@@ -99,6 +99,16 @@ describe("buildSnapshot", () => {
     expect(snap.samples[0].t).toBe(0); // clamped to the first sample
   });
 
+  it("freezes the vehicle weight as the leaderboard listed-weight default", () => {
+    const snap = buildSnapshot({
+      lap, samples, course, trackName: "OKC", courseName: "Full CW",
+      engine: "Rotax", sourceFileName: "s.dove",
+      vehicle: { id: "v1", name: "Kart", number: 7, weight: 365, weightUnit: "lb" },
+    });
+    expect(snap.vehicle?.weight).toBe(365);
+    expect(snap.vehicle?.weightUnit).toBe("lb");
+  });
+
   it("preserves createdAt when replacing an existing snapshot", () => {
     const snap = buildSnapshot({
       lap, samples, course, trackName: "OKC", courseName: "Full CW",
diff --git a/src/lib/lapSnapshot.ts b/src/lib/lapSnapshot.ts
index 35165909..1f6b8d37 100644
--- a/src/lib/lapSnapshot.ts
+++ b/src/lib/lapSnapshot.ts
@@ -27,6 +27,9 @@ export interface SnapshotVehicle {
   id?: string;
   name?: string;
   number?: number;
+  /** Vehicle weight at capture time — the default "listed weight" for leaderboards. */
+  weight?: number;
+  weightUnit?: "lb" | "kg";
 }
 
 export interface LapSnapshot {
diff --git a/src/lib/leaderboardBrowse.test.ts b/src/lib/leaderboardBrowse.test.ts
new file mode 100644
index 00000000..1be2b862
--- /dev/null
+++ b/src/lib/leaderboardBrowse.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { buildBrowseTree, engineLabelFor } from "./leaderboardBrowse";
+import type { EngineClass, LeaderboardEntry } from "./leaderboardTypes";
+
+function e(over: Partial<LeaderboardEntry>): LeaderboardEntry {
+  return {
+    id: Math.random().toString(36).slice(2),
+    userId: "u",
+    displayName: "Racer",
+    trackName: "OKC",
+    courseName: "Full CW",
+    courseKey: "OKC|Full CW",
+    direction: null,
+    engine: "Tillotson 225",
+    engineKey: "tillotson 225",
+    engineClassId: null,
+    listedWeight: 365,
+    listedWeightUnit: "lb",
+    lapTimeMs: 62000,
+    contentHash: "h",
+    engineTelemetryPublic: false,
+    status: "approved",
+    createdAt: "",
+    ...over,
+  };
+}
+
+const classes: EngineClass[] = [
+  { id: "c1", name: "Tillotson 225", keywords: ["tilly", "225"], sortOrder: 0 },
+];
+
+describe("engineLabelFor", () => {
+  it("uses the class name when classified, raw engine otherwise", () => {
+    const m = new Map(classes.map((c) => [c.id, c]));
+    expect(engineLabelFor(e({ engineClassId: "c1", engine: "Tilly" }), m)).toBe("Tillotson 225");
+    expect(engineLabelFor(e({ engineClassId: null, engine: "225RS" }), m)).toBe("225RS");
+  });
+});
+
+describe("buildBrowseTree", () => {
+  it("collapses different raw engines into one class group", () => {
+    const tree = buildBrowseTree(
+      [
+        e({ engineClassId: "c1", engine: "Tilly", lapTimeMs: 63000 }),
+        e({ engineClassId: "c1", engine: "225RS", lapTimeMs: 61000 }),
+      ],
+      classes,
+      false,
+    );
+    expect(tree).toHaveLength(1);
+    const course = tree[0].courses[0];
+    expect(course.groups).toHaveLength(1);
+    expect(course.groups[0].label).toBe("Tillotson 225");
+    expect(course.groups[0].recordCount).toBe(2);
+    expect(course.engineCount).toBe(1);
+    expect(course.fastestMs).toBe(61000);
+    // entries + entryIds are ranked fastest-first.
+    expect(course.groups[0].entries.map((x) => x.lapTimeMs)).toEqual([61000, 63000]);
+    expect(course.groups[0].entryIds).toEqual(course.groups[0].entries.map((x) => x.id));
+  });
+
+  it("splits by exact weight when grouping by weight", () => {
+    const tree = buildBrowseTree(
+      [
+        e({ engineClassId: "c1", listedWeight: 365, lapTimeMs: 62000 }),
+        e({ engineClassId: "c1", listedWeight: 380, lapTimeMs: 61000 }),
+      ],
+      classes,
+      true,
+    );
+    const groups = tree[0].courses[0].groups;
+    expect(groups).toHaveLength(2);
+    expect(groups[0].label).toBe("Tillotson 225 · 380 lb"); // fastest first
+    expect(groups[1].label).toBe("Tillotson 225 · 365 lb");
+  });
+
+  it("orders tracks/courses/groups by fastest lap", () => {
+    const tree = buildBrowseTree(
+      [
+        e({ trackName: "Slow Track", lapTimeMs: 90000 }),
+        e({ trackName: "Fast Track", lapTimeMs: 50000 }),
+      ],
+      classes,
+      false,
+    );
+    expect(tree.map((t) => t.trackName)).toEqual(["Fast Track", "Slow Track"]);
+  });
+});
diff --git a/src/lib/leaderboardBrowse.ts b/src/lib/leaderboardBrowse.ts
new file mode 100644
index 00000000..96cfaae6
--- /dev/null
+++ b/src/lib/leaderboardBrowse.ts
@@ -0,0 +1,160 @@
+// Pure aggregation of light leaderboard rows → the Track → Course → engine/weight
+// browse tree (plan 0005). No React / network so the grouping + counting stays
+// unit-testable. Engine grouping collapses by admin class when classified, else by
+// the normalized raw engine; the "group by weight" toggle further splits by exact
+// listed weight.
+
+import type { EngineClass, LeaderboardEntry } from "./leaderboardTypes";
+
+/** One ranked entry within a group (for the leaderboard list level). */
+export interface GroupEntry {
+  id: string;
+  userId: string;
+  displayName: string;
+  lapTimeMs: number;
+}
+
+export interface GroupNode {
+  /** Stable key for this group within its course (engine[/weight]). */
+  key: string;
+  /** Display label (class name or raw engine, + weight when grouped by weight). */
+  label: string;
+  engineLabel: string;
+  weightLabel?: string;
+  /** Entry ids, fastest-first. */
+  entryIds: string[];
+  /** Ranked entries (fastest-first) for the leaderboard list. */
+  entries: GroupEntry[];
+  recordCount: number;
+  fastestMs: number;
+}
+
+export interface CourseNode {
+  courseName: string;
+  courseKey: string;
+  recordCount: number;
+  engineCount: number;
+  fastestMs: number;
+  groups: GroupNode[];
+}
+
+export interface TrackNode {
+  trackName: string;
+  recordCount: number;
+  engineCount: number;
+  fastestMs: number;
+  courses: CourseNode[];
+}
+
+/** The engine label for an entry: its admin class name, else the raw engine. */
+export function engineLabelFor(
+  entry: LeaderboardEntry,
+  classesById: Map<string, EngineClass>,
+): string {
+  if (entry.engineClassId) {
+    const cls = classesById.get(entry.engineClassId);
+    if (cls) return cls.name;
+  }
+  return entry.engine;
+}
+
+/** The grouping key for an entry's engine (class id when classified, else raw key). */
+function engineGroupKey(entry: LeaderboardEntry): string {
+  return entry.engineClassId ? `class:${entry.engineClassId}` : `raw:${entry.engineKey}`;
+}
+
+function weightLabel(entry: LeaderboardEntry): string | undefined {
+  if (entry.listedWeight == null) return undefined;
+  return `${entry.listedWeight} ${entry.listedWeightUnit ?? "lb"}`;
+}
+
+/**
+ * Build the browse tree. `groupByWeight` additionally splits each engine group by
+ * exact listed weight (no class math — exact match only). Tracks, courses and
+ * groups are each ordered by fastest lap.
+ */
+export function buildBrowseTree(
+  entries: LeaderboardEntry[],
+  classes: EngineClass[],
+  groupByWeight: boolean,
+): TrackNode[] {
+  const classesById = new Map(classes.map((c) => [c.id, c]));
+
+  // track → course → group → entries
+  const tracks = new Map<string, Map<string, Map<string, LeaderboardEntry[]>>>();
+  for (const e of entries) {
+    const courses = tracks.get(e.trackName) ?? new Map();
+    tracks.set(e.trackName, courses);
+    const groups = courses.get(e.courseKey) ?? new Map();
+    courses.set(e.courseKey, groups);
+    const gkey = groupByWeight ? `${engineGroupKey(e)}|${e.listedWeight ?? "?"}|${e.listedWeightUnit ?? ""}` : engineGroupKey(e);
+    const list = groups.get(gkey) ?? [];
+    groups.set(gkey, list);
+    list.push(e);
+  }
+
+  const fastest = (es: LeaderboardEntry[]) => es.reduce((m, e) => Math.min(m, e.lapTimeMs), Infinity);
+
+  const trackNodes: TrackNode[] = [];
+  for (const [trackName, courses] of tracks) {
+    const courseNodes: CourseNode[] = [];
+    const trackEngineKeys = new Set<string>();
+    let trackRecords = 0;
+    let trackFastest = Infinity;
+
+    for (const [courseKey, groups] of courses) {
+      const groupNodes: GroupNode[] = [];
+      const courseEngineKeys = new Set<string>();
+      let courseRecords = 0;
+      let courseFastest = Infinity;
+      let courseName = "";
+
+      for (const [gkey, es] of groups) {
+        const sample = es[0];
+        courseName = sample.courseName;
+        courseEngineKeys.add(engineGroupKey(sample));
+        trackEngineKeys.add(engineGroupKey(sample));
+        const f = fastest(es);
+        courseRecords += es.length;
+        courseFastest = Math.min(courseFastest, f);
+        const eng = engineLabelFor(sample, classesById);
+        const wl = groupByWeight ? weightLabel(sample) : undefined;
+        const ranked = [...es].sort((a, b) => a.lapTimeMs - b.lapTimeMs);
+        groupNodes.push({
+          key: gkey,
+          label: wl ? `${eng} · ${wl}` : eng,
+          engineLabel: eng,
+          weightLabel: wl,
+          entryIds: ranked.map((e) => e.id),
+          entries: ranked.map((e) => ({ id: e.id, userId: e.userId, displayName: e.displayName, lapTimeMs: e.lapTimeMs })),
+          recordCount: es.length,
+          fastestMs: f,
+        });
+      }
+
+      groupNodes.sort((a, b) => a.fastestMs - b.fastestMs);
+      trackRecords += courseRecords;
+      trackFastest = Math.min(trackFastest, courseFastest);
+      courseNodes.push({
+        courseName,
+        courseKey,
+        recordCount: courseRecords,
+        engineCount: courseEngineKeys.size,
+        fastestMs: courseFastest,
+        groups: groupNodes,
+      });
+    }
+
+    courseNodes.sort((a, b) => a.fastestMs - b.fastestMs);
+    trackNodes.push({
+      trackName,
+      recordCount: trackRecords,
+      engineCount: trackEngineKeys.size,
+      fastestMs: trackFastest,
+      courses: courseNodes,
+    });
+  }
+
+  trackNodes.sort((a, b) => a.fastestMs - b.fastestMs);
+  return trackNodes;
+}
diff --git a/src/lib/leaderboardHandoff.test.ts b/src/lib/leaderboardHandoff.test.ts
new file mode 100644
index 00000000..b40ea41a
--- /dev/null
+++ b/src/lib/leaderboardHandoff.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import {
+  hasPendingLeaderboardSession,
+  setPendingLeaderboardSession,
+  takePendingLeaderboardSession,
+} from "./leaderboardHandoff";
+import type { LeaderboardSessionBundle } from "./leaderboardSession";
+
+const bundle = { descriptor: { courseName: "c", engineLabel: "e" } } as LeaderboardSessionBundle;
+
+describe("leaderboardHandoff", () => {
+  it("hands off a session exactly once (consume-once)", () => {
+    expect(hasPendingLeaderboardSession()).toBe(false);
+    setPendingLeaderboardSession(bundle);
+    expect(hasPendingLeaderboardSession()).toBe(true);
+    expect(takePendingLeaderboardSession()).toBe(bundle);
+    // Cleared after taking.
+    expect(hasPendingLeaderboardSession()).toBe(false);
+    expect(takePendingLeaderboardSession()).toBeNull();
+  });
+});
diff --git a/src/lib/leaderboardHandoff.ts b/src/lib/leaderboardHandoff.ts
new file mode 100644
index 00000000..f7059235
--- /dev/null
+++ b/src/lib/leaderboardHandoff.ts
@@ -0,0 +1,29 @@
+// In-app handoff for the read-only leaderboard viewer (plan 0005).
+//
+// The /leaderboards page does the (async, potentially heavy) work of fetching a
+// group's entries and transposing them into a synthetic session, then stashes the
+// finished bundle here and navigates to "/". Index.tsx consumes it once on mount
+// and enters read-only mode. A module-level singleton (same shape as
+// fileLoadingState) keeps this off React context — it's a one-shot handoff, not
+// reactive state.
+
+import type { LeaderboardSessionBundle } from "./leaderboardSession";
+
+let pending: LeaderboardSessionBundle | null = null;
+
+/** Stash a built session for the next viewer mount to pick up. */
+export function setPendingLeaderboardSession(bundle: LeaderboardSessionBundle): void {
+  pending = bundle;
+}
+
+/** Consume the pending session (clears it) — null when there is none. */
+export function takePendingLeaderboardSession(): LeaderboardSessionBundle | null {
+  const p = pending;
+  pending = null;
+  return p;
+}
+
+/** Peek without consuming. */
+export function hasPendingLeaderboardSession(): boolean {
+  return pending !== null;
+}
diff --git a/src/lib/leaderboardSession.test.ts b/src/lib/leaderboardSession.test.ts
new file mode 100644
index 00000000..08c11067
--- /dev/null
+++ b/src/lib/leaderboardSession.test.ts
@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import type { Course } from "@/types/racing";
+import { buildLeaderboardSession } from "./leaderboardSession";
+import type { LeaderboardEntry } from "./leaderboardTypes";
+
+const course: Course = {
+  name: "Full CW",
+  startFinishA: { lat: 35.0, lon: -97.0 },
+  startFinishB: { lat: 35.0, lon: -97.001 },
+};
+
+function entry(id: string, name: string, lapTimeMs: number, nSamples = 5): LeaderboardEntry {
+  return {
+    id,
+    userId: `u-${id}`,
+    displayName: name,
+    trackName: "OKC",
+    courseName: "Full CW",
+    courseKey: "OKCFull CW",
+    direction: null,
+    engine: "Rotax",
+    engineKey: "rotax",
+    engineClassId: null,
+    listedWeight: 365,
+    listedWeightUnit: "lb",
+    lapTimeMs,
+    contentHash: `h-${id}`,
+    engineTelemetryPublic: false,
+    status: "approved",
+    createdAt: "2026-06-26T00:00:00Z",
+    data: {
+      samples: Array.from({ length: nSamples }, (_, i) => ({
+        t: 1000 + i * 1000, // non-zero base to exercise rebasing
+        lat: 35 + i * 1e-5,
+        lon: -97 + i * 1e-5,
+        speedMps: 20,
+        speedMph: 40 + i,
+        speedKph: 64 + i,
+        extraFields: { rpm: 12000 },
+      })),
+      fieldMappings: [{ index: 0, name: "rpm", enabled: true }],
+      course,
+      lapStartMs: 1000,
+      lapEndMs: 1000 + (nSamples - 1) * 1000,
+    },
+  };
+}
+
+describe("buildLeaderboardSession", () => {
+  it("returns null when no entry has samples", () => {
+    expect(buildLeaderboardSession([], { courseName: "x", engineLabel: "y" })).toBeNull();
+  });
+
+  it("orders laps fastest-first and labels them by submitter", () => {
+    const bundle = buildLeaderboardSession(
+      [entry("a", "Alice", 65000), entry("b", "Bob", 62000), entry("c", "Cara", 63000)],
+      { courseName: "Full CW", engineLabel: "Rotax", weightLabel: "365 lb" },
+    )!;
+    expect(bundle.laps.map((l) => l.lapNumber)).toEqual([1, 2, 3]);
+    expect(bundle.laps.map((l) => l.lapTimeMs)).toEqual([62000, 63000, 65000]);
+    expect(bundle.lapLabels).toEqual({ 1: "Bob", 2: "Cara", 3: "Alice" });
+  });
+
+  it("stacks samples with cumulative, monotonic timestamps and exact lap indices", () => {
+    const bundle = buildLeaderboardSession(
+      [entry("a", "Alice", 65000, 3), entry("b", "Bob", 62000, 4)],
+      { courseName: "Full CW", engineLabel: "Rotax" },
+    )!;
+    // Bob (fastest) first: 4 samples then Alice: 3 → 7 total.
+    expect(bundle.data.samples.length).toBe(7);
+    expect(bundle.laps[0].startIndex).toBe(0);
+    expect(bundle.laps[0].endIndex).toBe(3);
+    expect(bundle.laps[1].startIndex).toBe(4);
+    expect(bundle.laps[1].endIndex).toBe(6);
+    // First sample rebased to 0; timestamps monotonically increase.
+    expect(bundle.data.samples[0].t).toBe(0);
+    const ts = bundle.data.samples.map((s) => s.t);
+    expect([...ts].sort((x, y) => x - y)).toEqual(ts);
+    // dovex metadata carries the ordered lap times.
+    expect(bundle.data.dovexMetadata?.lapTimesMs).toEqual([62000, 65000]);
+  });
+
+  it("unions field mappings and carries the descriptor", () => {
+    const bundle = buildLeaderboardSession([entry("a", "Alice", 65000)], {
+      courseName: "Full CW",
+      engineLabel: "Rotax",
+      weightLabel: "365 lb",
+    })!;
+    expect(bundle.data.fieldMappings.map((f) => f.name)).toEqual(["rpm"]);
+    expect(bundle.descriptor).toEqual({ courseName: "Full CW", engineLabel: "Rotax", weightLabel: "365 lb" });
+    expect(bundle.selection.trackName).toBe("OKC");
+  });
+});
diff --git a/src/lib/leaderboardSession.ts b/src/lib/leaderboardSession.ts
new file mode 100644
index 00000000..dbc12640
--- /dev/null
+++ b/src/lib/leaderboardSession.ts
@@ -0,0 +1,136 @@
+// Transpose leaderboard entries → one synthetic ParsedData session (plan 0005).
+//
+// Each submitted entry is one frozen lap. We stack their clean-lap samples end to
+// end with cumulative time offsets (fastest entry → lap 1, slowest → lap N) and
+// emit one injected Lap per entry. The read-only viewer uses these laps verbatim
+// (it does NOT re-run crossing detection — the concatenated multi-driver samples
+// would never lap-detect sanely). Pure (no React / no IndexedDB) for testability.
+
+import type {
+  CourseDirection,
+  Course,
+  FieldMapping,
+  GpsSample,
+  Lap,
+  ParsedData,
+  TrackCourseSelection,
+} from "@/types/racing";
+import { calculateBounds } from "./parserUtils";
+import { computeLapSectors } from "./lapCalculation";
+import type { LeaderboardEntry } from "./leaderboardTypes";
+
+/** A small visual gap inserted between consecutive laps in the stacked timeline. */
+const LAP_GAP_MS = 1000;
+
+/** Course/engine/weight context shown above the read-only lap table. */
+export interface LeaderboardDescriptor {
+  courseName: string;
+  engineLabel: string;
+  weightLabel?: string;
+}
+
+export interface LeaderboardSessionBundle {
+  data: ParsedData;
+  course: Course;
+  selection: TrackCourseSelection;
+  laps: Lap[];
+  /** lapNumber → submitter display name (the public lap label). */
+  lapLabels: Record<number, string>;
+  descriptor: LeaderboardDescriptor;
+}
+
+/**
+ * Build a read-only session from a group's entries. Entries without a `data`
+ * payload are skipped; the rest are sorted fastest-first. Returns null when no
+ * entry carries usable samples.
+ */
+export function buildLeaderboardSession(
+  entries: LeaderboardEntry[],
+  descriptor: LeaderboardDescriptor,
+): LeaderboardSessionBundle | null {
+  const valid = entries
+    .filter((e) => e.data && e.data.samples.length > 0)
+    .sort((a, b) => a.lapTimeMs - b.lapTimeMs);
+  if (valid.length === 0) return null;
+
+  const samples: GpsSample[] = [];
+  const laps: Lap[] = [];
+  const lapLabels: Record<number, string> = {};
+  const seenFields = new Set<string>();
+  const fieldMappings: FieldMapping[] = [];
+  let offset = 0;
+
+  valid.forEach((entry, i) => {
+    const lapNumber = i + 1;
+    const src = entry.data!.samples;
+    const baseT = src[0].t;
+    const startIndex = samples.length;
+
+    let maxMph = -Infinity;
+    let minMph = Infinity;
+    let maxKph = -Infinity;
+    let minKph = Infinity;
+    for (const s of src) {
+      samples.push({ ...s, t: offset + (s.t - baseT) });
+      if (s.speedMph > maxMph) maxMph = s.speedMph;
+      if (s.speedMph < minMph) minMph = s.speedMph;
+      if (s.speedKph > maxKph) maxKph = s.speedKph;
+      if (s.speedKph < minKph) minKph = s.speedKph;
+    }
+    const endIndex = samples.length - 1;
+
+    for (const fm of entry.data!.fieldMappings) {
+      if (!seenFields.has(fm.name)) {
+        seenFields.add(fm.name);
+        fieldMappings.push(fm);
+      }
+    }
+
+    // Sector splits computed on the transposed lap (boundaries are relative to
+    // this entry's samples, so offset them into the concatenated array).
+    const sec = computeLapSectors(src, entry.data!.course);
+    const sectorBoundaries = sec.sectorBoundaries?.map((b) =>
+      b === undefined ? undefined : b + startIndex,
+    );
+
+    laps.push({
+      lapNumber,
+      startTime: samples[startIndex].t,
+      endTime: samples[endIndex].t,
+      lapTimeMs: entry.lapTimeMs,
+      maxSpeedMph: maxMph === -Infinity ? 0 : maxMph,
+      maxSpeedKph: maxKph === -Infinity ? 0 : maxKph,
+      minSpeedMph: minMph === Infinity ? 0 : minMph,
+      minSpeedKph: minKph === Infinity ? 0 : minKph,
+      startIndex,
+      endIndex,
+      sectors: sec.sectors,
+      sectorTimes: sec.sectorTimes,
+      sectorBoundaries,
+    });
+    lapLabels[lapNumber] = entry.displayName;
+    offset = samples[endIndex].t + LAP_GAP_MS;
+  });
+
+  const first = valid[0];
+  const course = first.data!.course;
+  const selection: TrackCourseSelection = {
+    trackName: first.trackName,
+    courseName: first.courseName,
+    course,
+    direction: (first.direction as CourseDirection | undefined) ?? undefined,
+  };
+
+  const data: ParsedData = {
+    samples,
+    fieldMappings,
+    bounds: calculateBounds(samples),
+    duration: samples.length > 0 ? samples[samples.length - 1].t : 0,
+    dovexMetadata: {
+      course: course.name,
+      lapTimesMs: valid.map((e) => e.lapTimeMs),
+    },
+  };
+
+  return { data, course, selection, laps, lapLabels, descriptor };
+}
diff --git a/src/lib/leaderboardTypes.ts b/src/lib/leaderboardTypes.ts
new file mode 100644
index 00000000..285c1970
--- /dev/null
+++ b/src/lib/leaderboardTypes.ts
@@ -0,0 +1,64 @@
+// Shared leaderboard types (plan 0005). Kept in lib/ (not the cloud-sync plugin)
+// so both the submission path (plugin) and the browse/viewer path (page + session
+// builder) can depend on them without coupling to Supabase.
+
+import type { Course, FieldMapping, GpsSample } from "@/types/racing";
+
+/** Canonical engine-telemetry channel ids — stripped on submit unless shared. */
+export const ENGINE_TELEMETRY_CHANNELS: ReadonlySet<string> = new Set([
+  "rpm",
+  "water_temp",
+  "oil_temp",
+  "egt",
+  "temp_1",
+  "temp_2",
+]);
+
+/** The frozen telemetry payload stored in `leaderboard_entries.data` (jsonb). */
+export interface LeaderboardEntryData {
+  /** Clean-lap samples (buffer trimmed); engine-telemetry stripped unless shared. */
+  samples: GpsSample[];
+  /** Channels present in `samples` (engine telemetry removed unless shared). */
+  fieldMappings: FieldMapping[];
+  /** Course geometry frozen at capture time. */
+  course: Course;
+  lapStartMs: number;
+  lapEndMs: number;
+}
+
+/**
+ * A `leaderboard_entries` row in app (camelCase) form. The light browse query
+ * omits `data`; opening a group re-queries the chosen rows with it.
+ */
+export interface LeaderboardEntry {
+  id: string;
+  userId: string;
+  displayName: string;
+  trackName: string;
+  courseName: string;
+  courseKey: string;
+  direction?: string | null;
+  engine: string;
+  engineKey: string;
+  engineClassId: string | null;
+  listedWeight: number | null;
+  listedWeightUnit: "lb" | "kg" | null;
+  lapTimeMs: number;
+  contentHash: string;
+  engineTelemetryPublic: boolean;
+  status: "approved" | "denied";
+  createdAt: string;
+  /** Admin-only fields (present when loaded through the admin view). */
+  classSource?: "auto" | "admin";
+  adminNotes?: string | null;
+  /** Only present once a group is opened (heavy payload). */
+  data?: LeaderboardEntryData;
+}
+
+/** An admin-managed engine classification group. */
+export interface EngineClass {
+  id: string;
+  name: string;
+  keywords: string[];
+  sortOrder: number;
+}
diff --git a/src/lib/loggers/alfano/alfanoConnection.test.ts b/src/lib/loggers/alfano/alfanoConnection.test.ts
new file mode 100644
index 00000000..556233a7
--- /dev/null
+++ b/src/lib/loggers/alfano/alfanoConnection.test.ts
@@ -0,0 +1,63 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as ipc from "./ipc";
+import { createAlfanoConnection } from "./alfanoConnection";
+
+vi.mock("./ipc", () => ({
+  loggerListFiles: vi.fn(),
+  loggerDownloadFile: vi.fn(),
+  loggerDisconnect: vi.fn(),
+}));
+
+function info(overrides: Partial<ipc.LoggerDeviceInfo> = {}): ipc.LoggerDeviceInfo {
+  return { kind: "alfano", fields: {}, ...overrides };
+}
+
+describe("createAlfanoConnection", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("reports an alfano without in-app device details", () => {
+    const conn = createAlfanoConnection(info({ name: "Alfano 6" }));
+    expect(conn.kind).toBe("alfano");
+    expect(conn.supportsDeviceDetails).toBe(false);
+    expect(conn.displayName).toBe("Alfano 6");
+  });
+
+  it("falls back name → model → brand for the display name", () => {
+    expect(createAlfanoConnection(info({ model: "Alfano 6+" })).displayName).toBe("Alfano 6+");
+    expect(createAlfanoConnection(info()).displayName).toBe("Alfano");
+  });
+
+  it("maps device file entries down to the generic LoggerFile shape", async () => {
+    vi.mocked(ipc.loggerListFiles).mockResolvedValue([
+      { name: "session_01", size: 4096, date: "2026-06-28", meta: { laps: "8" } },
+    ]);
+    const conn = createAlfanoConnection(info());
+    await expect(conn.listLogs()).resolves.toEqual([{ name: "session_01", size: 4096 }]);
+  });
+
+  it("wraps raw {received,total} progress into a full LoggerDownloadProgress", async () => {
+    const bytes = new Uint8Array([1, 2, 3]);
+    vi.mocked(ipc.loggerDownloadFile).mockImplementation(async (_name, onProgress) => {
+      onProgress({ received: 50, total: 100 });
+      return bytes;
+    });
+    const conn = createAlfanoConnection(info());
+    const onProgress = vi.fn();
+
+    await expect(conn.downloadLog("session_01", onProgress)).resolves.toBe(bytes);
+    expect(ipc.loggerDownloadFile).toHaveBeenCalledWith("session_01", expect.any(Function));
+    expect(onProgress).toHaveBeenCalledWith(
+      expect.objectContaining({ received: 50, total: 100, percent: 50 }),
+    );
+    const reported = onProgress.mock.calls[0][0];
+    expect(reported).toHaveProperty("speed");
+    expect(reported).toHaveProperty("eta");
+  });
+
+  it("delegates disconnect to the IPC teardown", () => {
+    createAlfanoConnection(info()).disconnect();
+    expect(ipc.loggerDisconnect).toHaveBeenCalled();
+  });
+});
diff --git a/src/lib/loggers/alfano/alfanoConnection.ts b/src/lib/loggers/alfano/alfanoConnection.ts
new file mode 100644
index 00000000..628faa43
--- /dev/null
+++ b/src/lib/loggers/alfano/alfanoConnection.ts
@@ -0,0 +1,41 @@
+/**
+ * Alfano native (Bluetooth-serial) adapter — wraps the native (Tauri) transport
+ * in the generic `LoggerConnection` surface so the download UI never branches on
+ * transport. Mirrors `doveslogger/dovesloggerConnection.ts`. SKELETON: the
+ * download/list commands resolve against a Rust backend that is still TBD.
+ *
+ * Importing this module pulls the native IPC client (and, lazily, Tauri) in, so
+ * only the lazy native Alfano flow should reference it — never the eager picker.
+ * Connection establishment (`loggerScan` / `loggerConnect`) happens in the UI;
+ * this factory adapts an already-connected device.
+ */
+
+import type { LoggerConnection } from "../types";
+import { computeProgress } from "../progress";
+import {
+  type LoggerDeviceInfo,
+  loggerListFiles,
+  loggerDownloadFile,
+  loggerDisconnect,
+} from "./ipc";
+
+/** Adapt a connected Alfano (described by `info`) to the generic logger interface. */
+export function createAlfanoConnection(info: LoggerDeviceInfo): LoggerConnection {
+  return {
+    kind: "alfano",
+    displayName: info.name ?? info.model ?? "Alfano",
+    // No in-app settings/tracks/firmware surfaces for Alfano — download only.
+    supportsDeviceDetails: false,
+    listLogs: async () => {
+      const files = await loggerListFiles();
+      return files.map((f) => ({ name: f.name, size: f.size }));
+    },
+    downloadLog: (name, onProgress) => {
+      const start = Date.now();
+      return loggerDownloadFile(name, ({ received, total }) => {
+        onProgress?.(computeProgress(received, total, start));
+      });
+    },
+    disconnect: () => void loggerDisconnect(),
+  };
+}
diff --git a/src/lib/loggers/alfano/ipc.test.ts b/src/lib/loggers/alfano/ipc.test.ts
new file mode 100644
index 00000000..60c3c41f
--- /dev/null
+++ b/src/lib/loggers/alfano/ipc.test.ts
@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Hoisted mock of the Tauri core API (dynamically imported by ../native/ipc).
+const { invoke, ChannelMock } = vi.hoisted(() => {
+  const invoke = vi.fn();
+  class ChannelMock<T> {
+    onmessage: ((m: T) => void) | null = null;
+  }
+  return { invoke, ChannelMock };
+});
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke, Channel: ChannelMock }));
+
+import { loggerScan, loggerConnect } from "./ipc";
+
+// The kind-agnostic commands (list / download / disconnect) are covered by
+// ../native/ipc.test.ts; this suite asserts the Alfano-specific scan/connect.
+describe("alfano ipc", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("scans with the alfano kind and returns the device list", async () => {
+    const devices = [{ id: "AA:BB", name: "Alfano 6", rssi: -52 }];
+    invoke.mockResolvedValue(devices);
+    await expect(loggerScan()).resolves.toEqual(devices);
+    expect(invoke).toHaveBeenCalledWith("logger_scan", { kind: "alfano" });
+  });
+
+  it("connects to the chosen device by id (host)", async () => {
+    invoke.mockResolvedValue({ kind: "alfano", fields: {} });
+    await loggerConnect({ host: "AA:BB" });
+    expect(invoke).toHaveBeenCalledWith("logger_connect", {
+      kind: "alfano",
+      host: "AA:BB",
+    });
+  });
+
+  it("connects to the first logger found when no host is given", async () => {
+    invoke.mockResolvedValue({ kind: "alfano", fields: {} });
+    await loggerConnect();
+    expect(invoke).toHaveBeenCalledWith("logger_connect", {
+      kind: "alfano",
+      host: undefined,
+    });
+  });
+
+  it("passes backend error strings through unwrapped (prefix preserved)", async () => {
+    invoke.mockRejectedValueOnce("unsupported: alfano backend not implemented");
+    await expect(loggerScan()).rejects.toBe("unsupported: alfano backend not implemented");
+  });
+});
diff --git a/src/lib/loggers/alfano/ipc.ts b/src/lib/loggers/alfano/ipc.ts
new file mode 100644
index 00000000..36fdafd5
--- /dev/null
+++ b/src/lib/loggers/alfano/ipc.ts
@@ -0,0 +1,64 @@
+/**
+ * Native (Tauri) IPC client for the Alfano downloader — SKELETON.
+ *
+ * Alfano loggers talk over **Bluetooth serial** (Classic Bluetooth SPP), which
+ * Web Bluetooth can't reach (it only does BLE GATT). So unlike the Fledgling
+ * there is no web path at all — Alfano downloads only ever run through the native
+ * (Tauri) shell. The Rust backend (`logger_scan` / `logger_connect` /
+ * `logger_serial_*`) is still TBD; this module is the web-side seam it plugs into.
+ *
+ * The kind-agnostic commands (list / download / device info / disconnect) and the
+ * memoized `@tauri-apps/api` loader live in `../native/ipc` and are shared with the
+ * other native loggers; this module adds only the Alfano-specific `logger_scan`
+ * and `logger_connect` (both tagged `kind: "alfano"`), and re-exports the shared
+ * surface so `alfanoConnection.ts` imports everything from here.
+ *
+ * Arg keys are camelCase and every command rejects with a plain string whose
+ * prefix encodes the error category (`device unreachable:`, `device hung:`,
+ * `protocol error:`, `unsupported:`, `no logger connected …`). We pass those
+ * strings through unwrapped so the UI can match on the prefix.
+ */
+
+import { api, type LoggerDeviceInfo } from "../native/ipc";
+
+// Re-export the shared native surface so Alfano callers import it all from here.
+export {
+  loggerDeviceInfo,
+  loggerListFiles,
+  loggerDownloadFile,
+  loggerDisconnect,
+} from "../native/ipc";
+export type { LoggerDeviceInfo, FileEntry, DownloadProgress } from "../native/ipc";
+
+/**
+ * An Alfano found during a Bluetooth-serial scan. `name`/`rssi` are DISPLAY ONLY
+ * (so the user recognizes their device); selection is by `id` (the transport
+ * address, passed back as `host` to `loggerConnect`).
+ */
+export interface ScannedDevice {
+  /** Transport address — pass back as `host` to `loggerConnect`. */
+  id: string;
+  /** Advertised name — display only. */
+  name?: string;
+  /** Signal strength, for sorting / display. */
+  rssi?: number;
+}
+
+/** Scan for nearby Alfano loggers reachable over Bluetooth serial (native only). */
+export async function loggerScan(): Promise<ScannedDevice[]> {
+  const { invoke } = await api();
+  return invoke<ScannedDevice[]>("logger_scan", { kind: "alfano" });
+}
+
+/**
+ * Connect to an Alfano over Bluetooth serial. `host` is the chosen
+ * `ScannedDevice.id`; omitting it connects to the first logger found (the picker
+ * is the intended UX).
+ */
+export async function loggerConnect(opts: { host?: string } = {}): Promise<LoggerDeviceInfo> {
+  const { invoke } = await api();
+  return invoke<LoggerDeviceInfo>("logger_connect", {
+    kind: "alfano",
+    host: opts.host,
+  });
+}
diff --git a/src/lib/trackSubmission.test.ts b/src/lib/trackSubmission.test.ts
index 4e37a15f..cfbe50cb 100644
--- a/src/lib/trackSubmission.test.ts
+++ b/src/lib/trackSubmission.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import type { Course, Track } from '@/types/racing';
 import {
+  buildCourseSubmission,
   buildSubmissionPlan,
   courseContentHash,
   courseToSubmissionData,
@@ -24,6 +25,37 @@ const sectors = {
   sector3: { a: { lat: 28.413, lon: -81.383 }, b: { lat: 28.414, lon: -81.384 } },
 };
 
+describe('buildCourseSubmission', () => {
+  const defaults: Track[] = [
+    { name: 'OKC', shortName: 'OKC', courses: [course('Full CW')] },
+  ];
+
+  it('classifies a wholly new track and auto-derives a short name', () => {
+    const sub = buildCourseSubmission('Backyard Karting', 'Loop', course('Loop'), defaults);
+    expect(sub?.type).toBe('new_track');
+    expect(sub?.change).toBe('new-track');
+    expect(sub?.trackShortName).toBeTruthy(); // derived since none was given
+    expect(sub?.courseData.start_a_lat).toBe(28.41);
+  });
+
+  it('classifies a new course on a built-in track', () => {
+    const sub = buildCourseSubmission('OKC', 'Short', course('Short'), defaults);
+    expect(sub?.type).toBe('new_course');
+    expect(sub?.change).toBe('new-course');
+  });
+
+  it('classifies an edited built-in course as a modification', () => {
+    const moved = course('Full CW', { startFinishA: { lat: 28.5, lon: -81.38 } });
+    const sub = buildCourseSubmission('OKC', 'Full CW', moved, defaults);
+    expect(sub?.type).toBe('course_modification');
+    expect(sub?.change).toBe('modified');
+  });
+
+  it('returns null when the course is identical to the built-in one', () => {
+    expect(buildCourseSubmission('OKC', 'Full CW', course('Full CW'), defaults)).toBeNull();
+  });
+});
+
 describe('courseToSubmissionData', () => {
   it('emits the flat start/finish payload without sectors', () => {
     const d = courseToSubmissionData(course('A'));
diff --git a/src/lib/trackSubmission.ts b/src/lib/trackSubmission.ts
index aab96b26..2985e56e 100644
--- a/src/lib/trackSubmission.ts
+++ b/src/lib/trackSubmission.ts
@@ -22,6 +22,7 @@ import type { Course, Track } from '@/types/racing';
 import { deriveShortName } from '@/lib/trackUtils';
 import { legacyMirror, normalizeCourseSectors } from '@/lib/courseSectors';
 import { sectorsToJson, type SectorJson } from '@/lib/trackStorage';
+import { fnv1a } from '@/lib/fnv1a';
 
 /** Flat snake_case coordinate payload — the shape the edge fn + DB expect. */
 export interface CourseSubmissionData {
@@ -137,15 +138,6 @@ export function courseToSubmissionData(course: Course): CourseSubmissionData {
 }
 
 // FNV-1a 32-bit → 8 hex chars. Not cryptographic — only change-detection.
-function fnv1a(str: string): string {
-  let h = 0x811c9dc5;
-  for (let i = 0; i < str.length; i++) {
-    h ^= str.charCodeAt(i);
-    h = Math.imul(h, 0x01000193);
-  }
-  return (h >>> 0).toString(16).padStart(8, '0');
-}
-
 /** Canonical (rounded) string for a drawn outline, or '' when there is none. */
 function layoutHashInput(layout?: Array<{ lat: number; lon: number }>): string {
   if (!layout || layout.length < 2) return '';
@@ -275,6 +267,60 @@ export function pendingCourses(plan: SubmissionPlan): SubmissionCourse[] {
   return plan.groups.flatMap((g) => g.courses.filter((c) => !c.alreadySubmitted));
 }
 
+/**
+ * Build a submission for ONE course (e.g. the frozen course inside a lap snapshot)
+ * against the built-in defaults — used to auto-submit a custom track alongside a
+ * leaderboard snapshot. Returns null when the course is byte-identical to a built-in
+ * one (nothing to contribute). Mirrors `buildSubmissionPlan`'s per-course
+ * classification, including auto-deriving a short name for a wholly new track.
+ */
+export function buildCourseSubmission(
+  trackName: string,
+  courseName: string,
+  course: Course,
+  defaults: Track[],
+  trackShortName?: string,
+): SubmissionCourse | null {
+  const key = submissionKey(trackName, courseName);
+  const hash = courseContentHash(course);
+
+  const defaultTrack = defaults.find((t) => t.name === trackName);
+  const builtinCourse = defaultTrack?.courses.find((c) => c.name === courseName);
+  const builtinHash = builtinCourse ? courseContentHash(builtinCourse) : undefined;
+
+  if (builtinHash !== undefined && builtinHash === hash) return null;
+
+  let type: SubmissionType;
+  let change: CourseChange;
+  if (!defaultTrack) {
+    type = 'new_track';
+    change = 'new-track';
+  } else if (builtinHash === undefined) {
+    type = 'new_course';
+    change = 'new-course';
+  } else {
+    type = 'course_modification';
+    change = 'modified';
+  }
+
+  const resolvedShort = type === 'new_track'
+    ? (trackShortName?.trim() || deriveShortName(trackName) || undefined)
+    : trackShortName;
+
+  return {
+    trackName,
+    trackShortName: resolvedShort,
+    courseName,
+    type,
+    change,
+    courseData: courseToSubmissionData(course),
+    layout: course.layout && course.layout.length >= 2 ? course.layout : undefined,
+    contentHash: hash,
+    key,
+    alreadySubmitted: false,
+  };
+}
+
 /**
  * Merge freshly-submitted courses into the remembered set (pure). Returns a new
  * record map; the caller persists it.
diff --git a/src/lib/vehicleStorage.ts b/src/lib/vehicleStorage.ts
index 6b9abffe..66115cf5 100644
--- a/src/lib/vehicleStorage.ts
+++ b/src/lib/vehicleStorage.ts
@@ -14,6 +14,11 @@ export interface Vehicle {
   number: number;
   weight: number;
   weightUnit: "lb" | "kg";
+  /**
+   * Opt-in: when true, a public-safe projection (name/type/engine/number — never
+   * weight/setup) is published to the user's public driver profile. See plan 0006.
+   */
+  publicProfile?: boolean;
   /** Last local edit time (ms) — set by saveVehicle; used for sync merge. */
   updatedAt?: number;
 }
diff --git a/src/locales/de/admin.json b/src/locales/de/admin.json
index 2329b70b..80ef0cd0 100644
--- a/src/locales/de/admin.json
+++ b/src/locales/de/admin.json
@@ -11,7 +11,8 @@
     "courses": "Kurse",
     "tools": "Werkzeuge",
     "banned": "Gesperrte IPs",
-    "users": "Benutzer"
+    "users": "Benutzer",
+    "leaderboards": "Bestenlisten"
   },
   "common": {
     "error": "Fehler",
@@ -51,7 +52,8 @@
       "comment": "Kommentar",
       "featureRequest": "Funktionswunsch",
       "complaint": "Beschwerde",
-      "bugReport": "Fehlerbericht"
+      "bugReport": "Fehlerbericht",
+      "newDatalogger": "Anbindung eines neuen Datenloggers"
     },
     "emailLine": "E-Mail: {{email}}",
     "ipLine": "IP: {{ip}}",
@@ -200,5 +202,43 @@
     "granted_other": "{{count}} Monate Premium gewährt",
     "grantFailed": "Aktion fehlgeschlagen",
     "grantRemoved": "Premium-Gewährung entfernt"
+  },
+  "leaderboards": {
+    "title": "Bestenlisten-Einträge",
+    "loading": "Einträge werden geladen…",
+    "loadFailed": "Einträge konnten nicht geladen werden.",
+    "empty": "Noch keine Bestenlisten-Einträge.",
+    "filterAll": "Alle",
+    "filterApproved": "Genehmigt",
+    "filterDenied": "Abgelehnt",
+    "colDriver": "Fahrer",
+    "colTrack": "Strecke / Layout",
+    "colEngine": "Motor",
+    "colClass": "Klasse",
+    "colWeight": "Gewicht",
+    "colTime": "Rundenzeit",
+    "colStatus": "Status",
+    "approve": "Genehmigen",
+    "deny": "Ablehnen",
+    "unclassified": "— Nicht klassifiziert —",
+    "notes": "Admin-Notizen",
+    "notesPlaceholder": "Interne Notizen (optional)",
+    "saveNotes": "Speichern",
+    "updated": "Eintrag aktualisiert.",
+    "updateFailed": "Eintrag konnte nicht aktualisiert werden.",
+    "classesTitle": "Motorklassen",
+    "classesHint": "Schlüsselwortgruppen, die frei eingegebene Motornamen zu einer Klasse zusammenfassen. Ein Eintrag wird automatisch der ersten Klasse zugeordnet, deren Schlüsselwort im Motornamen vorkommt.",
+    "className": "Klassenname",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "Schlüsselwörter (durch Kommas getrennt)",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "Klasse hinzufügen",
+    "saveClass": "Speichern",
+    "deleteClass": "Löschen",
+    "reclassify": "Einträge neu klassifizieren",
+    "reclassified_one": "{{count}} Eintrag neu klassifiziert.",
+    "reclassified_other": "{{count}} Einträge neu klassifiziert.",
+    "classSaved": "Motorklasse gespeichert.",
+    "classFailed": "Motorklasse konnte nicht gespeichert werden."
   }
 }
diff --git a/src/locales/de/common.json b/src/locales/de/common.json
index 9d65569a..423d7f63 100644
--- a/src/locales/de/common.json
+++ b/src/locales/de/common.json
@@ -9,7 +9,8 @@
     "loading": "Wird geladen…",
     "reset": "Auf Standard zurücksetzen",
     "update": "Aktualisieren",
-    "updating": "Wird aktualisiert…"
+    "updating": "Wird aktualisiert…",
+    "backToHome": "Zurück zur Startseite"
   },
   "language": {
     "heading": "Sprache",
diff --git a/src/locales/de/drawer.json b/src/locales/de/drawer.json
index df0022e2..8e8fbd4f 100644
--- a/src/locales/de/drawer.json
+++ b/src/locales/de/drawer.json
@@ -72,7 +72,13 @@
     "number": "Nummer",
     "weight": "Gewicht",
     "update": "Fahrzeug aktualisieren",
-    "add": "Fahrzeug hinzufügen"
+    "add": "Fahrzeug hinzufügen",
+    "engineRequired": "Ein Motor ist erforderlich.",
+    "needsEngine": "Dieses Fahrzeug benötigt einen Motor – bearbeite es, um einen hinzuzufügen.",
+    "showOnProfile": "Im Profil anzeigen",
+    "showOnProfileHint": "Zeigt dieses Fahrzeug in deinem öffentlichen Fahrerprofil an (nur Name, Typ und Motor – niemals Gewicht oder Setup).",
+    "publicBadge": "Öffentlich",
+    "publicHint": "Wird in deinem öffentlichen Fahrerprofil angezeigt."
   },
   "engine": {
     "label": "Motor",
diff --git a/src/locales/de/driver.json b/src/locales/de/driver.json
new file mode 100644
index 00000000..a53f6307
--- /dev/null
+++ b/src/locales/de/driver.json
@@ -0,0 +1,14 @@
+{
+  "_machine": true,
+  "loading": "Profil wird geladen…",
+  "loadFailed": "Dieses Profil konnte nicht geladen werden.",
+  "notFoundTitle": "Fahrer nicht gefunden",
+  "notFoundBody": "Es gibt keinen Fahrer namens “{{name}}”.",
+  "vehiclesTitle": "Fahrzeuge",
+  "vehiclesEmpty": "Dieser Fahrer hat keine Fahrzeuge geteilt.",
+  "unknownType": "Unbekannter Typ",
+  "snapshotsTitle": "Bestenlisten-Snapshots",
+  "snapshotsEmpty": "Dieser Fahrer hat keine Bestenlisten-Snapshots hochgeladen.",
+  "noWeight": "Kein angegebenes Gewicht",
+  "openSnapshot": "Diese Runde im Viewer öffnen"
+}
diff --git a/src/locales/de/landing.json b/src/locales/de/landing.json
index 90df17f0..21be37b1 100644
--- a/src/locales/de/landing.json
+++ b/src/locales/de/landing.json
@@ -27,6 +27,10 @@
     "build": {
       "title": "Bau deinen eigenen Logger",
       "description": "Open-Source-GPS-Hardware & -Firmware – der DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "Bestenlisten",
+      "description": "Vergleiche die schnellsten Runden nach Strecke, Layout und Motorklasse"
     }
   },
   "links": {
@@ -43,14 +47,16 @@
         "text": "Aktualisierter günstigerer DIY-Logger (Juni '26)"
       },
       {
-        "text": "Strecken-Bestenlisten & öffentliche Benutzerprofile (Juni '26)"
+        "text": "Strecken-Bestenlisten & öffentliche Benutzerprofile (Juni '26)",
+        "done": true
       },
       {
         "text": "Downloads von Drittanbieter-Loggern (Juni '26)",
         "sub": [
           "MyChron: dekodiert, native App erforderlich",
-          "Alfano: ausstehend"
-        ]
+          "Alfano: Bluetooth Serial, native App erforderlich"
+        ],
+        "done": true
       },
       {
         "text": "Native App (Juli '26)"
@@ -220,7 +226,8 @@
       "comment": "Kommentar",
       "featureRequest": "Funktionswunsch",
       "complaint": "Beschwerde",
-      "bugReport": "Fehlerbericht"
+      "bugReport": "Fehlerbericht",
+      "newDatalogger": "Anbindung eines neuen Datenloggers"
     },
     "emailLabel": "E-Mail",
     "emailOptional": "(optional, für eine Antwort)",
diff --git a/src/locales/de/leaderboard.json b/src/locales/de/leaderboard.json
new file mode 100644
index 00000000..d1140b12
--- /dev/null
+++ b/src/locales/de/leaderboard.json
@@ -0,0 +1,32 @@
+{
+  "_machine": true,
+  "title": "Bestenlisten",
+  "subtitle": "Die schnellsten Community-Runden nach Strecke, Layout und Motorklasse.",
+  "empty": "Noch keine Einträge :(",
+  "loadFailed": "Die Bestenlisten konnten nicht geladen werden.",
+  "loading": "Bestenlisten werden geladen…",
+  "showTop": "Top anzeigen",
+  "all": "Alle",
+  "groupByWeight": "Nach Gewicht gruppieren",
+  "bubbles": {
+    "engines_one": "{{count}} Motor",
+    "engines_other": "{{count}} Motoren",
+    "records_one": "{{count}} Eintrag",
+    "records_other": "{{count}} Einträge",
+    "fastest": "Schnellste: {{time}}"
+  },
+  "unclassifiedEngine": "Nicht klassifiziert",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "Runden ansehen",
+  "buildFailed": "Diese Sitzung konnte nicht erstellt werden.",
+  "readOnly": {
+    "banner": "Schreibgeschützte Bestenlistenansicht",
+    "exit": "Beenden",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  },
+  "loadTopSession_one": "Schnellste Runde als eine Sitzung laden",
+  "loadTopSession_other": "Top {{count}} Runden als eine Sitzung laden",
+  "loadAllSession": "Alle Runden als eine Sitzung laden",
+  "viewProfile": "Fahrerprofil ansehen"
+}
diff --git a/src/locales/de/logger.json b/src/locales/de/logger.json
index fb9ce02b..6d29dd54 100644
--- a/src/locales/de/logger.json
+++ b/src/locales/de/logger.json
@@ -6,9 +6,9 @@
   "close": "Schließen",
   "trademarks": "MyChron ist eine Marke von AiM Tech S.r.l. und Alfano ist eine Marke von Alfano S.A. LapWing ist unabhängig und steht in keiner Verbindung zu ihnen und wird von ihnen nicht unterstützt; alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Inhaber.",
   "tags": {
-    "fledgling": "DIY-Logger · Bluetooth",
+    "fledgling": "DIY-Logger · Bluetooth LE",
     "mychron": "WLAN · native App erforderlich",
-    "alfano": "Bluetooth · demnächst"
+    "alfano": "Bluetooth Serial · native App erforderlich"
   },
   "fledglingUnsupported": "Web Bluetooth wird hier nicht unterstützt – nutze Chrome, Edge oder Opera auf dem Desktop.",
   "mychron": {
@@ -51,7 +51,25 @@
     }
   },
   "alfano": {
-    "title": "Alfano-Downloads",
-    "body": "Alfano-Downloads werden dank der Bluetooth-Konnektivität des Loggers ohne native App verfügbar sein. Es geht voran – bleib dran (voraussichtlich Anfang Juli 2026)."
-  }
+    "title": "Native App erforderlich",
+    "body": "Alfano nutzt Bluetooth Serial, worauf Webbrowser im Browser nicht zugreifen können – auch dafür ist die native App erforderlich. Eine eigene native App zum Herunterladen von Alfano ist in Entwicklung.",
+    "flow": {
+      "scanning": "Suche nach Alfano-Loggern…",
+      "selectDevice": "Wähle deinen Alfano",
+      "deviceInstructions": "Tippe auf deinen Alfano, um zu verbinden:",
+      "noDevices": "Keine Alfano-Logger gefunden. Stelle sicher, dass deiner eingeschaltet und Bluetooth aktiviert ist, und suche dann erneut.",
+      "rescan": "Erneut suchen",
+      "connecting": "Verbindung…",
+      "fetching": "Sitzungen werden abgerufen…",
+      "selectFile": "Wähle eine Sitzung zum Herunterladen",
+      "downloading": "Wird heruntergeladen…",
+      "errorTitle": "Verbindungsfehler",
+      "instructions": "Tippe auf eine Sitzung, um sie herunterzuladen und zu laden:",
+      "empty": "Keine Sitzungen auf diesem Gerät",
+      "savedHint": " — die Datei wurde gespeichert und ist unter „Dateien durchsuchen“ zu finden.",
+      "retry": "Erneut versuchen",
+      "cancel": "Abbrechen"
+    }
+  },
+  "requestLogger": "Weitere Datenlogger anfragen"
 }
diff --git a/src/locales/de/plugins.json b/src/locales/de/plugins.json
index a322a4e0..ffe48366 100644
--- a/src/locales/de/plugins.json
+++ b/src/locales/de/plugins.json
@@ -6,7 +6,8 @@
     "account": "Konto",
     "lapSnapshots": "Runden-Snapshots",
     "cloudLogs": "Cloud-Logs",
-    "dataPrivacy": "Daten & Datenschutz"
+    "dataPrivacy": "Daten & Datenschutz",
+    "leaderboards": "Bestenlisten"
   },
   "account": {
     "signInBlurb": "Melde dich an, um deine Dateien, deine Garage und Notizen geräteübergreifend zu sichern und zu synchronisieren. Alles hier funktioniert weiterhin offline auf diesem Gerät — Cloud Sync ist optional.",
@@ -25,7 +26,13 @@
     "nameEmpty": "Der Anzeigename darf nicht leer sein.",
     "nameProfanity": "Bitte wähle einen saubereren Anzeigenamen.",
     "nameUpdateFailed": "Anzeigename konnte nicht aktualisiert werden.",
-    "loadUsageFailed": "Speichernutzung konnte nicht geladen werden"
+    "loadUsageFailed": "Speichernutzung konnte nicht geladen werden",
+    "changeAvatar": "Profilbild ändern",
+    "avatarUpdated": "Profilbild aktualisiert.",
+    "avatarFailed": "Profilbild konnte nicht aktualisiert werden.",
+    "copyProfileLink": "Profillink kopieren",
+    "linkCopied": "Profillink kopiert.",
+    "linkCopyFailed": "Profillink konnte nicht kopiert werden."
   },
   "plan": {
     "title": "Tarif",
@@ -172,5 +179,29 @@
     "downloadingFiles_one": "{{count}} Cloud-Datei wird heruntergeladen…",
     "downloadingFiles_other": "{{count}} Cloud-Dateien werden heruntergeladen…",
     "zipping": "Wird komprimiert…"
+  },
+  "leaderboard": {
+    "signInHint": "Melde dich an, um deine Schnappschüsse an die öffentlichen Bestenlisten zu senden.",
+    "noSnapshots": "Erfasse eine Runde, um sie an die Bestenlisten zu senden.",
+    "intro_one": "Du hast {{count}} Schnappschuss, den du an die Bestenlisten senden kannst.",
+    "intro_other": "Du hast {{count}} Schnappschüsse, die du an die Bestenlisten senden kannst.",
+    "submitButton": "An Bestenlisten senden",
+    "dialogTitle": "An Bestenlisten senden",
+    "dialogDescription": "Deine GPS-Daten, der Motor und das angegebene Gewicht sind öffentlich, damit andere Runden vergleichen und überprüfen können. Die Motorsensordaten bleiben privat, sofern du sie nicht teilst.",
+    "listedWeight": "Angegebenes Gewicht",
+    "listedWeightHint": "Wird öffentlich angezeigt und zum Gruppieren der Einträge verwendet. Standardmäßig das Gewicht deines Fahrzeugs – ändere es, wenn du lieber ein Klassengewicht angeben möchtest.",
+    "weightRequired": "Gib zum Senden ein angegebenes Gewicht ein.",
+    "shareEngineData": "Motorsensordaten teilen (Drehzahl, Temperaturen)",
+    "publicNotice": "Öffentlich: GPS, Motorname, Rundenzeit, angegebenes Gewicht.",
+    "submitOne": "Senden",
+    "submitting": "Wird gesendet…",
+    "submitted": "Gesendet",
+    "submitSuccess": "An die Bestenlisten gesendet.",
+    "submitFailed": "Senden fehlgeschlagen – bitte versuche es erneut.",
+    "alreadySubmitted": "Bereits in den Bestenlisten.",
+    "loadFailed": "Deine Einträge konnten nicht geladen werden.",
+    "close": "Schließen",
+    "customTrackNotice": "Diese Strecke ist nicht in der integrierten Liste – ihr Layout und ihre Sektoren werden mit deinem Snapshot übermittelt, und die Strecke wird zur Überprüfung der Community-Datenbank hinzugefügt.",
+    "trackAdded": "Strecke zur Überprüfung an die Community-Datenbank gesendet."
   }
 }
diff --git a/src/locales/en/admin.json b/src/locales/en/admin.json
index 057b0c32..6056a0a6 100644
--- a/src/locales/en/admin.json
+++ b/src/locales/en/admin.json
@@ -10,13 +10,52 @@
     "courses": "Courses",
     "tools": "Tools",
     "banned": "Banned IPs",
-    "users": "Users"
+    "users": "Users",
+    "leaderboards": "Leaderboards"
   },
   "common": {
     "error": "Error",
     "loading": "Loading...",
     "delete": "Delete"
   },
+  "leaderboards": {
+    "title": "Leaderboard records",
+    "loading": "Loading records…",
+    "loadFailed": "Failed to load records.",
+    "empty": "No leaderboard submissions yet.",
+    "filterAll": "All",
+    "filterApproved": "Approved",
+    "filterDenied": "Denied",
+    "colDriver": "Driver",
+    "colTrack": "Track / Course",
+    "colEngine": "Engine",
+    "colClass": "Class",
+    "colWeight": "Weight",
+    "colTime": "Lap time",
+    "colStatus": "Status",
+    "approve": "Approve",
+    "deny": "Deny",
+    "unclassified": "— Unclassified —",
+    "notes": "Admin notes",
+    "notesPlaceholder": "Internal notes (optional)",
+    "saveNotes": "Save",
+    "updated": "Record updated.",
+    "updateFailed": "Couldn't update the record.",
+    "classesTitle": "Engine classes",
+    "classesHint": "Keyword groups that collapse free-text engine names into one class. A submission auto-matches the first class whose keyword appears in its engine name.",
+    "className": "Class name",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "Keywords (comma-separated)",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "Add class",
+    "saveClass": "Save",
+    "deleteClass": "Delete",
+    "reclassify": "Reclassify records",
+    "reclassified_one": "Reclassified {{count}} record.",
+    "reclassified_other": "Reclassified {{count}} records.",
+    "classSaved": "Engine class saved.",
+    "classFailed": "Couldn't save the engine class."
+  },
   "bannedIps": {
     "title": "Banned IPs",
     "banIp": "Ban IP",
@@ -50,7 +89,8 @@
       "comment": "Comment",
       "featureRequest": "Feature Request",
       "complaint": "Complaint",
-      "bugReport": "Bug Report"
+      "bugReport": "Bug Report",
+      "newDatalogger": "New datalogger connection"
     },
     "emailLine": "Email: {{email}}",
     "ipLine": "IP: {{ip}}",
diff --git a/src/locales/en/common.json b/src/locales/en/common.json
index a3715ee4..3e4efe6c 100644
--- a/src/locales/en/common.json
+++ b/src/locales/en/common.json
@@ -4,6 +4,7 @@
     "signIn": "Sign in",
     "signOut": "Sign out",
     "profile": "Profile",
+    "backToHome": "Back to home",
     "sponsor": "Sponsor",
     "loading": "Loading…",
     "reset": "Reset to Defaults",
diff --git a/src/locales/en/drawer.json b/src/locales/en/drawer.json
index 21ded8ff..aaac936d 100644
--- a/src/locales/en/drawer.json
+++ b/src/locales/en/drawer.json
@@ -71,7 +71,13 @@
     "number": "Number",
     "weight": "Weight",
     "update": "Update Vehicle",
-    "add": "Add Vehicle"
+    "add": "Add Vehicle",
+    "engineRequired": "An engine is required.",
+    "needsEngine": "This vehicle needs an engine — edit to add one.",
+    "showOnProfile": "Show on profile",
+    "showOnProfileHint": "List this vehicle on your public driver profile (name, type and engine only — never weight or setup).",
+    "publicBadge": "Public",
+    "publicHint": "Shown on your public driver profile."
   },
   "engine": {
     "label": "Engine",
diff --git a/src/locales/en/driver.json b/src/locales/en/driver.json
new file mode 100644
index 00000000..4b9657da
--- /dev/null
+++ b/src/locales/en/driver.json
@@ -0,0 +1,13 @@
+{
+  "loading": "Loading profile…",
+  "loadFailed": "Couldn't load this profile.",
+  "notFoundTitle": "Driver not found",
+  "notFoundBody": "No driver named “{{name}}” exists.",
+  "vehiclesTitle": "Vehicles",
+  "vehiclesEmpty": "This driver hasn't shared any vehicles.",
+  "unknownType": "Unknown type",
+  "snapshotsTitle": "Leaderboard snapshots",
+  "snapshotsEmpty": "This driver hasn't uploaded any leaderboard snapshots.",
+  "noWeight": "No listed weight",
+  "openSnapshot": "Open this lap in the viewer"
+}
diff --git a/src/locales/en/landing.json b/src/locales/en/landing.json
index 38ae4280..4111ba57 100644
--- a/src/locales/en/landing.json
+++ b/src/locales/en/landing.json
@@ -26,6 +26,10 @@
     "build": {
       "title": "Build your own logger",
       "description": "Open-source GPS hardware & firmware — the DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "Leaderboards",
+      "description": "Compare fastest laps by track, course and engine class"
     }
   },
   "links": {
@@ -42,13 +46,15 @@
         "text": "Updated cheaper DIY logger (June '26)"
       },
       {
-        "text": "Track leaderboards & public user profiles (June '26)"
+        "text": "Track leaderboards & public user profiles (June '26)",
+        "done": true
       },
       {
         "text": "Downloads from 3rd-party loggers (June '26)",
+        "done": true,
         "sub": [
           "MyChron: decoded, native app required",
-          "Alfano: pending"
+          "Alfano: Bluetooth serial, native app required"
         ]
       },
       {
@@ -175,7 +181,8 @@
       "comment": "Comment",
       "featureRequest": "Feature Request",
       "complaint": "Complaint",
-      "bugReport": "Bug Report"
+      "bugReport": "Bug Report",
+      "newDatalogger": "New datalogger connection"
     },
     "emailLabel": "Email",
     "emailOptional": "(optional, for a reply)",
diff --git a/src/locales/en/leaderboard.json b/src/locales/en/leaderboard.json
new file mode 100644
index 00000000..5a6d1d7b
--- /dev/null
+++ b/src/locales/en/leaderboard.json
@@ -0,0 +1,31 @@
+{
+  "title": "Leaderboards",
+  "subtitle": "Fastest community laps by track, course and engine class.",
+  "empty": "No submissions yet :(",
+  "loadFailed": "Couldn't load the leaderboards.",
+  "loading": "Loading leaderboards…",
+  "showTop": "Show top",
+  "viewProfile": "View driver profile",
+  "all": "All",
+  "groupByWeight": "Group by weight",
+  "bubbles": {
+    "engines_one": "{{count}} engine",
+    "engines_other": "{{count}} engines",
+    "records_one": "{{count}} record",
+    "records_other": "{{count}} records",
+    "fastest": "Fastest: {{time}}"
+  },
+  "unclassifiedEngine": "Unclassified",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "View laps",
+  "loadTopSession_one": "Load top lap as a single session",
+  "loadTopSession_other": "Load top {{count}} laps as a single session",
+  "loadAllSession": "Load all laps as a single session",
+  "buildFailed": "Couldn't build that session.",
+  "readOnly": {
+    "banner": "Read-only leaderboard view",
+    "exit": "Exit",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  }
+}
diff --git a/src/locales/en/logger.json b/src/locales/en/logger.json
index 33f75e3a..fffe2cce 100644
--- a/src/locales/en/logger.json
+++ b/src/locales/en/logger.json
@@ -3,11 +3,12 @@
   "subtitle": "Choose your logger to start a download.",
   "comingSoon": "Coming soon",
   "close": "Close",
+  "requestLogger": "Request additional dataloggers",
   "trademarks": "MyChron is a trademark of AiM Tech S.r.l. and Alfano is a trademark of Alfano S.A. LapWing is independent and not affiliated with or endorsed by them; all product names, logos, and brands are the property of their respective owners.",
   "tags": {
-    "fledgling": "DIY logger · Bluetooth",
+    "fledgling": "DIY logger · Bluetooth LE",
     "mychron": "Wi-Fi · native app required",
-    "alfano": "Bluetooth · coming soon"
+    "alfano": "Bluetooth serial · native app required"
   },
   "fledglingUnsupported": "Web Bluetooth isn't supported here — use Chrome, Edge or Opera on desktop.",
   "mychron": {
@@ -50,7 +51,24 @@
     }
   },
   "alfano": {
-    "title": "Alfano downloads",
-    "body": "Alfano downloads will be available without a native app thanks to the logger's Bluetooth connectivity. Progress is being made — stay tuned for updates (estimated early July '26)."
+    "title": "Native app required",
+    "body": "Alfano uses Bluetooth serial, which web browsers can't access in-browser — it will also require the native app. A dedicated native app to download from Alfano is in development.",
+    "flow": {
+      "scanning": "Scanning for Alfano loggers…",
+      "selectDevice": "Select your Alfano",
+      "deviceInstructions": "Tap your Alfano to connect:",
+      "noDevices": "No Alfano loggers found. Make sure yours is powered on, Bluetooth is enabled, then rescan.",
+      "rescan": "Rescan",
+      "connecting": "Connecting…",
+      "fetching": "Fetching sessions…",
+      "selectFile": "Select a session to download",
+      "downloading": "Downloading…",
+      "errorTitle": "Connection error",
+      "instructions": "Tap a session to download and load it:",
+      "empty": "No sessions on this device",
+      "savedHint": " — the file was saved and can be found in Browse Files.",
+      "retry": "Try again",
+      "cancel": "Cancel"
+    }
   }
 }
diff --git a/src/locales/en/plugins.json b/src/locales/en/plugins.json
index 0cda6eef..2da136ae 100644
--- a/src/locales/en/plugins.json
+++ b/src/locales/en/plugins.json
@@ -4,9 +4,34 @@
   "panels": {
     "account": "Account",
     "lapSnapshots": "Lap snapshots",
+    "leaderboards": "Leaderboards",
     "cloudLogs": "Cloud logs",
     "dataPrivacy": "Data & privacy"
   },
+  "leaderboard": {
+    "signInHint": "Sign in to submit your snapshots to the public leaderboards.",
+    "noSnapshots": "Capture a lap snapshot to submit it to the leaderboards.",
+    "intro_one": "You have {{count}} snapshot you can submit to the leaderboards.",
+    "intro_other": "You have {{count}} snapshots you can submit to the leaderboards.",
+    "submitButton": "Submit to leaderboards",
+    "dialogTitle": "Submit to leaderboards",
+    "dialogDescription": "Your GPS data, engine, and listed weight are public so others can compare and verify laps. Your engine sensor data stays private unless you choose to share it.",
+    "listedWeight": "Listed weight",
+    "listedWeightHint": "Shown publicly and used to group records. Defaults to your vehicle weight — change it if you'd rather list a class weight.",
+    "weightRequired": "Enter a listed weight to submit.",
+    "shareEngineData": "Share engine sensor data (RPM, temps)",
+    "publicNotice": "Public: GPS, engine name, lap time, listed weight.",
+    "customTrackNotice": "This track isn't in the built-in list — its layout and sectors are submitted with your snapshot, and the track is added to the community database for review.",
+    "trackAdded": "Track sent to the community database for review.",
+    "submitOne": "Submit",
+    "submitting": "Submitting…",
+    "submitted": "Submitted",
+    "submitSuccess": "Submitted to the leaderboards.",
+    "submitFailed": "Couldn't submit — please try again.",
+    "alreadySubmitted": "Already on the leaderboards.",
+    "loadFailed": "Couldn't load your submissions.",
+    "close": "Close"
+  },
   "account": {
     "signInBlurb": "Sign in to back up and sync your files, garage and notes across devices. Everything here still works offline against this device — Cloud Sync is optional.",
     "signIn": "Sign in",
@@ -24,7 +49,13 @@
     "nameEmpty": "Display name can't be empty.",
     "nameProfanity": "Please choose a cleaner display name.",
     "nameUpdateFailed": "Couldn't update display name.",
-    "loadUsageFailed": "Failed to load storage usage"
+    "loadUsageFailed": "Failed to load storage usage",
+    "changeAvatar": "Change profile picture",
+    "avatarUpdated": "Profile picture updated.",
+    "avatarFailed": "Couldn't update profile picture.",
+    "copyProfileLink": "Copy profile link",
+    "linkCopied": "Profile link copied.",
+    "linkCopyFailed": "Couldn't copy profile link."
   },
   "plan": {
     "title": "Plan",
diff --git a/src/locales/es/admin.json b/src/locales/es/admin.json
index 7def3cd1..3577eaeb 100644
--- a/src/locales/es/admin.json
+++ b/src/locales/es/admin.json
@@ -11,7 +11,8 @@
     "courses": "Circuitos",
     "tools": "Herramientas",
     "banned": "IP bloqueadas",
-    "users": "Usuarios"
+    "users": "Usuarios",
+    "leaderboards": "Clasificaciones"
   },
   "common": {
     "error": "Error",
@@ -51,7 +52,8 @@
       "comment": "Comentario",
       "featureRequest": "Solicitud de función",
       "complaint": "Queja",
-      "bugReport": "Informe de error"
+      "bugReport": "Informe de error",
+      "newDatalogger": "Conexión de nuevo registrador de datos"
     },
     "emailLine": "Correo: {{email}}",
     "ipLine": "IP: {{ip}}",
@@ -200,5 +202,43 @@
     "granted_other": "Se concedieron {{count}} meses de premium",
     "grantFailed": "La acción falló",
     "grantRemoved": "Concesión de premium eliminada"
+  },
+  "leaderboards": {
+    "title": "Registros de clasificación",
+    "loading": "Cargando registros…",
+    "loadFailed": "Error al cargar los registros.",
+    "empty": "Aún no hay envíos a las clasificaciones.",
+    "filterAll": "Todos",
+    "filterApproved": "Aprobados",
+    "filterDenied": "Rechazados",
+    "colDriver": "Piloto",
+    "colTrack": "Circuito / Trazado",
+    "colEngine": "Motor",
+    "colClass": "Clase",
+    "colWeight": "Peso",
+    "colTime": "Tiempo de vuelta",
+    "colStatus": "Estado",
+    "approve": "Aprobar",
+    "deny": "Rechazar",
+    "unclassified": "— Sin clasificar —",
+    "notes": "Notas de administración",
+    "notesPlaceholder": "Notas internas (opcional)",
+    "saveNotes": "Guardar",
+    "updated": "Registro actualizado.",
+    "updateFailed": "No se pudo actualizar el registro.",
+    "classesTitle": "Clases de motor",
+    "classesHint": "Grupos de palabras clave que unifican los nombres de motor de texto libre en una sola clase. Un envío coincide automáticamente con la primera clase cuya palabra clave aparezca en el nombre del motor.",
+    "className": "Nombre de la clase",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "Palabras clave (separadas por comas)",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "Añadir clase",
+    "saveClass": "Guardar",
+    "deleteClass": "Eliminar",
+    "reclassify": "Reclasificar registros",
+    "reclassified_one": "Se reclasificó {{count}} registro.",
+    "reclassified_other": "Se reclasificaron {{count}} registros.",
+    "classSaved": "Clase de motor guardada.",
+    "classFailed": "No se pudo guardar la clase de motor."
   }
 }
diff --git a/src/locales/es/common.json b/src/locales/es/common.json
index 4942547e..8aee2704 100644
--- a/src/locales/es/common.json
+++ b/src/locales/es/common.json
@@ -9,7 +9,8 @@
     "loading": "Cargando…",
     "reset": "Restablecer valores predeterminados",
     "update": "Actualizar",
-    "updating": "Actualizando…"
+    "updating": "Actualizando…",
+    "backToHome": "Volver al inicio"
   },
   "language": {
     "heading": "Idioma",
diff --git a/src/locales/es/drawer.json b/src/locales/es/drawer.json
index c9162be6..a0be18d0 100644
--- a/src/locales/es/drawer.json
+++ b/src/locales/es/drawer.json
@@ -72,7 +72,13 @@
     "number": "Número",
     "weight": "Peso",
     "update": "Actualizar vehículo",
-    "add": "Añadir vehículo"
+    "add": "Añadir vehículo",
+    "engineRequired": "Se requiere un motor.",
+    "needsEngine": "Este vehículo necesita un motor; edítalo para añadir uno.",
+    "showOnProfile": "Mostrar en el perfil",
+    "showOnProfileHint": "Muestra este vehículo en tu perfil público de piloto (solo nombre, tipo y motor, nunca peso ni configuración).",
+    "publicBadge": "Público",
+    "publicHint": "Se muestra en tu perfil público de piloto."
   },
   "engine": {
     "label": "Motor",
diff --git a/src/locales/es/driver.json b/src/locales/es/driver.json
new file mode 100644
index 00000000..9a1a1391
--- /dev/null
+++ b/src/locales/es/driver.json
@@ -0,0 +1,14 @@
+{
+  "_machine": true,
+  "loading": "Cargando perfil…",
+  "loadFailed": "No se pudo cargar este perfil.",
+  "notFoundTitle": "Piloto no encontrado",
+  "notFoundBody": "No existe ningún piloto llamado “{{name}}”.",
+  "vehiclesTitle": "Vehículos",
+  "vehiclesEmpty": "Este piloto no ha compartido ningún vehículo.",
+  "unknownType": "Tipo desconocido",
+  "snapshotsTitle": "Capturas de la clasificación",
+  "snapshotsEmpty": "Este piloto no ha subido ninguna captura a la clasificación.",
+  "noWeight": "Sin peso indicado",
+  "openSnapshot": "Abrir esta vuelta en el visor"
+}
diff --git a/src/locales/es/landing.json b/src/locales/es/landing.json
index 041e9bcc..b23a3650 100644
--- a/src/locales/es/landing.json
+++ b/src/locales/es/landing.json
@@ -27,6 +27,10 @@
     "build": {
       "title": "Construye tu propio registrador",
       "description": "Hardware y firmware GPS de código abierto: el DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "Clasificaciones",
+      "description": "Compara las vueltas más rápidas por circuito, trazado y clase de motor"
     }
   },
   "links": {
@@ -43,14 +47,16 @@
         "text": "Logger DIY más económico actualizado (junio '26)"
       },
       {
-        "text": "Clasificaciones de circuitos y perfiles públicos de usuario (junio '26)"
+        "text": "Clasificaciones de circuitos y perfiles públicos de usuario (junio '26)",
+        "done": true
       },
       {
         "text": "Descargas desde loggers de terceros (junio '26)",
         "sub": [
           "MyChron: decodificado, requiere aplicación nativa",
-          "Alfano: pendiente"
-        ]
+          "Alfano: Bluetooth serie, requiere app nativa"
+        ],
+        "done": true
       },
       {
         "text": "Aplicación nativa (julio '26)"
@@ -220,7 +226,8 @@
       "comment": "Comentario",
       "featureRequest": "Solicitud de función",
       "complaint": "Queja",
-      "bugReport": "Informe de error"
+      "bugReport": "Informe de error",
+      "newDatalogger": "Conexión de nuevo registrador de datos"
     },
     "emailLabel": "Correo electrónico",
     "emailOptional": "(opcional, para responderte)",
diff --git a/src/locales/es/leaderboard.json b/src/locales/es/leaderboard.json
new file mode 100644
index 00000000..a03df883
--- /dev/null
+++ b/src/locales/es/leaderboard.json
@@ -0,0 +1,32 @@
+{
+  "_machine": true,
+  "title": "Clasificaciones",
+  "subtitle": "Las vueltas más rápidas de la comunidad por circuito, trazado y clase de motor.",
+  "empty": "Aún no hay envíos :(",
+  "loadFailed": "No se pudieron cargar las clasificaciones.",
+  "loading": "Cargando clasificaciones…",
+  "showTop": "Mostrar los mejores",
+  "all": "Todos",
+  "groupByWeight": "Agrupar por peso",
+  "bubbles": {
+    "engines_one": "{{count}} motor",
+    "engines_other": "{{count}} motores",
+    "records_one": "{{count}} registro",
+    "records_other": "{{count}} registros",
+    "fastest": "Más rápida: {{time}}"
+  },
+  "unclassifiedEngine": "Sin clasificar",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "Ver vueltas",
+  "buildFailed": "No se pudo crear esa sesión.",
+  "readOnly": {
+    "banner": "Vista de clasificación de solo lectura",
+    "exit": "Salir",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  },
+  "loadTopSession_one": "Cargar la vuelta más rápida como una sola sesión",
+  "loadTopSession_other": "Cargar las {{count}} mejores vueltas como una sola sesión",
+  "loadAllSession": "Cargar todas las vueltas como una sola sesión",
+  "viewProfile": "Ver perfil del piloto"
+}
diff --git a/src/locales/es/logger.json b/src/locales/es/logger.json
index 8c84ea42..c994c1d1 100644
--- a/src/locales/es/logger.json
+++ b/src/locales/es/logger.json
@@ -6,9 +6,9 @@
   "close": "Cerrar",
   "trademarks": "MyChron es una marca registrada de AiM Tech S.r.l. y Alfano es una marca registrada de Alfano S.A. LapWing es independiente y no está afiliada ni respaldada por ellas; todos los nombres de productos, logotipos y marcas son propiedad de sus respectivos dueños.",
   "tags": {
-    "fledgling": "Registrador DIY · Bluetooth",
+    "fledgling": "Registrador DIY · Bluetooth LE",
     "mychron": "Wi-Fi · requiere app nativa",
-    "alfano": "Bluetooth · próximamente"
+    "alfano": "Bluetooth serie · requiere app nativa"
   },
   "fledglingUnsupported": "Web Bluetooth no es compatible aquí: usa Chrome, Edge u Opera en ordenador.",
   "mychron": {
@@ -51,7 +51,25 @@
     }
   },
   "alfano": {
-    "title": "Descargas de Alfano",
-    "body": "Las descargas de Alfano estarán disponibles sin una app nativa gracias a la conectividad Bluetooth del registrador. Se está avanzando; mantente atento a las novedades (estimado para principios de julio de 2026)."
-  }
+    "title": "Se necesita app nativa",
+    "body": "Alfano usa Bluetooth serie, al que los navegadores web no pueden acceder en el navegador, y también requerirá la app nativa. Hay una app nativa específica para descargar de Alfano en desarrollo.",
+    "flow": {
+      "scanning": "Buscando registradores Alfano…",
+      "selectDevice": "Selecciona tu Alfano",
+      "deviceInstructions": "Toca tu Alfano para conectar:",
+      "noDevices": "No se encontraron registradores Alfano. Asegúrate de que el tuyo esté encendido y el Bluetooth activado, luego vuelve a buscar.",
+      "rescan": "Buscar de nuevo",
+      "connecting": "Conectando…",
+      "fetching": "Obteniendo sesiones…",
+      "selectFile": "Selecciona una sesión para descargar",
+      "downloading": "Descargando…",
+      "errorTitle": "Error de conexión",
+      "instructions": "Toca una sesión para descargarla y cargarla:",
+      "empty": "No hay sesiones en este dispositivo",
+      "savedHint": " — el archivo se guardó y puedes encontrarlo en Explorar archivos.",
+      "retry": "Reintentar",
+      "cancel": "Cancelar"
+    }
+  },
+  "requestLogger": "Solicitar más registradores de datos"
 }
diff --git a/src/locales/es/plugins.json b/src/locales/es/plugins.json
index c3b5b59f..74b5dd6b 100644
--- a/src/locales/es/plugins.json
+++ b/src/locales/es/plugins.json
@@ -6,7 +6,8 @@
     "account": "Cuenta",
     "lapSnapshots": "Instantáneas de vuelta",
     "cloudLogs": "Registros en la nube",
-    "dataPrivacy": "Datos y privacidad"
+    "dataPrivacy": "Datos y privacidad",
+    "leaderboards": "Clasificaciones"
   },
   "account": {
     "signInBlurb": "Inicia sesión para respaldar y sincronizar tus archivos, garaje y notas entre dispositivos. Todo aquí sigue funcionando sin conexión en este dispositivo: Cloud Sync es opcional.",
@@ -25,7 +26,13 @@
     "nameEmpty": "El nombre para mostrar no puede estar vacío.",
     "nameProfanity": "Elige un nombre para mostrar más limpio, por favor.",
     "nameUpdateFailed": "No se pudo actualizar el nombre para mostrar.",
-    "loadUsageFailed": "No se pudo cargar el uso de almacenamiento"
+    "loadUsageFailed": "No se pudo cargar el uso de almacenamiento",
+    "changeAvatar": "Cambiar foto de perfil",
+    "avatarUpdated": "Foto de perfil actualizada.",
+    "avatarFailed": "No se pudo actualizar la foto de perfil.",
+    "copyProfileLink": "Copiar enlace del perfil",
+    "linkCopied": "Enlace del perfil copiado.",
+    "linkCopyFailed": "No se pudo copiar el enlace del perfil."
   },
   "plan": {
     "title": "Plan",
@@ -172,5 +179,29 @@
     "downloadingFiles_one": "Descargando {{count}} archivo de la nube…",
     "downloadingFiles_other": "Descargando {{count}} archivos de la nube…",
     "zipping": "Comprimiendo…"
+  },
+  "leaderboard": {
+    "signInHint": "Inicia sesión para enviar tus capturas a las clasificaciones públicas.",
+    "noSnapshots": "Captura una vuelta para enviarla a las clasificaciones.",
+    "intro_one": "Tienes {{count}} captura que puedes enviar a las clasificaciones.",
+    "intro_other": "Tienes {{count}} capturas que puedes enviar a las clasificaciones.",
+    "submitButton": "Enviar a las clasificaciones",
+    "dialogTitle": "Enviar a las clasificaciones",
+    "dialogDescription": "Tus datos de GPS, el motor y el peso indicado son públicos para que otros puedan comparar y verificar las vueltas. Los datos del sensor del motor permanecen privados a menos que decidas compartirlos.",
+    "listedWeight": "Peso indicado",
+    "listedWeightHint": "Se muestra públicamente y se usa para agrupar los registros. Por defecto es el peso de tu vehículo: cámbialo si prefieres indicar un peso de categoría.",
+    "weightRequired": "Introduce un peso indicado para enviar.",
+    "shareEngineData": "Compartir datos del sensor del motor (RPM, temperaturas)",
+    "publicNotice": "Público: GPS, nombre del motor, tiempo de vuelta, peso indicado.",
+    "submitOne": "Enviar",
+    "submitting": "Enviando…",
+    "submitted": "Enviado",
+    "submitSuccess": "Enviado a las clasificaciones.",
+    "submitFailed": "No se pudo enviar; inténtalo de nuevo.",
+    "alreadySubmitted": "Ya está en las clasificaciones.",
+    "loadFailed": "No se pudieron cargar tus envíos.",
+    "close": "Cerrar",
+    "customTrackNotice": "Este circuito no está en la lista integrada: su trazado y sectores se envían con tu captura, y el circuito se añade a la base de datos de la comunidad para su revisión.",
+    "trackAdded": "Circuito enviado a la base de datos de la comunidad para su revisión."
   }
 }
diff --git a/src/locales/fr/admin.json b/src/locales/fr/admin.json
index 55c3a819..ba2bf3d4 100644
--- a/src/locales/fr/admin.json
+++ b/src/locales/fr/admin.json
@@ -11,7 +11,8 @@
     "courses": "Parcours",
     "tools": "Outils",
     "banned": "IP bannies",
-    "users": "Utilisateurs"
+    "users": "Utilisateurs",
+    "leaderboards": "Classements"
   },
   "common": {
     "error": "Erreur",
@@ -51,7 +52,8 @@
       "comment": "Commentaire",
       "featureRequest": "Demande de fonctionnalité",
       "complaint": "Réclamation",
-      "bugReport": "Rapport de bug"
+      "bugReport": "Rapport de bug",
+      "newDatalogger": "Connexion d'un nouvel enregistreur de données"
     },
     "emailLine": "E-mail : {{email}}",
     "ipLine": "IP : {{ip}}",
@@ -200,5 +202,43 @@
     "granted_other": "{{count}} mois de premium offerts",
     "grantFailed": "L'action a échoué",
     "grantRemoved": "Offre premium retirée"
+  },
+  "leaderboards": {
+    "title": "Enregistrements de classement",
+    "loading": "Chargement des enregistrements…",
+    "loadFailed": "Échec du chargement des enregistrements.",
+    "empty": "Aucun envoi de classement pour l'instant.",
+    "filterAll": "Tous",
+    "filterApproved": "Approuvés",
+    "filterDenied": "Refusés",
+    "colDriver": "Pilote",
+    "colTrack": "Circuit / Tracé",
+    "colEngine": "Moteur",
+    "colClass": "Catégorie",
+    "colWeight": "Poids",
+    "colTime": "Temps au tour",
+    "colStatus": "Statut",
+    "approve": "Approuver",
+    "deny": "Refuser",
+    "unclassified": "— Non classé —",
+    "notes": "Notes d'administration",
+    "notesPlaceholder": "Notes internes (facultatif)",
+    "saveNotes": "Enregistrer",
+    "updated": "Enregistrement mis à jour.",
+    "updateFailed": "Impossible de mettre à jour l'enregistrement.",
+    "classesTitle": "Catégories de moteur",
+    "classesHint": "Groupes de mots-clés qui regroupent les noms de moteur en texte libre dans une seule catégorie. Un envoi correspond automatiquement à la première catégorie dont le mot-clé apparaît dans le nom du moteur.",
+    "className": "Nom de la catégorie",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "Mots-clés (séparés par des virgules)",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "Ajouter une catégorie",
+    "saveClass": "Enregistrer",
+    "deleteClass": "Supprimer",
+    "reclassify": "Reclasser les enregistrements",
+    "reclassified_one": "{{count}} enregistrement reclassé.",
+    "reclassified_other": "{{count}} enregistrements reclassés.",
+    "classSaved": "Catégorie de moteur enregistrée.",
+    "classFailed": "Impossible d'enregistrer la catégorie de moteur."
   }
 }
diff --git a/src/locales/fr/common.json b/src/locales/fr/common.json
index 95bd92a6..02c95d74 100644
--- a/src/locales/fr/common.json
+++ b/src/locales/fr/common.json
@@ -9,7 +9,8 @@
     "loading": "Chargement…",
     "reset": "Réinitialiser les valeurs par défaut",
     "update": "Mettre à jour",
-    "updating": "Mise à jour…"
+    "updating": "Mise à jour…",
+    "backToHome": "Retour à l'accueil"
   },
   "language": {
     "heading": "Langue",
diff --git a/src/locales/fr/drawer.json b/src/locales/fr/drawer.json
index 64fe2cfb..595aa990 100644
--- a/src/locales/fr/drawer.json
+++ b/src/locales/fr/drawer.json
@@ -72,7 +72,13 @@
     "number": "Numéro",
     "weight": "Poids",
     "update": "Mettre à jour le véhicule",
-    "add": "Ajouter un véhicule"
+    "add": "Ajouter un véhicule",
+    "engineRequired": "Un moteur est requis.",
+    "needsEngine": "Ce véhicule a besoin d'un moteur — modifiez-le pour en ajouter un.",
+    "showOnProfile": "Afficher sur le profil",
+    "showOnProfileHint": "Affiche ce véhicule sur votre profil public de pilote (nom, type et moteur uniquement — jamais le poids ni les réglages).",
+    "publicBadge": "Public",
+    "publicHint": "Affiché sur votre profil public de pilote."
   },
   "engine": {
     "label": "Moteur",
diff --git a/src/locales/fr/driver.json b/src/locales/fr/driver.json
new file mode 100644
index 00000000..3ea1a414
--- /dev/null
+++ b/src/locales/fr/driver.json
@@ -0,0 +1,14 @@
+{
+  "_machine": true,
+  "loading": "Chargement du profil…",
+  "loadFailed": "Impossible de charger ce profil.",
+  "notFoundTitle": "Pilote introuvable",
+  "notFoundBody": "Aucun pilote nommé “{{name}}” n'existe.",
+  "vehiclesTitle": "Véhicules",
+  "vehiclesEmpty": "Ce pilote n'a partagé aucun véhicule.",
+  "unknownType": "Type inconnu",
+  "snapshotsTitle": "Instantanés du classement",
+  "snapshotsEmpty": "Ce pilote n'a téléversé aucun instantané au classement.",
+  "noWeight": "Aucun poids indiqué",
+  "openSnapshot": "Ouvrir ce tour dans la visionneuse"
+}
diff --git a/src/locales/fr/landing.json b/src/locales/fr/landing.json
index 8ce64e13..3b3053d1 100644
--- a/src/locales/fr/landing.json
+++ b/src/locales/fr/landing.json
@@ -27,6 +27,10 @@
     "build": {
       "title": "Construisez votre propre enregistreur",
       "description": "Matériel et firmware GPS open source : le DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "Classements",
+      "description": "Comparez les tours les plus rapides par circuit, tracé et catégorie de moteur"
     }
   },
   "links": {
@@ -43,14 +47,16 @@
         "text": "Logger DIY moins cher mis à jour (juin '26)"
       },
       {
-        "text": "Classements de circuits et profils publics (juin '26)"
+        "text": "Classements de circuits et profils publics (juin '26)",
+        "done": true
       },
       {
         "text": "Téléchargements depuis des loggers tiers (juin '26)",
         "sub": [
           "MyChron : décodé, application native requise",
-          "Alfano : en attente"
-        ]
+          "Alfano : Bluetooth série, app native requise"
+        ],
+        "done": true
       },
       {
         "text": "Application native (juillet '26)"
@@ -220,7 +226,8 @@
       "comment": "Commentaire",
       "featureRequest": "Demande de fonctionnalité",
       "complaint": "Réclamation",
-      "bugReport": "Rapport de bug"
+      "bugReport": "Rapport de bug",
+      "newDatalogger": "Connexion d'un nouvel enregistreur de données"
     },
     "emailLabel": "E-mail",
     "emailOptional": "(facultatif, pour une réponse)",
diff --git a/src/locales/fr/leaderboard.json b/src/locales/fr/leaderboard.json
new file mode 100644
index 00000000..27a4021e
--- /dev/null
+++ b/src/locales/fr/leaderboard.json
@@ -0,0 +1,32 @@
+{
+  "_machine": true,
+  "title": "Classements",
+  "subtitle": "Les tours les plus rapides de la communauté par circuit, tracé et catégorie de moteur.",
+  "empty": "Aucun envoi pour l'instant :(",
+  "loadFailed": "Impossible de charger les classements.",
+  "loading": "Chargement des classements…",
+  "showTop": "Afficher le top",
+  "all": "Tous",
+  "groupByWeight": "Grouper par poids",
+  "bubbles": {
+    "engines_one": "{{count}} moteur",
+    "engines_other": "{{count}} moteurs",
+    "records_one": "{{count}} record",
+    "records_other": "{{count}} records",
+    "fastest": "Plus rapide : {{time}}"
+  },
+  "unclassifiedEngine": "Non classé",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "Voir les tours",
+  "buildFailed": "Impossible de créer cette session.",
+  "readOnly": {
+    "banner": "Vue de classement en lecture seule",
+    "exit": "Quitter",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  },
+  "loadTopSession_one": "Charger le meilleur tour en une seule session",
+  "loadTopSession_other": "Charger les {{count}} meilleurs tours en une seule session",
+  "loadAllSession": "Charger tous les tours en une seule session",
+  "viewProfile": "Voir le profil du pilote"
+}
diff --git a/src/locales/fr/logger.json b/src/locales/fr/logger.json
index 03b37b41..e9b6a9f7 100644
--- a/src/locales/fr/logger.json
+++ b/src/locales/fr/logger.json
@@ -6,9 +6,9 @@
   "close": "Fermer",
   "trademarks": "MyChron est une marque déposée d'AiM Tech S.r.l. et Alfano est une marque déposée d'Alfano S.A. LapWing est indépendant et n'est ni affilié ni approuvé par eux ; tous les noms de produits, logos et marques appartiennent à leurs propriétaires respectifs.",
   "tags": {
-    "fledgling": "Enregistreur DIY · Bluetooth",
+    "fledgling": "Enregistreur DIY · Bluetooth LE",
     "mychron": "Wi-Fi · app native requise",
-    "alfano": "Bluetooth · bientôt disponible"
+    "alfano": "Bluetooth série · app native requise"
   },
   "fledglingUnsupported": "Web Bluetooth n'est pas pris en charge ici — utilisez Chrome, Edge ou Opera sur ordinateur.",
   "mychron": {
@@ -51,7 +51,25 @@
     }
   },
   "alfano": {
-    "title": "Téléchargements Alfano",
-    "body": "Les téléchargements Alfano seront disponibles sans app native grâce à la connectivité Bluetooth de l'enregistreur. Des progrès sont en cours — restez à l'écoute (estimé début juillet 2026)."
-  }
+    "title": "App native requise",
+    "body": "Alfano utilise le Bluetooth série, auquel les navigateurs web ne peuvent pas accéder dans le navigateur — l'app native sera également requise. Une app native dédiée au téléchargement depuis Alfano est en cours de développement.",
+    "flow": {
+      "scanning": "Recherche d'enregistreurs Alfano…",
+      "selectDevice": "Sélectionnez votre Alfano",
+      "deviceInstructions": "Touchez votre Alfano pour vous connecter :",
+      "noDevices": "Aucun enregistreur Alfano trouvé. Assurez-vous que le vôtre est allumé et que le Bluetooth est activé, puis relancez la recherche.",
+      "rescan": "Relancer la recherche",
+      "connecting": "Connexion…",
+      "fetching": "Récupération des sessions…",
+      "selectFile": "Sélectionnez une session à télécharger",
+      "downloading": "Téléchargement…",
+      "errorTitle": "Erreur de connexion",
+      "instructions": "Touchez une session pour la télécharger et la charger :",
+      "empty": "Aucune session sur cet appareil",
+      "savedHint": " — le fichier a été enregistré et se trouve dans Parcourir les fichiers.",
+      "retry": "Réessayer",
+      "cancel": "Annuler"
+    }
+  },
+  "requestLogger": "Demander d'autres enregistreurs de données"
 }
diff --git a/src/locales/fr/plugins.json b/src/locales/fr/plugins.json
index a3c26e56..7bef81ba 100644
--- a/src/locales/fr/plugins.json
+++ b/src/locales/fr/plugins.json
@@ -6,7 +6,8 @@
     "account": "Compte",
     "lapSnapshots": "Instantanés de tour",
     "cloudLogs": "Journaux dans le cloud",
-    "dataPrivacy": "Données et confidentialité"
+    "dataPrivacy": "Données et confidentialité",
+    "leaderboards": "Classements"
   },
   "account": {
     "signInBlurb": "Connectez-vous pour sauvegarder et synchroniser vos fichiers, votre garage et vos notes sur tous vos appareils. Tout ici fonctionne toujours hors ligne sur cet appareil — Cloud Sync est optionnel.",
@@ -25,7 +26,13 @@
     "nameEmpty": "Le nom d'affichage ne peut pas être vide.",
     "nameProfanity": "Veuillez choisir un nom d'affichage plus correct.",
     "nameUpdateFailed": "Impossible de mettre à jour le nom d'affichage.",
-    "loadUsageFailed": "Impossible de charger l'utilisation du stockage"
+    "loadUsageFailed": "Impossible de charger l'utilisation du stockage",
+    "changeAvatar": "Changer la photo de profil",
+    "avatarUpdated": "Photo de profil mise à jour.",
+    "avatarFailed": "Impossible de mettre à jour la photo de profil.",
+    "copyProfileLink": "Copier le lien du profil",
+    "linkCopied": "Lien du profil copié.",
+    "linkCopyFailed": "Impossible de copier le lien du profil."
   },
   "plan": {
     "title": "Forfait",
@@ -172,5 +179,29 @@
     "downloadingFiles_one": "Téléchargement de {{count}} fichier du cloud…",
     "downloadingFiles_other": "Téléchargement de {{count}} fichiers du cloud…",
     "zipping": "Compression…"
+  },
+  "leaderboard": {
+    "signInHint": "Connectez-vous pour envoyer vos instantanés aux classements publics.",
+    "noSnapshots": "Capturez un tour pour l'envoyer aux classements.",
+    "intro_one": "Vous avez {{count}} instantané à envoyer aux classements.",
+    "intro_other": "Vous avez {{count}} instantanés à envoyer aux classements.",
+    "submitButton": "Envoyer aux classements",
+    "dialogTitle": "Envoyer aux classements",
+    "dialogDescription": "Vos données GPS, le moteur et le poids indiqué sont publics afin que d'autres puissent comparer et vérifier les tours. Les données du capteur moteur restent privées sauf si vous choisissez de les partager.",
+    "listedWeight": "Poids indiqué",
+    "listedWeightHint": "Affiché publiquement et utilisé pour regrouper les records. Par défaut, le poids de votre véhicule — changez-le si vous préférez indiquer un poids de catégorie.",
+    "weightRequired": "Saisissez un poids indiqué pour envoyer.",
+    "shareEngineData": "Partager les données du capteur moteur (régime, températures)",
+    "publicNotice": "Public : GPS, nom du moteur, temps au tour, poids indiqué.",
+    "submitOne": "Envoyer",
+    "submitting": "Envoi…",
+    "submitted": "Envoyé",
+    "submitSuccess": "Envoyé aux classements.",
+    "submitFailed": "Échec de l'envoi — veuillez réessayer.",
+    "alreadySubmitted": "Déjà dans les classements.",
+    "loadFailed": "Impossible de charger vos envois.",
+    "close": "Fermer",
+    "customTrackNotice": "Ce circuit n'est pas dans la liste intégrée : son tracé et ses secteurs sont envoyés avec votre instantané, et le circuit est ajouté à la base de données communautaire pour révision.",
+    "trackAdded": "Circuit envoyé à la base de données communautaire pour révision."
   }
 }
diff --git a/src/locales/it/admin.json b/src/locales/it/admin.json
index e53ba77e..23face81 100644
--- a/src/locales/it/admin.json
+++ b/src/locales/it/admin.json
@@ -11,7 +11,8 @@
     "courses": "Circuiti",
     "tools": "Strumenti",
     "banned": "IP bloccati",
-    "users": "Utenti"
+    "users": "Utenti",
+    "leaderboards": "Classifiche"
   },
   "common": {
     "error": "Errore",
@@ -51,7 +52,8 @@
       "comment": "Commento",
       "featureRequest": "Richiesta di funzionalità",
       "complaint": "Reclamo",
-      "bugReport": "Segnalazione di bug"
+      "bugReport": "Segnalazione di bug",
+      "newDatalogger": "Connessione di un nuovo data logger"
     },
     "emailLine": "Email: {{email}}",
     "ipLine": "IP: {{ip}}",
@@ -200,5 +202,43 @@
     "granted_other": "Concessi {{count}} mesi di premium",
     "grantFailed": "Azione non riuscita",
     "grantRemoved": "Concessione premium rimossa"
+  },
+  "leaderboards": {
+    "title": "Record delle classifiche",
+    "loading": "Caricamento record…",
+    "loadFailed": "Impossibile caricare i record.",
+    "empty": "Ancora nessun invio alle classifiche.",
+    "filterAll": "Tutti",
+    "filterApproved": "Approvati",
+    "filterDenied": "Rifiutati",
+    "colDriver": "Pilota",
+    "colTrack": "Pista / Tracciato",
+    "colEngine": "Motore",
+    "colClass": "Classe",
+    "colWeight": "Peso",
+    "colTime": "Tempo sul giro",
+    "colStatus": "Stato",
+    "approve": "Approva",
+    "deny": "Rifiuta",
+    "unclassified": "— Non classificato —",
+    "notes": "Note amministratore",
+    "notesPlaceholder": "Note interne (facoltativo)",
+    "saveNotes": "Salva",
+    "updated": "Record aggiornato.",
+    "updateFailed": "Impossibile aggiornare il record.",
+    "classesTitle": "Classi motore",
+    "classesHint": "Gruppi di parole chiave che uniscono i nomi di motore in testo libero in un'unica classe. Un invio corrisponde automaticamente alla prima classe la cui parola chiave compare nel nome del motore.",
+    "className": "Nome della classe",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "Parole chiave (separate da virgole)",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "Aggiungi classe",
+    "saveClass": "Salva",
+    "deleteClass": "Elimina",
+    "reclassify": "Riclassifica record",
+    "reclassified_one": "{{count}} record riclassificato.",
+    "reclassified_other": "{{count}} record riclassificati.",
+    "classSaved": "Classe motore salvata.",
+    "classFailed": "Impossibile salvare la classe motore."
   }
 }
diff --git a/src/locales/it/common.json b/src/locales/it/common.json
index ec6bc44d..0b2ac798 100644
--- a/src/locales/it/common.json
+++ b/src/locales/it/common.json
@@ -9,7 +9,8 @@
     "loading": "Caricamento…",
     "reset": "Ripristina valori predefiniti",
     "update": "Aggiorna",
-    "updating": "Aggiornamento…"
+    "updating": "Aggiornamento…",
+    "backToHome": "Torna alla home"
   },
   "language": {
     "heading": "Lingua",
diff --git a/src/locales/it/drawer.json b/src/locales/it/drawer.json
index 5be224eb..f6b665ab 100644
--- a/src/locales/it/drawer.json
+++ b/src/locales/it/drawer.json
@@ -72,7 +72,13 @@
     "number": "Numero",
     "weight": "Peso",
     "update": "Aggiorna veicolo",
-    "add": "Aggiungi veicolo"
+    "add": "Aggiungi veicolo",
+    "engineRequired": "È richiesto un motore.",
+    "needsEngine": "Questo veicolo ha bisogno di un motore — modificalo per aggiungerne uno.",
+    "showOnProfile": "Mostra nel profilo",
+    "showOnProfileHint": "Mostra questo veicolo nel tuo profilo pubblico di pilota (solo nome, tipo e motore — mai peso o assetto).",
+    "publicBadge": "Pubblico",
+    "publicHint": "Mostrato nel tuo profilo pubblico di pilota."
   },
   "engine": {
     "label": "Motore",
diff --git a/src/locales/it/driver.json b/src/locales/it/driver.json
new file mode 100644
index 00000000..7b7ff1e0
--- /dev/null
+++ b/src/locales/it/driver.json
@@ -0,0 +1,14 @@
+{
+  "_machine": true,
+  "loading": "Caricamento profilo…",
+  "loadFailed": "Impossibile caricare questo profilo.",
+  "notFoundTitle": "Pilota non trovato",
+  "notFoundBody": "Non esiste nessun pilota di nome “{{name}}”.",
+  "vehiclesTitle": "Veicoli",
+  "vehiclesEmpty": "Questo pilota non ha condiviso alcun veicolo.",
+  "unknownType": "Tipo sconosciuto",
+  "snapshotsTitle": "Snapshot della classifica",
+  "snapshotsEmpty": "Questo pilota non ha caricato alcuno snapshot in classifica.",
+  "noWeight": "Nessun peso indicato",
+  "openSnapshot": "Apri questo giro nel visualizzatore"
+}
diff --git a/src/locales/it/landing.json b/src/locales/it/landing.json
index bf441804..4bf4ee50 100644
--- a/src/locales/it/landing.json
+++ b/src/locales/it/landing.json
@@ -27,6 +27,10 @@
     "build": {
       "title": "Costruisci il tuo logger",
       "description": "Hardware e firmware GPS open source: il DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "Classifiche",
+      "description": "Confronta i giri più veloci per pista, tracciato e classe motore"
     }
   },
   "links": {
@@ -43,14 +47,16 @@
         "text": "Logger DIY più economico aggiornato (giugno '26)"
       },
       {
-        "text": "Classifiche dei circuiti e profili utente pubblici (giugno '26)"
+        "text": "Classifiche dei circuiti e profili utente pubblici (giugno '26)",
+        "done": true
       },
       {
         "text": "Download da logger di terze parti (giugno '26)",
         "sub": [
           "MyChron: decodificato, richiede l'app nativa",
-          "Alfano: in sospeso"
-        ]
+          "Alfano: Bluetooth seriale, richiede l'app nativa"
+        ],
+        "done": true
       },
       {
         "text": "App nativa (luglio '26)"
@@ -220,7 +226,8 @@
       "comment": "Commento",
       "featureRequest": "Richiesta di funzionalità",
       "complaint": "Reclamo",
-      "bugReport": "Segnalazione di bug"
+      "bugReport": "Segnalazione di bug",
+      "newDatalogger": "Connessione di un nuovo data logger"
     },
     "emailLabel": "Email",
     "emailOptional": "(facoltativa, per una risposta)",
diff --git a/src/locales/it/leaderboard.json b/src/locales/it/leaderboard.json
new file mode 100644
index 00000000..1d9588ff
--- /dev/null
+++ b/src/locales/it/leaderboard.json
@@ -0,0 +1,32 @@
+{
+  "_machine": true,
+  "title": "Classifiche",
+  "subtitle": "I giri più veloci della community per pista, tracciato e classe motore.",
+  "empty": "Ancora nessun invio :(",
+  "loadFailed": "Impossibile caricare le classifiche.",
+  "loading": "Caricamento classifiche…",
+  "showTop": "Mostra i migliori",
+  "all": "Tutti",
+  "groupByWeight": "Raggruppa per peso",
+  "bubbles": {
+    "engines_one": "{{count}} motore",
+    "engines_other": "{{count}} motori",
+    "records_one": "{{count}} record",
+    "records_other": "{{count}} record",
+    "fastest": "Più veloce: {{time}}"
+  },
+  "unclassifiedEngine": "Non classificato",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "Vedi i giri",
+  "buildFailed": "Impossibile creare quella sessione.",
+  "readOnly": {
+    "banner": "Vista classifica in sola lettura",
+    "exit": "Esci",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  },
+  "loadTopSession_one": "Carica il giro più veloce come singola sessione",
+  "loadTopSession_other": "Carica i {{count}} giri più veloci come singola sessione",
+  "loadAllSession": "Carica tutti i giri come singola sessione",
+  "viewProfile": "Vedi profilo pilota"
+}
diff --git a/src/locales/it/logger.json b/src/locales/it/logger.json
index 19cec640..b4a53729 100644
--- a/src/locales/it/logger.json
+++ b/src/locales/it/logger.json
@@ -6,9 +6,9 @@
   "close": "Chiudi",
   "trademarks": "MyChron è un marchio di AiM Tech S.r.l. e Alfano è un marchio di Alfano S.A. LapWing è indipendente e non è affiliata né approvata da loro; tutti i nomi di prodotti, loghi e marchi sono di proprietà dei rispettivi titolari.",
   "tags": {
-    "fledgling": "Logger DIY · Bluetooth",
+    "fledgling": "Logger DIY · Bluetooth LE",
     "mychron": "Wi-Fi · richiede app nativa",
-    "alfano": "Bluetooth · prossimamente"
+    "alfano": "Bluetooth seriale · richiede app nativa"
   },
   "fledglingUnsupported": "Web Bluetooth non è supportato qui: usa Chrome, Edge o Opera su computer.",
   "mychron": {
@@ -51,7 +51,25 @@
     }
   },
   "alfano": {
-    "title": "Download Alfano",
-    "body": "I download Alfano saranno disponibili senza un'app nativa grazie alla connettività Bluetooth del logger. Stiamo facendo progressi: resta sintonizzato per gli aggiornamenti (stimato inizio luglio 2026)."
-  }
+    "title": "App nativa richiesta",
+    "body": "Alfano usa il Bluetooth seriale, a cui i browser web non possono accedere nel browser e richiederà anche l'app nativa. Un'app nativa dedicata al download da Alfano è in fase di sviluppo.",
+    "flow": {
+      "scanning": "Ricerca dei logger Alfano…",
+      "selectDevice": "Seleziona il tuo Alfano",
+      "deviceInstructions": "Tocca il tuo Alfano per connetterti:",
+      "noDevices": "Nessun logger Alfano trovato. Assicurati che il tuo sia acceso e che il Bluetooth sia attivo, poi riavvia la ricerca.",
+      "rescan": "Cerca di nuovo",
+      "connecting": "Connessione…",
+      "fetching": "Recupero delle sessioni…",
+      "selectFile": "Seleziona una sessione da scaricare",
+      "downloading": "Download in corso…",
+      "errorTitle": "Errore di connessione",
+      "instructions": "Tocca una sessione per scaricarla e caricarla:",
+      "empty": "Nessuna sessione su questo dispositivo",
+      "savedHint": " — il file è stato salvato e si trova in Sfoglia file.",
+      "retry": "Riprova",
+      "cancel": "Annulla"
+    }
+  },
+  "requestLogger": "Richiedi altri data logger"
 }
diff --git a/src/locales/it/plugins.json b/src/locales/it/plugins.json
index c2a9b1fe..2beaa920 100644
--- a/src/locales/it/plugins.json
+++ b/src/locales/it/plugins.json
@@ -6,7 +6,8 @@
     "account": "Account",
     "lapSnapshots": "Istantanee del giro",
     "cloudLogs": "Registri nel cloud",
-    "dataPrivacy": "Dati e privacy"
+    "dataPrivacy": "Dati e privacy",
+    "leaderboards": "Classifiche"
   },
   "account": {
     "signInBlurb": "Accedi per eseguire il backup e sincronizzare i tuoi file, il garage e le note tra i dispositivi. Tutto qui continua a funzionare offline su questo dispositivo — Cloud Sync è facoltativo.",
@@ -25,7 +26,13 @@
     "nameEmpty": "Il nome visualizzato non può essere vuoto.",
     "nameProfanity": "Scegli un nome visualizzato più appropriato.",
     "nameUpdateFailed": "Impossibile aggiornare il nome visualizzato.",
-    "loadUsageFailed": "Impossibile caricare l'utilizzo dello spazio"
+    "loadUsageFailed": "Impossibile caricare l'utilizzo dello spazio",
+    "changeAvatar": "Cambia foto profilo",
+    "avatarUpdated": "Foto profilo aggiornata.",
+    "avatarFailed": "Impossibile aggiornare la foto profilo.",
+    "copyProfileLink": "Copia link del profilo",
+    "linkCopied": "Link del profilo copiato.",
+    "linkCopyFailed": "Impossibile copiare il link del profilo."
   },
   "plan": {
     "title": "Piano",
@@ -172,5 +179,29 @@
     "downloadingFiles_one": "Download di {{count}} file dal cloud…",
     "downloadingFiles_other": "Download di {{count}} file dal cloud…",
     "zipping": "Compressione…"
+  },
+  "leaderboard": {
+    "signInHint": "Accedi per inviare le tue istantanee alle classifiche pubbliche.",
+    "noSnapshots": "Cattura un giro per inviarlo alle classifiche.",
+    "intro_one": "Hai {{count}} istantanea da inviare alle classifiche.",
+    "intro_other": "Hai {{count}} istantanee da inviare alle classifiche.",
+    "submitButton": "Invia alle classifiche",
+    "dialogTitle": "Invia alle classifiche",
+    "dialogDescription": "I tuoi dati GPS, il motore e il peso indicato sono pubblici così altri possono confrontare e verificare i giri. I dati del sensore motore restano privati a meno che tu non scelga di condividerli.",
+    "listedWeight": "Peso indicato",
+    "listedWeightHint": "Mostrato pubblicamente e usato per raggruppare i record. Per impostazione predefinita è il peso del tuo veicolo: cambialo se preferisci indicare un peso di categoria.",
+    "weightRequired": "Inserisci un peso indicato per inviare.",
+    "shareEngineData": "Condividi i dati del sensore motore (RPM, temperature)",
+    "publicNotice": "Pubblico: GPS, nome del motore, tempo sul giro, peso indicato.",
+    "submitOne": "Invia",
+    "submitting": "Invio…",
+    "submitted": "Inviato",
+    "submitSuccess": "Inviato alle classifiche.",
+    "submitFailed": "Invio non riuscito — riprova.",
+    "alreadySubmitted": "Già nelle classifiche.",
+    "loadFailed": "Impossibile caricare i tuoi invii.",
+    "close": "Chiudi",
+    "customTrackNotice": "Questo circuito non è nell'elenco integrato: il suo tracciato e i settori vengono inviati con il tuo snapshot e il circuito viene aggiunto al database della community per la revisione.",
+    "trackAdded": "Circuito inviato al database della community per la revisione."
   }
 }
diff --git a/src/locales/ja/admin.json b/src/locales/ja/admin.json
index 43941c17..688c8331 100644
--- a/src/locales/ja/admin.json
+++ b/src/locales/ja/admin.json
@@ -11,7 +11,8 @@
     "courses": "コース",
     "tools": "ツール",
     "banned": "禁止 IP",
-    "users": "ユーザー"
+    "users": "ユーザー",
+    "leaderboards": "リーダーボード"
   },
   "common": {
     "error": "エラー",
@@ -51,7 +52,8 @@
       "comment": "コメント",
       "featureRequest": "機能リクエスト",
       "complaint": "苦情",
-      "bugReport": "バグ報告"
+      "bugReport": "バグ報告",
+      "newDatalogger": "新しいデータロガーの接続"
     },
     "emailLine": "メール: {{email}}",
     "ipLine": "IP: {{ip}}",
@@ -200,5 +202,43 @@
     "granted_other": "{{count}}か月のプレミアムを付与しました",
     "grantFailed": "操作に失敗しました",
     "grantRemoved": "プレミアム付与を取り消しました"
+  },
+  "leaderboards": {
+    "title": "リーダーボードの記録",
+    "loading": "記録を読み込み中…",
+    "loadFailed": "記録の読み込みに失敗しました。",
+    "empty": "リーダーボードへの送信はまだありません。",
+    "filterAll": "すべて",
+    "filterApproved": "承認済み",
+    "filterDenied": "却下",
+    "colDriver": "ドライバー",
+    "colTrack": "コース / レイアウト",
+    "colEngine": "エンジン",
+    "colClass": "クラス",
+    "colWeight": "重量",
+    "colTime": "ラップタイム",
+    "colStatus": "ステータス",
+    "approve": "承認",
+    "deny": "却下",
+    "unclassified": "— 未分類 —",
+    "notes": "管理者メモ",
+    "notesPlaceholder": "内部メモ（任意）",
+    "saveNotes": "保存",
+    "updated": "記録を更新しました。",
+    "updateFailed": "記録を更新できませんでした。",
+    "classesTitle": "エンジンクラス",
+    "classesHint": "自由入力のエンジン名を1つのクラスにまとめるキーワードグループです。送信は、エンジン名にキーワードが含まれる最初のクラスに自動的に一致します。",
+    "className": "クラス名",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "キーワード（カンマ区切り）",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "クラスを追加",
+    "saveClass": "保存",
+    "deleteClass": "削除",
+    "reclassify": "記録を再分類",
+    "reclassified_one": "{{count}} 件の記録を再分類しました。",
+    "reclassified_other": "{{count}} 件の記録を再分類しました。",
+    "classSaved": "エンジンクラスを保存しました。",
+    "classFailed": "エンジンクラスを保存できませんでした。"
   }
 }
diff --git a/src/locales/ja/common.json b/src/locales/ja/common.json
index ea3fea90..21f01d73 100644
--- a/src/locales/ja/common.json
+++ b/src/locales/ja/common.json
@@ -9,7 +9,8 @@
     "loading": "読み込み中…",
     "reset": "デフォルトに戻す",
     "update": "更新",
-    "updating": "更新中…"
+    "updating": "更新中…",
+    "backToHome": "ホームに戻る"
   },
   "language": {
     "heading": "言語",
diff --git a/src/locales/ja/drawer.json b/src/locales/ja/drawer.json
index 8ac226c5..a2fc100b 100644
--- a/src/locales/ja/drawer.json
+++ b/src/locales/ja/drawer.json
@@ -72,7 +72,13 @@
     "number": "番号",
     "weight": "重量",
     "update": "車両を更新",
-    "add": "車両を追加"
+    "add": "車両を追加",
+    "engineRequired": "エンジンは必須です。",
+    "needsEngine": "この車両にはエンジンが必要です。編集して追加してください。",
+    "showOnProfile": "プロフィールに表示",
+    "showOnProfileHint": "この車両を公開ドライバープロフィールに表示します（名前・タイプ・エンジンのみ。重量やセットアップは含みません）。",
+    "publicBadge": "公開",
+    "publicHint": "公開ドライバープロフィールに表示されます。"
   },
   "engine": {
     "label": "エンジン",
diff --git a/src/locales/ja/driver.json b/src/locales/ja/driver.json
new file mode 100644
index 00000000..970f8b88
--- /dev/null
+++ b/src/locales/ja/driver.json
@@ -0,0 +1,14 @@
+{
+  "_machine": true,
+  "loading": "プロフィールを読み込み中…",
+  "loadFailed": "このプロフィールを読み込めませんでした。",
+  "notFoundTitle": "ドライバーが見つかりません",
+  "notFoundBody": "「{{name}}」というドライバーは存在しません。",
+  "vehiclesTitle": "車両",
+  "vehiclesEmpty": "このドライバーは車両を共有していません。",
+  "unknownType": "不明なタイプ",
+  "snapshotsTitle": "リーダーボードのスナップショット",
+  "snapshotsEmpty": "このドライバーはリーダーボードにスナップショットをアップロードしていません。",
+  "noWeight": "重量の記載なし",
+  "openSnapshot": "このラップをビューアで開く"
+}
diff --git a/src/locales/ja/landing.json b/src/locales/ja/landing.json
index 71b61d93..ca4052df 100644
--- a/src/locales/ja/landing.json
+++ b/src/locales/ja/landing.json
@@ -27,6 +27,10 @@
     "build": {
       "title": "自分だけのロガーを作る",
       "description": "オープンソースの GPS ハードウェアとファームウェア — DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "リーダーボード",
+      "description": "コース、レイアウト、エンジンクラスごとに最速ラップを比較"
     }
   },
   "links": {
@@ -43,14 +47,16 @@
         "text": "より安価なDIYロガーのアップデート（2026年6月）"
       },
       {
-        "text": "トラックのリーダーボードと公開ユーザープロフィール（2026年6月）"
+        "text": "トラックのリーダーボードと公開ユーザープロフィール（2026年6月）",
+        "done": true
       },
       {
         "text": "サードパーティ製ロガーからのダウンロード（2026年6月）",
         "sub": [
           "MyChron：解読済み、ネイティブアプリが必要",
-          "Alfano：保留中"
-        ]
+          "Alfano：Bluetooth シリアル、ネイティブアプリが必要"
+        ],
+        "done": true
       },
       {
         "text": "ネイティブアプリ（2026年7月）"
@@ -220,7 +226,8 @@
       "comment": "コメント",
       "featureRequest": "機能リクエスト",
       "complaint": "苦情",
-      "bugReport": "バグ報告"
+      "bugReport": "バグ報告",
+      "newDatalogger": "新しいデータロガーの接続"
     },
     "emailLabel": "メールアドレス",
     "emailOptional": "（任意、返信用）",
diff --git a/src/locales/ja/leaderboard.json b/src/locales/ja/leaderboard.json
new file mode 100644
index 00000000..9e5364c7
--- /dev/null
+++ b/src/locales/ja/leaderboard.json
@@ -0,0 +1,32 @@
+{
+  "_machine": true,
+  "title": "リーダーボード",
+  "subtitle": "コース、レイアウト、エンジンクラスごとのコミュニティ最速ラップ。",
+  "empty": "まだ送信がありません :(",
+  "loadFailed": "リーダーボードを読み込めませんでした。",
+  "loading": "リーダーボードを読み込み中…",
+  "showTop": "上位を表示",
+  "all": "すべて",
+  "groupByWeight": "重量でグループ化",
+  "bubbles": {
+    "engines_one": "{{count}} 基のエンジン",
+    "engines_other": "{{count}} 基のエンジン",
+    "records_one": "{{count}} 件の記録",
+    "records_other": "{{count}} 件の記録",
+    "fastest": "最速: {{time}}"
+  },
+  "unclassifiedEngine": "未分類",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "ラップを見る",
+  "buildFailed": "そのセッションを作成できませんでした。",
+  "readOnly": {
+    "banner": "読み取り専用のリーダーボード表示",
+    "exit": "終了",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  },
+  "loadTopSession_one": "最速ラップを1つのセッションとして読み込む",
+  "loadTopSession_other": "上位 {{count}} ラップを1つのセッションとして読み込む",
+  "loadAllSession": "すべてのラップを1つのセッションとして読み込む",
+  "viewProfile": "ドライバープロフィールを見る"
+}
diff --git a/src/locales/ja/logger.json b/src/locales/ja/logger.json
index 07a383d7..8ed43513 100644
--- a/src/locales/ja/logger.json
+++ b/src/locales/ja/logger.json
@@ -6,9 +6,9 @@
   "close": "閉じる",
   "trademarks": "MyChron は AiM Tech S.r.l. の、Alfano は Alfano S.A. の商標です。LapWing は独立しており、これらの企業と提携も推奨もされていません。すべての製品名、ロゴ、ブランドはそれぞれの所有者に帰属します。",
   "tags": {
-    "fledgling": "DIYロガー · Bluetooth",
+    "fledgling": "DIYロガー · Bluetooth LE",
     "mychron": "Wi-Fi · ネイティブアプリが必要",
-    "alfano": "Bluetooth · 近日公開"
+    "alfano": "Bluetooth シリアル · ネイティブアプリが必要"
   },
   "fledglingUnsupported": "Web Bluetooth はこの環境では非対応です。デスクトップの Chrome、Edge、または Opera をご利用ください。",
   "mychron": {
@@ -51,7 +51,25 @@
     }
   },
   "alfano": {
-    "title": "Alfano のダウンロード",
-    "body": "Alfano のダウンロードは、ロガーの Bluetooth 接続によりネイティブアプリなしで利用できるようになります。開発は進行中です。最新情報にご注目ください（2026年7月初旬予定）。"
-  }
+    "title": "ネイティブアプリが必要です",
+    "body": "Alfano は Bluetooth シリアルを使用しており、Web ブラウザーからは直接アクセスできず、ネイティブアプリも必要になります。Alfano からダウンロードするための専用ネイティブアプリを開発中です。",
+    "flow": {
+      "scanning": "Alfano ロガーを検索中…",
+      "selectDevice": "Alfano を選択",
+      "deviceInstructions": "接続する Alfano をタップしてください：",
+      "noDevices": "Alfano ロガーが見つかりません。電源が入っていて Bluetooth が有効になっていることを確認し、再検索してください。",
+      "rescan": "再検索",
+      "connecting": "接続中…",
+      "fetching": "セッションを取得中…",
+      "selectFile": "ダウンロードするセッションを選択",
+      "downloading": "ダウンロード中…",
+      "errorTitle": "接続エラー",
+      "instructions": "セッションをタップしてダウンロードして読み込みます：",
+      "empty": "このデバイスにセッションはありません",
+      "savedHint": " — ファイルは保存され、「ファイルを参照」で見つけられます。",
+      "retry": "再試行",
+      "cancel": "キャンセル"
+    }
+  },
+  "requestLogger": "他のデータロガーをリクエスト"
 }
diff --git a/src/locales/ja/plugins.json b/src/locales/ja/plugins.json
index 4c47342e..c1d31fa9 100644
--- a/src/locales/ja/plugins.json
+++ b/src/locales/ja/plugins.json
@@ -6,7 +6,8 @@
     "account": "アカウント",
     "lapSnapshots": "ラップスナップショット",
     "cloudLogs": "クラウドログ",
-    "dataPrivacy": "データとプライバシー"
+    "dataPrivacy": "データとプライバシー",
+    "leaderboards": "リーダーボード"
   },
   "account": {
     "signInBlurb": "サインインすると、ファイル・ガレージ・メモをデバイス間でバックアップ・同期できます。ここのすべては、このデバイス上でオフラインでも動作します。Cloud Sync は任意です。",
@@ -25,7 +26,13 @@
     "nameEmpty": "表示名を空にすることはできません。",
     "nameProfanity": "もっと適切な表示名を選んでください。",
     "nameUpdateFailed": "表示名を更新できませんでした。",
-    "loadUsageFailed": "ストレージ使用量を読み込めませんでした"
+    "loadUsageFailed": "ストレージ使用量を読み込めませんでした",
+    "changeAvatar": "プロフィール写真を変更",
+    "avatarUpdated": "プロフィール写真を更新しました。",
+    "avatarFailed": "プロフィール写真を更新できませんでした。",
+    "copyProfileLink": "プロフィールリンクをコピー",
+    "linkCopied": "プロフィールリンクをコピーしました。",
+    "linkCopyFailed": "プロフィールリンクをコピーできませんでした。"
   },
   "plan": {
     "title": "プラン",
@@ -172,5 +179,29 @@
     "downloadingFiles_one": "{{count}}件のクラウドファイルをダウンロード中…",
     "downloadingFiles_other": "{{count}}件のクラウドファイルをダウンロード中…",
     "zipping": "圧縮中…"
+  },
+  "leaderboard": {
+    "signInHint": "スナップショットを公開リーダーボードに送信するにはサインインしてください。",
+    "noSnapshots": "ラップをスナップショットとして保存すると、リーダーボードに送信できます。",
+    "intro_one": "リーダーボードに送信できるスナップショットが {{count}} 件あります。",
+    "intro_other": "リーダーボードに送信できるスナップショットが {{count}} 件あります。",
+    "submitButton": "リーダーボードに送信",
+    "dialogTitle": "リーダーボードに送信",
+    "dialogDescription": "GPSデータ、エンジン、申告重量は公開され、他のユーザーがラップを比較・確認できます。エンジンセンサーのデータは、共有を選択しない限り非公開のままです。",
+    "listedWeight": "申告重量",
+    "listedWeightHint": "公開され、記録のグループ分けに使用されます。既定では車両の重量です。クラス重量を表示したい場合は変更してください。",
+    "weightRequired": "送信するには申告重量を入力してください。",
+    "shareEngineData": "エンジンセンサーのデータを共有する（回転数、温度）",
+    "publicNotice": "公開: GPS、エンジン名、ラップタイム、申告重量。",
+    "submitOne": "送信",
+    "submitting": "送信中…",
+    "submitted": "送信済み",
+    "submitSuccess": "リーダーボードに送信しました。",
+    "submitFailed": "送信できませんでした。もう一度お試しください。",
+    "alreadySubmitted": "すでにリーダーボードに登録されています。",
+    "loadFailed": "あなたの送信を読み込めませんでした。",
+    "close": "閉じる",
+    "customTrackNotice": "このコースは組み込みリストにありません。レイアウトとセクターはスナップショットと共に送信され、コースは承認のためコミュニティデータベースに追加されます。",
+    "trackAdded": "コースを承認のためコミュニティデータベースに送信しました。"
   }
 }
diff --git a/src/locales/pt-BR/admin.json b/src/locales/pt-BR/admin.json
index 747a0bd4..bd9f8835 100644
--- a/src/locales/pt-BR/admin.json
+++ b/src/locales/pt-BR/admin.json
@@ -11,7 +11,8 @@
     "courses": "Circuitos",
     "tools": "Ferramentas",
     "banned": "IPs banidos",
-    "users": "Usuários"
+    "users": "Usuários",
+    "leaderboards": "Rankings"
   },
   "common": {
     "error": "Erro",
@@ -51,7 +52,8 @@
       "comment": "Comentário",
       "featureRequest": "Solicitação de recurso",
       "complaint": "Reclamação",
-      "bugReport": "Relatório de bug"
+      "bugReport": "Relatório de bug",
+      "newDatalogger": "Conexão de novo datalogger"
     },
     "emailLine": "E-mail: {{email}}",
     "ipLine": "IP: {{ip}}",
@@ -200,5 +202,43 @@
     "granted_other": "{{count}} meses de premium concedidos",
     "grantFailed": "A ação falhou",
     "grantRemoved": "Concessão premium removida"
+  },
+  "leaderboards": {
+    "title": "Registros de ranking",
+    "loading": "Carregando registros…",
+    "loadFailed": "Falha ao carregar os registros.",
+    "empty": "Nenhum envio de ranking ainda.",
+    "filterAll": "Todos",
+    "filterApproved": "Aprovados",
+    "filterDenied": "Recusados",
+    "colDriver": "Piloto",
+    "colTrack": "Pista / Traçado",
+    "colEngine": "Motor",
+    "colClass": "Classe",
+    "colWeight": "Peso",
+    "colTime": "Tempo de volta",
+    "colStatus": "Status",
+    "approve": "Aprovar",
+    "deny": "Recusar",
+    "unclassified": "— Não classificado —",
+    "notes": "Notas do admin",
+    "notesPlaceholder": "Notas internas (opcional)",
+    "saveNotes": "Salvar",
+    "updated": "Registro atualizado.",
+    "updateFailed": "Não foi possível atualizar o registro.",
+    "classesTitle": "Classes de motor",
+    "classesHint": "Grupos de palavras-chave que unificam nomes de motor em texto livre em uma única classe. Um envio corresponde automaticamente à primeira classe cuja palavra-chave aparece no nome do motor.",
+    "className": "Nome da classe",
+    "classNamePlaceholder": "Tillotson 225",
+    "keywords": "Palavras-chave (separadas por vírgulas)",
+    "keywordsPlaceholder": "tilly, 225, 225rs",
+    "addClass": "Adicionar classe",
+    "saveClass": "Salvar",
+    "deleteClass": "Excluir",
+    "reclassify": "Reclassificar registros",
+    "reclassified_one": "{{count}} registro reclassificado.",
+    "reclassified_other": "{{count}} registros reclassificados.",
+    "classSaved": "Classe de motor salva.",
+    "classFailed": "Não foi possível salvar a classe de motor."
   }
 }
diff --git a/src/locales/pt-BR/common.json b/src/locales/pt-BR/common.json
index 5aaa6feb..06924194 100644
--- a/src/locales/pt-BR/common.json
+++ b/src/locales/pt-BR/common.json
@@ -9,7 +9,8 @@
     "loading": "Carregando…",
     "reset": "Restaurar padrões",
     "update": "Atualizar",
-    "updating": "Atualizando…"
+    "updating": "Atualizando…",
+    "backToHome": "Voltar ao início"
   },
   "language": {
     "heading": "Idioma",
diff --git a/src/locales/pt-BR/drawer.json b/src/locales/pt-BR/drawer.json
index 2e98e310..584437af 100644
--- a/src/locales/pt-BR/drawer.json
+++ b/src/locales/pt-BR/drawer.json
@@ -72,7 +72,13 @@
     "number": "Número",
     "weight": "Peso",
     "update": "Atualizar veículo",
-    "add": "Adicionar veículo"
+    "add": "Adicionar veículo",
+    "engineRequired": "Um motor é obrigatório.",
+    "needsEngine": "Este veículo precisa de um motor — edite para adicionar um.",
+    "showOnProfile": "Mostrar no perfil",
+    "showOnProfileHint": "Lista este veículo no seu perfil público de piloto (apenas nome, tipo e motor — nunca peso ou setup).",
+    "publicBadge": "Público",
+    "publicHint": "Exibido no seu perfil público de piloto."
   },
   "engine": {
     "label": "Motor",
diff --git a/src/locales/pt-BR/driver.json b/src/locales/pt-BR/driver.json
new file mode 100644
index 00000000..b1795e18
--- /dev/null
+++ b/src/locales/pt-BR/driver.json
@@ -0,0 +1,14 @@
+{
+  "_machine": true,
+  "loading": "Carregando perfil…",
+  "loadFailed": "Não foi possível carregar este perfil.",
+  "notFoundTitle": "Piloto não encontrado",
+  "notFoundBody": "Não existe nenhum piloto chamado “{{name}}”.",
+  "vehiclesTitle": "Veículos",
+  "vehiclesEmpty": "Este piloto não compartilhou nenhum veículo.",
+  "unknownType": "Tipo desconhecido",
+  "snapshotsTitle": "Snapshots do ranking",
+  "snapshotsEmpty": "Este piloto não enviou nenhum snapshot ao ranking.",
+  "noWeight": "Sem peso informado",
+  "openSnapshot": "Abrir esta volta no visualizador"
+}
diff --git a/src/locales/pt-BR/landing.json b/src/locales/pt-BR/landing.json
index 9f08ca2f..07a75b35 100644
--- a/src/locales/pt-BR/landing.json
+++ b/src/locales/pt-BR/landing.json
@@ -27,6 +27,10 @@
     "build": {
       "title": "Monte seu próprio registrador",
       "description": "Hardware e firmware GPS de código aberto: o DovesDataLogger"
+    },
+    "leaderboards": {
+      "title": "Rankings",
+      "description": "Compare as voltas mais rápidas por pista, traçado e classe de motor"
     }
   },
   "links": {
@@ -43,14 +47,16 @@
         "text": "Logger DIY mais barato atualizado (junho '26)"
       },
       {
-        "text": "Rankings de pista e perfis públicos de usuário (junho '26)"
+        "text": "Rankings de pista e perfis públicos de usuário (junho '26)",
+        "done": true
       },
       {
         "text": "Downloads de loggers de terceiros (junho '26)",
         "sub": [
           "MyChron: decodificado, requer aplicativo nativo",
-          "Alfano: pendente"
-        ]
+          "Alfano: Bluetooth serial, requer aplicativo nativo"
+        ],
+        "done": true
       },
       {
         "text": "Aplicativo nativo (julho '26)"
@@ -220,7 +226,8 @@
       "comment": "Comentário",
       "featureRequest": "Solicitação de recurso",
       "complaint": "Reclamação",
-      "bugReport": "Relatório de bug"
+      "bugReport": "Relatório de bug",
+      "newDatalogger": "Conexão de novo datalogger"
     },
     "emailLabel": "E-mail",
     "emailOptional": "(opcional, para resposta)",
diff --git a/src/locales/pt-BR/leaderboard.json b/src/locales/pt-BR/leaderboard.json
new file mode 100644
index 00000000..a78ff944
--- /dev/null
+++ b/src/locales/pt-BR/leaderboard.json
@@ -0,0 +1,32 @@
+{
+  "_machine": true,
+  "title": "Rankings",
+  "subtitle": "As voltas mais rápidas da comunidade por pista, traçado e classe de motor.",
+  "empty": "Nenhum envio ainda :(",
+  "loadFailed": "Não foi possível carregar os rankings.",
+  "loading": "Carregando rankings…",
+  "showTop": "Mostrar os melhores",
+  "all": "Todos",
+  "groupByWeight": "Agrupar por peso",
+  "bubbles": {
+    "engines_one": "{{count}} motor",
+    "engines_other": "{{count}} motores",
+    "records_one": "{{count}} registro",
+    "records_other": "{{count}} registros",
+    "fastest": "Mais rápida: {{time}}"
+  },
+  "unclassifiedEngine": "Não classificado",
+  "weightLabel": "{{weight}} {{unit}}",
+  "openGroup": "Ver voltas",
+  "buildFailed": "Não foi possível criar essa sessão.",
+  "readOnly": {
+    "banner": "Visualização de ranking somente leitura",
+    "exit": "Sair",
+    "descriptor": "{{course}} · {{engine}}",
+    "descriptorWeight": "{{course}} · {{engine}} · {{weight}}"
+  },
+  "loadTopSession_one": "Carregar a volta mais rápida como uma única sessão",
+  "loadTopSession_other": "Carregar as {{count}} voltas mais rápidas como uma única sessão",
+  "loadAllSession": "Carregar todas as voltas como uma única sessão",
+  "viewProfile": "Ver perfil do piloto"
+}
diff --git a/src/locales/pt-BR/logger.json b/src/locales/pt-BR/logger.json
index dfa56b0b..8b484d9e 100644
--- a/src/locales/pt-BR/logger.json
+++ b/src/locales/pt-BR/logger.json
@@ -6,9 +6,9 @@
   "close": "Fechar",
   "trademarks": "MyChron é uma marca registrada da AiM Tech S.r.l. e Alfano é uma marca registrada da Alfano S.A. O LapWing é independente e não é afiliado nem endossado por elas; todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos donos.",
   "tags": {
-    "fledgling": "Registrador DIY · Bluetooth",
+    "fledgling": "Registrador DIY · Bluetooth LE",
     "mychron": "Wi-Fi · app nativo necessário",
-    "alfano": "Bluetooth · em breve"
+    "alfano": "Bluetooth serial · app nativo necessário"
   },
   "fledglingUnsupported": "Web Bluetooth não é compatível aqui — use Chrome, Edge ou Opera no computador.",
   "mychron": {
@@ -51,7 +51,25 @@
     }
   },
   "alfano": {
-    "title": "Downloads do Alfano",
-    "body": "Os downloads do Alfano estarão disponíveis sem um app nativo graças à conectividade Bluetooth do registrador. Estamos progredindo — fique de olho nas novidades (estimado para início de julho de 2026)."
-  }
+    "title": "App nativo necessário",
+    "body": "O Alfano usa Bluetooth serial, que os navegadores web não conseguem acessar no navegador — também exigirá o app nativo. Um app nativo dedicado para baixar do Alfano está em desenvolvimento.",
+    "flow": {
+      "scanning": "Procurando registradores Alfano…",
+      "selectDevice": "Selecione seu Alfano",
+      "deviceInstructions": "Toque no seu Alfano para conectar:",
+      "noDevices": "Nenhum registrador Alfano encontrado. Verifique se o seu está ligado e o Bluetooth ativado e procure novamente.",
+      "rescan": "Procurar novamente",
+      "connecting": "Conectando…",
+      "fetching": "Buscando sessões…",
+      "selectFile": "Selecione uma sessão para baixar",
+      "downloading": "Baixando…",
+      "errorTitle": "Erro de conexão",
+      "instructions": "Toque em uma sessão para baixá-la e carregá-la:",
+      "empty": "Nenhuma sessão neste dispositivo",
+      "savedHint": " — o arquivo foi salvo e pode ser encontrado em Procurar arquivos.",
+      "retry": "Tentar novamente",
+      "cancel": "Cancelar"
+    }
+  },
+  "requestLogger": "Solicitar mais dataloggers"
 }
diff --git a/src/locales/pt-BR/plugins.json b/src/locales/pt-BR/plugins.json
index 0aa1bf2c..a79d8986 100644
--- a/src/locales/pt-BR/plugins.json
+++ b/src/locales/pt-BR/plugins.json
@@ -6,7 +6,8 @@
     "account": "Conta",
     "lapSnapshots": "Instantâneos de volta",
     "cloudLogs": "Registros na nuvem",
-    "dataPrivacy": "Dados e privacidade"
+    "dataPrivacy": "Dados e privacidade",
+    "leaderboards": "Rankings"
   },
   "account": {
     "signInBlurb": "Entre para fazer backup e sincronizar seus arquivos, garagem e notas entre dispositivos. Tudo aqui continua funcionando offline neste dispositivo — o Cloud Sync é opcional.",
@@ -25,7 +26,13 @@
     "nameEmpty": "O nome de exibição não pode ficar vazio.",
     "nameProfanity": "Escolha um nome de exibição mais adequado.",
     "nameUpdateFailed": "Não foi possível atualizar o nome de exibição.",
-    "loadUsageFailed": "Não foi possível carregar o uso de armazenamento"
+    "loadUsageFailed": "Não foi possível carregar o uso de armazenamento",
+    "changeAvatar": "Alterar foto de perfil",
+    "avatarUpdated": "Foto de perfil atualizada.",
+    "avatarFailed": "Não foi possível atualizar a foto de perfil.",
+    "copyProfileLink": "Copiar link do perfil",
+    "linkCopied": "Link do perfil copiado.",
+    "linkCopyFailed": "Não foi possível copiar o link do perfil."
   },
   "plan": {
     "title": "Plano",
@@ -172,5 +179,29 @@
     "downloadingFiles_one": "Baixando {{count}} arquivo da nuvem…",
     "downloadingFiles_other": "Baixando {{count}} arquivos da nuvem…",
     "zipping": "Compactando…"
+  },
+  "leaderboard": {
+    "signInHint": "Faça login para enviar seus instantâneos aos rankings públicos.",
+    "noSnapshots": "Capture uma volta para enviá-la aos rankings.",
+    "intro_one": "Você tem {{count}} instantâneo para enviar aos rankings.",
+    "intro_other": "Você tem {{count}} instantâneos para enviar aos rankings.",
+    "submitButton": "Enviar aos rankings",
+    "dialogTitle": "Enviar aos rankings",
+    "dialogDescription": "Seus dados de GPS, o motor e o peso informado são públicos para que outros possam comparar e verificar as voltas. Os dados do sensor do motor permanecem privados a menos que você opte por compartilhá-los.",
+    "listedWeight": "Peso informado",
+    "listedWeightHint": "Exibido publicamente e usado para agrupar os registros. O padrão é o peso do seu veículo — altere se preferir informar um peso de categoria.",
+    "weightRequired": "Informe um peso para enviar.",
+    "shareEngineData": "Compartilhar dados do sensor do motor (RPM, temperaturas)",
+    "publicNotice": "Público: GPS, nome do motor, tempo de volta, peso informado.",
+    "submitOne": "Enviar",
+    "submitting": "Enviando…",
+    "submitted": "Enviado",
+    "submitSuccess": "Enviado aos rankings.",
+    "submitFailed": "Não foi possível enviar — tente novamente.",
+    "alreadySubmitted": "Já está nos rankings.",
+    "loadFailed": "Não foi possível carregar seus envios.",
+    "close": "Fechar",
+    "customTrackNotice": "Esta pista não está na lista integrada — seu traçado e setores são enviados com o seu snapshot, e a pista é adicionada ao banco de dados da comunidade para revisão.",
+    "trackAdded": "Pista enviada ao banco de dados da comunidade para revisão."
   }
 }
diff --git a/src/pages/Admin.tsx b/src/pages/Admin.tsx
index a8f80996..2b276a1b 100644
--- a/src/pages/Admin.tsx
+++ b/src/pages/Admin.tsx
@@ -13,6 +13,7 @@ import { ToolsTab } from '@/components/admin/ToolsTab';
 import { BannedIpsTab } from '@/components/admin/BannedIpsTab';
 import { MessagesTab } from '@/components/admin/MessagesTab';
 import { UsersTab } from '@/components/admin/UsersTab';
+import { LeaderboardsTab } from '@/components/admin/LeaderboardsTab';
 
 export default function Admin() {
   const { t } = useTranslation('admin');
@@ -58,7 +59,7 @@ export default function Admin() {
 
       <main className="flex-1 p-6 max-w-6xl mx-auto w-full">
         <Tabs defaultValue="messages" className="w-full">
-          <TabsList className="grid w-full grid-cols-7">
+          <TabsList className="grid w-full grid-cols-8">
             <TabsTrigger value="messages" className="relative">
               {t('tabs.messages')}
               {unreadCount > 0 && (
@@ -71,6 +72,7 @@ export default function Admin() {
             <TabsTrigger value="users">{t('tabs.users')}</TabsTrigger>
             <TabsTrigger value="tracks">{t('tabs.tracks')}</TabsTrigger>
             <TabsTrigger value="courses">{t('tabs.courses')}</TabsTrigger>
+            <TabsTrigger value="leaderboards">{t('tabs.leaderboards')}</TabsTrigger>
             <TabsTrigger value="tools">{t('tabs.tools')}</TabsTrigger>
             <TabsTrigger value="banned">{t('tabs.banned')}</TabsTrigger>
           </TabsList>
@@ -79,6 +81,7 @@ export default function Admin() {
           <TabsContent value="users"><UsersTab /></TabsContent>
           <TabsContent value="tracks"><TracksTab /></TabsContent>
           <TabsContent value="courses"><CoursesTab /></TabsContent>
+          <TabsContent value="leaderboards"><LeaderboardsTab /></TabsContent>
           <TabsContent value="tools"><ToolsTab /></TabsContent>
           <TabsContent value="banned"><BannedIpsTab /></TabsContent>
         </Tabs>
diff --git a/src/pages/DriverProfile.tsx b/src/pages/DriverProfile.tsx
new file mode 100644
index 00000000..94413fd1
--- /dev/null
+++ b/src/pages/DriverProfile.tsx
@@ -0,0 +1,265 @@
+import { useEffect, useState } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { Car, Cpu, Trophy, UserX, Weight, Loader2 } from "lucide-react";
+import { toast } from "sonner";
+import { SiteHeader } from "@/components/SiteHeader";
+import { SettingsModal } from "@/components/SettingsModal";
+import { BackToHome } from "@/components/BackToHome";
+import { ProfileAvatar } from "@/components/ProfileAvatar";
+import { useSettings } from "@/hooks/useSettings";
+import { formatLapTime } from "@/lib/lapCalculation";
+import { groupEntriesByCourseWeight, type DriverCourseGroup } from "@/lib/driverProfileGroups";
+import { buildLeaderboardSession } from "@/lib/leaderboardSession";
+import { setPendingLeaderboardSession } from "@/lib/leaderboardHandoff";
+import type { PublicProfile, PublicVehicle } from "@/plugins/cloud-sync/publicProfile";
+
+/** One flattened, clickable uploaded snapshot card. */
+interface SnapshotCard {
+  id: string;
+  courseName: string;
+  trackName: string;
+  engineLabel: string;
+  weightLabel: string | null;
+  lapTimeMs: number;
+}
+
+/** Flatten the course→weight→lap grouping into one card per uploaded snapshot. */
+function flattenSnapshots(courses: DriverCourseGroup[]): SnapshotCard[] {
+  return courses.flatMap((c) =>
+    c.weightGroups.flatMap((wg) =>
+      wg.laps.map((lap) => ({
+        id: lap.id,
+        courseName: c.courseName,
+        trackName: c.trackName,
+        engineLabel: lap.engineLabel,
+        weightLabel: wg.weightLabel,
+        lapTimeMs: lap.lapTimeMs,
+      })),
+    ),
+  );
+}
+
+const enableCloud = import.meta.env.VITE_ENABLE_CLOUD === "true";
+
+interface LoadedData {
+  profile: PublicProfile;
+  vehicles: PublicVehicle[];
+  courses: DriverCourseGroup[];
+}
+
+type LoadState =
+  | { status: "loading" }
+  | { status: "notfound" }
+  | { status: "error"; message: string }
+  | { status: "ready"; data: LoadedData };
+
+export default function DriverProfile() {
+  const navigate = useNavigate();
+  const { username } = useParams<{ username: string }>();
+  const name = decodeURIComponent(username ?? "");
+  const { t } = useTranslation(["driver", "common"]);
+  const { settings, setSettings, toggleFieldDefault } = useSettings();
+  const [state, setState] = useState<LoadState>({ status: "loading" });
+
+  useEffect(() => {
+    let cancelled = false;
+    setState({ status: "loading" });
+    (async () => {
+      try {
+        const { fetchPublicProfileByName, fetchPublicVehicles } = await import(
+          "@/plugins/cloud-sync/publicProfile"
+        );
+        const profile = await fetchPublicProfileByName(name);
+        if (cancelled) return;
+        if (!profile) {
+          setState({ status: "notfound" });
+          return;
+        }
+        const { fetchApprovedLightByUser, fetchEngineClasses } = await import(
+          "@/plugins/cloud-sync/leaderboardClient"
+        );
+        const [entries, classes, vehicles] = await Promise.all([
+          fetchApprovedLightByUser(profile.userId),
+          fetchEngineClasses(),
+          fetchPublicVehicles(profile.userId),
+        ]);
+        if (cancelled) return;
+        setState({
+          status: "ready",
+          data: { profile, vehicles, courses: groupEntriesByCourseWeight(entries, classes) },
+        });
+      } catch (e) {
+        if (!cancelled) {
+          setState({ status: "error", message: e instanceof Error ? e.message : t("loadFailed") });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [name, t]);
+
+  const settingsButton = (
+    <SettingsModal
+      settings={settings}
+      onSettingsChange={setSettings}
+      onToggleFieldDefault={toggleFieldDefault}
+      canHideSampleFiles
+      triggerLabelBreakpoint="sm"
+    />
+  );
+
+  return (
+    <div className="min-h-screen bg-background flex flex-col safe-area-x">
+      <SiteHeader
+        settingsButton={settingsButton}
+        enableCloud={enableCloud}
+        onOpenProfile={() => navigate("/", { state: { openProfile: true } })}
+        showSupportedFiles={false}
+        showAbout={false}
+      />
+
+      <main className="flex-1 px-6 py-6">
+        <div className="mx-auto w-full max-w-4xl space-y-6">
+          <BackToHome />
+
+          {state.status === "loading" && (
+            <p className="text-sm text-muted-foreground">{t("loading")}</p>
+          )}
+          {state.status === "error" && <p className="text-sm text-destructive">{state.message}</p>}
+          {state.status === "notfound" && (
+            <div className="flex flex-col items-center gap-3 rounded-xl border border-dashed border-border p-10 text-center text-muted-foreground">
+              <UserX className="h-10 w-10 opacity-40" />
+              <p className="text-base font-medium text-foreground">{t("notFoundTitle")}</p>
+              <p className="text-sm">{t("notFoundBody", { name })}</p>
+            </div>
+          )}
+
+          {state.status === "ready" && <DriverBody data={state.data} />}
+        </div>
+      </main>
+    </div>
+  );
+}
+
+function DriverBody({ data }: { data: LoadedData }) {
+  const { t } = useTranslation("driver");
+  const navigate = useNavigate();
+  const { profile, vehicles, courses } = data;
+  const [loadingId, setLoadingId] = useState<string | null>(null);
+  const snapshots = flattenSnapshots(courses);
+
+  // Open one uploaded snapshot in the read-only viewer — the same hand-off the
+  // Leaderboards page uses (fetch the full entry, build a synthetic session, jump).
+  const openSnapshot = async (s: SnapshotCard) => {
+    setLoadingId(s.id);
+    try {
+      const { fetchGroupEntries } = await import("@/plugins/cloud-sync/leaderboardClient");
+      const full = await fetchGroupEntries([s.id], 1);
+      const bundle = buildLeaderboardSession(full, {
+        courseName: s.courseName,
+        engineLabel: s.engineLabel,
+        weightLabel: s.weightLabel ?? undefined,
+      });
+      if (!bundle) {
+        toast.error(t("loadFailed"));
+        return;
+      }
+      setPendingLeaderboardSession(bundle);
+      navigate("/");
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : t("loadFailed"));
+    } finally {
+      setLoadingId(null);
+    }
+  };
+
+  return (
+    <div className="space-y-8">
+      {/* Top: avatar + name on the left, public vehicles on the right. */}
+      <div className="flex flex-col gap-6 md:flex-row md:items-start">
+        <div className="flex items-center gap-4 md:shrink-0">
+          <ProfileAvatar url={profile.avatarUrl} alt={profile.displayName} sizeClassName="h-20 w-20" />
+          <h2 className="text-2xl font-bold text-foreground">{profile.displayName}</h2>
+        </div>
+
+        <section className="flex-1 space-y-2">
+          <div className="flex items-center gap-2">
+            <Car className="h-4 w-4 text-primary" />
+            <h3 className="text-sm font-semibold uppercase tracking-wide text-muted-foreground">
+              {t("vehiclesTitle")}
+            </h3>
+          </div>
+          {vehicles.length === 0 ? (
+            <p className="rounded-lg border border-dashed border-border p-3 text-sm text-muted-foreground">
+              {t("vehiclesEmpty")}
+            </p>
+          ) : (
+            <div className="grid gap-2 sm:grid-cols-2">
+              {vehicles.map((v) => (
+                <div key={v.vehicleId} className="rounded-lg border border-border px-3 py-2">
+                  <div className="text-sm font-medium text-foreground">
+                    {v.number ? `#${v.number} — ` : ""}
+                    {v.name}
+                  </div>
+                  <div className="text-xs text-muted-foreground">
+                    {v.typeName ?? t("unknownType")}
+                    {v.engine ? ` · ${v.engine}` : ""}
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </section>
+      </div>
+
+      {/* Below both: uploaded-snapshot cards. Clicking one loads it read-only. */}
+      <section className="space-y-3">
+        <div className="flex items-center gap-2">
+          <Trophy className="h-5 w-5 text-primary" />
+          <h3 className="text-lg font-semibold text-foreground">{t("snapshotsTitle")}</h3>
+        </div>
+        {snapshots.length === 0 ? (
+          <p className="rounded-lg border border-dashed border-border p-4 text-sm text-muted-foreground">
+            {t("snapshotsEmpty")}
+          </p>
+        ) : (
+          <div className="grid gap-2 sm:grid-cols-2 lg:grid-cols-3">
+            {snapshots.map((s) => (
+              <button
+                key={s.id}
+                type="button"
+                disabled={loadingId === s.id}
+                onClick={() => void openSnapshot(s)}
+                title={t("openSnapshot")}
+                className="flex flex-col gap-2 rounded-lg border border-border p-3 text-left transition-colors hover:border-primary/50 hover:bg-primary/5 disabled:opacity-60"
+              >
+                <div className="flex items-start justify-between gap-2">
+                  <div className="min-w-0">
+                    <p className="truncate text-sm font-semibold text-foreground">{s.courseName}</p>
+                    <p className="truncate text-xs text-muted-foreground">{s.trackName}</p>
+                  </div>
+                  <span className="flex shrink-0 items-center gap-1 font-mono text-sm font-semibold text-primary">
+                    {loadingId === s.id && <Loader2 className="h-3.5 w-3.5 animate-spin" />}
+                    {formatLapTime(s.lapTimeMs)}
+                  </span>
+                </div>
+                <div className="flex flex-wrap gap-1">
+                  <span className="flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-[10px] text-muted-foreground">
+                    <Cpu className="h-3 w-3" /> {s.engineLabel}
+                  </span>
+                  {s.weightLabel && (
+                    <span className="flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-[10px] text-muted-foreground">
+                      <Weight className="h-3 w-3" /> {s.weightLabel}
+                    </span>
+                  )}
+                </div>
+              </button>
+            ))}
+          </div>
+        )}
+      </section>
+    </div>
+  );
+}
diff --git a/src/pages/Index.tsx b/src/pages/Index.tsx
index f271710e..14f4c75f 100644
--- a/src/pages/Index.tsx
+++ b/src/pages/Index.tsx
@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useMemo, useState, lazy, Suspense } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
 import { useTranslation } from "react-i18next";
 import { Gauge, Map, ListOrdered, BarChart3, FolderOpen, Play, Pause, StepBack, StepForward, Eye, EyeOff, AlertCircle, Wrench, NotebookPen, SlidersHorizontal, Columns2 } from "lucide-react";
 import { BrandLogo } from "@/components/BrandLogo";
@@ -77,6 +78,8 @@ import { PlaybackProvider, type PlaybackContextValue } from "@/contexts/Playback
 import { VideoTimeProvider, type VideoTimeContextValue } from "@/contexts/VideoTimeContext";
 import { snapshotLapSamples } from "@/lib/lapSnapshot";
 import type { PluginSnapshot } from "@/plugins/panels";
+import { takePendingLeaderboardSession } from "@/lib/leaderboardHandoff";
+import type { LeaderboardDescriptor } from "@/lib/leaderboardSession";
 
 
 type TopPanelView = "raceline" | "laptable" | "graphview" | "coach" | "tools" | "setups" | "notes";
@@ -86,6 +89,7 @@ const enableCloud = import.meta.env.VITE_ENABLE_CLOUD === 'true';
 
 export default function Index() {
   const { t } = useTranslation("session");
+  const { t: tl } = useTranslation("leaderboard");
   const { settings, setSettings, toggleFieldDefault, isFieldHiddenByDefault } = useSettings();
   const fileManager = useFileManager();
   const vehicleManager = useVehicleManager();
@@ -121,11 +125,54 @@ export default function Index() {
   const {
     selection, selectedCourse, laps, selectedLapNumber, referenceLapNumber,
     filteredSamples, visibleSamples, visibleRange, currentIndex, filteredBounds,
-    setSelectedLapNumber, setReferenceLapNumber, setCurrentIndex,
+    setSelection, setLaps, setSelectedLapNumber, setReferenceLapNumber, setCurrentIndex,
     handleSelectionChange, handleLapSelect, handleLapDropdownChange,
     handleSetReference, handleScrub, handleRangeChange, formatRangeLabel: formatRangeLabelTime,
   } = lapMgmt;
 
+  // ── Read-only leaderboard view (plan 0005) ──────────────────────────────────
+  // The /leaderboards page builds a synthetic session and hands it off here; we
+  // consume it once on mount, inject the prebuilt laps/selection verbatim (no
+  // crossing detection on the stitched multi-driver samples), and flip read-only.
+  const navigate = useNavigate();
+  const location = useLocation();
+  const [readOnly, setReadOnly] = useState(false);
+  const [lapLabels, setLapLabels] = useState<Record<number, string>>({});
+  const [readOnlyDescriptor, setReadOnlyDescriptor] = useState<LeaderboardDescriptor | undefined>();
+  const exitReadOnly = useCallback(() => {
+    setReadOnly(false);
+    setLapLabels({});
+    setReadOnlyDescriptor(undefined);
+    sessionData.clearSession();
+    navigate("/leaderboards");
+  }, [sessionData, navigate]);
+
+  // Consume a pending leaderboard session once on mount. Inject the prebuilt
+  // ParsedData + selection + laps directly (bypassing useLapManagement's detection)
+  // and select the fastest lap (lap 1).
+  useEffect(() => {
+    const bundle = takePendingLeaderboardSession();
+    if (!bundle) return;
+    sessionData.loadParsedData(bundle.data, "leaderboard");
+    setSelection(bundle.selection);
+    setLaps(bundle.laps);
+    setSelectedLapNumber(bundle.laps[0]?.lapNumber ?? null);
+    setLapLabels(bundle.lapLabels);
+    setReadOnlyDescriptor(bundle.descriptor);
+    setReadOnly(true);
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- one-shot handoff on mount
+  }, []);
+
+  // The Leaderboards header's Profile button routes here with this flag so the
+  // profile drawer opens without duplicating the drawer onto that route.
+  useEffect(() => {
+    if ((location.state as { openProfile?: boolean } | null)?.openProfile) {
+      fileManager.openProfile();
+      navigate(location.pathname, { replace: true, state: null });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- run on state change only
+  }, [location.state]);
+
   // External reference
   const externalRef = useExternalReference(selectedCourse);
   const {
@@ -497,6 +544,9 @@ export default function Index() {
     selectedLapTimeMs,
     referenceLapNumber,
     isAllLaps,
+    readOnly,
+    lapLabels,
+    readOnlyDescriptor,
     hasReference,
     paceDiff,
     paceDiffLabel,
@@ -560,6 +610,7 @@ export default function Index() {
     visibleRange, minRange,
     selectedCourse, filteredBounds,
     laps, selectedLapNumber, selectedLapTimeMs, referenceLapNumber, isAllLaps,
+    readOnly, lapLabels, readOnlyDescriptor,
     hasReference, paceDiff, paceDiffLabel, slicedPaceData, slicedReferenceSpeedData,
     deltaTopSpeed, deltaMinSpeed, lapToFastestDelta, refAvgTopSpeed, refAvgMinSpeed,
     externalRefLabel, savedFiles,
@@ -691,16 +742,26 @@ export default function Index() {
     <PlaybackProvider value={playbackContextValue}>
     <VideoTimeProvider value={videoTimeContextValue}>
     <div className="h-screen bg-background flex flex-col overflow-hidden safe-area-inset">
-      <header className="border-b border-border px-4 py-2 flex items-center justify-between shrink-0">
-        <button
-          type="button"
-          onClick={clearSession}
-          aria-label={t("header.home")}
-          className="flex items-center gap-3 rounded-md focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-        >
-          <BrandLogo className="w-6 h-6" />
-          <span className="font-semibold text-foreground hidden sm:inline">LapWing</span>
-        </button>
+      <header className={cn(
+        "border-b px-4 py-2 flex items-center justify-between shrink-0",
+        readOnly ? "border-warning bg-warning/15" : "border-border",
+      )}>
+        {readOnly ? (
+          <div className="flex items-center gap-3 min-w-0">
+            <BrandLogo className="w-6 h-6 shrink-0" />
+            <span className="truncate text-sm font-semibold text-warning-foreground">{tl("readOnly.banner")}</span>
+          </div>
+        ) : (
+          <button
+            type="button"
+            onClick={clearSession}
+            aria-label={t("header.home")}
+            className="flex items-center gap-3 rounded-md focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            <BrandLogo className="w-6 h-6" />
+            <span className="font-semibold text-foreground hidden sm:inline">LapWing</span>
+          </button>
+        )}
 
         <div className="flex items-center gap-2">
           <TooltipProvider>
@@ -736,7 +797,9 @@ export default function Index() {
             </Tooltip>
           </TooltipProvider>
 
-          <TrackEditor selection={selection} onSelectionChange={handleSelectionChange} compact laps={laps} samples={data?.samples} />
+          {!readOnly && (
+            <TrackEditor selection={selection} onSelectionChange={handleSelectionChange} compact laps={laps} samples={data?.samples} />
+          )}
 
           {laps.length > 0 && (
             <Select value={selectedLapNumber?.toString() ?? "all"} onValueChange={handleLapDropdownChange}>
@@ -747,50 +810,61 @@ export default function Index() {
                 <SelectItem value="all">{t("header.allLaps")}</SelectItem>
                 {laps.map((lap) => (
                   <SelectItem key={lap.lapNumber} value={lap.lapNumber.toString()}>
-                    {t("header.lap", { number: lap.lapNumber })}
+                    {lapLabels[lap.lapNumber] ?? t("header.lap", { number: lap.lapNumber })}
                   </SelectItem>
                 ))}
               </SelectContent>
             </Select>
           )}
 
-          <LapSnapshotControls
-            snapshotsForCourse={snapshots.snapshotsForCourse}
-            activeSnapshotId={snapshots.activeSnapshotId}
-            canSnapshot={snapshots.canSnapshot}
-            hasCourse={!!selectedCourse}
-            onLoad={snapshots.loadSnapshot}
-            onClear={snapshots.clearActive}
-            onSave={snapshots.saveSelectedLap}
-            overlayLines={overlayLines}
-            onToggleOverlay={toggleOverlay}
-          />
+          {!readOnly && (
+            <LapSnapshotControls
+              snapshotsForCourse={snapshots.snapshotsForCourse}
+              activeSnapshotId={snapshots.activeSnapshotId}
+              canSnapshot={snapshots.canSnapshot}
+              hasCourse={!!selectedCourse}
+              onLoad={snapshots.loadSnapshot}
+              onClear={snapshots.clearActive}
+              onSave={snapshots.saveSelectedLap}
+              overlayLines={overlayLines}
+              onToggleOverlay={toggleOverlay}
+            />
+          )}
 
-          <OverlaysMenu
-            hasCourse={!!selectedCourse}
-            trackName={selection?.trackName}
-            courseName={selectedCourse?.name}
-            currentFileName={currentFileName}
-            laps={laps}
-            overlayLines={overlayLines}
-            referenceLapNumber={referenceLapNumber}
-            externalRefLabel={externalRefLabel}
-            onLoadOverlayFile={loadOverlayFile}
-            onAddExternalOverlay={addExternalOverlay}
-            onToggleOverlay={toggleOverlay}
-            onSetOverlayReference={handleSetOverlayReference}
-          />
+          {!readOnly && (
+            <OverlaysMenu
+              hasCourse={!!selectedCourse}
+              trackName={selection?.trackName}
+              courseName={selectedCourse?.name}
+              currentFileName={currentFileName}
+              laps={laps}
+              overlayLines={overlayLines}
+              referenceLapNumber={referenceLapNumber}
+              externalRefLabel={externalRefLabel}
+              onLoadOverlayFile={loadOverlayFile}
+              onAddExternalOverlay={addExternalOverlay}
+              onToggleOverlay={toggleOverlay}
+              onSetOverlayReference={handleSetOverlayReference}
+            />
+          )}
 
           <SettingsModal settings={settings} onSettingsChange={setSettings} onToggleFieldDefault={toggleFieldDefault} canHideSampleFiles={fileManager.hasOtherFiles} />
-          <Button variant="outline" size="sm" className="h-8 gap-1.5 px-2 lg:px-3" onClick={() => fileManager.open()}>
-            <FolderOpen className="w-4 h-4" />
-            <span className="hidden lg:inline">{t("header.garage")}</span>
-          </Button>
+          {readOnly ? (
+            <Button variant="outline" size="sm" className="h-8 gap-1.5 px-2 lg:px-3" onClick={exitReadOnly}>
+              <FolderOpen className="w-4 h-4" />
+              <span className="hidden lg:inline">{tl("readOnly.exit")}</span>
+            </Button>
+          ) : (
+            <Button variant="outline" size="sm" className="h-8 gap-1.5 px-2 lg:px-3" onClick={() => fileManager.open()}>
+              <FolderOpen className="w-4 h-4" />
+              <span className="hidden lg:inline">{t("header.garage")}</span>
+            </Button>
+          )}
         </div>
       </header>
 
       <main className="flex-1 min-h-0 overflow-hidden flex flex-col">
-        <TabBar topPanelView={topPanelView} setTopPanelView={setTopPanelView} laps={laps} showOverlays={showOverlays} onToggleOverlays={() => setShowOverlays(v => !v)} showCoach={showCoach} showTools={showTools} setupIndicator={setupIndicator} onSetupIndicatorClick={() => setupIndicator && navigateToManage(setupIndicator.target)} overlayLines={overlayLines} splitActive={splitActive} onStartSplit={startSplit} onCombineSplit={combineSplit} />
+        <TabBar topPanelView={topPanelView} setTopPanelView={setTopPanelView} laps={laps} showOverlays={showOverlays} onToggleOverlays={() => setShowOverlays(v => !v)} showCoach={showCoach && !readOnly} showTools={showTools && !readOnly} readOnly={readOnly} setupIndicator={readOnly ? null : setupIndicator} onSetupIndicatorClick={() => setupIndicator && navigateToManage(setupIndicator.target)} overlayLines={overlayLines} splitActive={splitActive} onStartSplit={startSplit} onCombineSplit={combineSplit} />
 
 
         <div className="flex-1 min-h-0 overflow-hidden">
@@ -868,7 +942,7 @@ export default function Index() {
 }
 
 /** Tab navigation bar for the main data view */
-function TabBar({ topPanelView, setTopPanelView, laps, showOverlays, onToggleOverlays, showCoach, showTools, setupIndicator, onSetupIndicatorClick, overlayLines, splitActive, onStartSplit, onCombineSplit }: {
+function TabBar({ topPanelView, setTopPanelView, laps, showOverlays, onToggleOverlays, showCoach, showTools, readOnly, setupIndicator, onSetupIndicatorClick, overlayLines, splitActive, onStartSplit, onCombineSplit }: {
   topPanelView: TopPanelView;
   setTopPanelView: (view: TopPanelView) => void;
   laps: { lapNumber: number }[];
@@ -876,6 +950,7 @@ function TabBar({ topPanelView, setTopPanelView, laps, showOverlays, onToggleOve
   onToggleOverlays: () => void;
   showCoach: boolean;
   showTools: boolean;
+  readOnly?: boolean;
   setupIndicator: SetupIndicator | null;
   onSetupIndicatorClick: () => void;
   overlayLines: OverlayLine[];
@@ -920,23 +995,28 @@ function TabBar({ topPanelView, setTopPanelView, laps, showOverlays, onToggleOve
         </button>
       )}
       {/* Phones: Setups and Notes are separate tabs. Tablet/desktop: one merged
-          tab opens the 50/50 split (SetupsNotesPanel handles the layout). */}
-      <button onClick={() => setTopPanelView("setups")} className={cn(tabClass("setups"), "md:hidden")}>
-        <SlidersHorizontal className="w-4 h-4" /> <span className="hidden sm:inline">{t("tabs.setups")}</span>
-      </button>
-      <button onClick={() => setTopPanelView("notes")} className={cn(tabClass("notes"), "md:hidden")}>
-        <NotebookPen className="w-4 h-4" /> <span className="hidden sm:inline">{t("tabs.notes")}</span>
-      </button>
-      <button
-        onClick={() => setTopPanelView("setups")}
-        className={cn(tabBase, tabState(setupsNotesActive), "hidden md:flex")}
-      >
-        <span className="flex items-center gap-1">
-          <SlidersHorizontal className="w-4 h-4" />
-          <NotebookPen className="w-4 h-4" />
-        </span>
-        {t("tabs.setupsNotes")}
-      </button>
+          tab opens the 50/50 split (SetupsNotesPanel handles the layout). Hidden
+          in read-only leaderboard view (no saving). */}
+      {!readOnly && (
+        <>
+          <button onClick={() => setTopPanelView("setups")} className={cn(tabClass("setups"), "md:hidden")}>
+            <SlidersHorizontal className="w-4 h-4" /> <span className="hidden sm:inline">{t("tabs.setups")}</span>
+          </button>
+          <button onClick={() => setTopPanelView("notes")} className={cn(tabClass("notes"), "md:hidden")}>
+            <NotebookPen className="w-4 h-4" /> <span className="hidden sm:inline">{t("tabs.notes")}</span>
+          </button>
+          <button
+            onClick={() => setTopPanelView("setups")}
+            className={cn(tabBase, tabState(setupsNotesActive), "hidden md:flex")}
+          >
+            <span className="flex items-center gap-1">
+              <SlidersHorizontal className="w-4 h-4" />
+              <NotebookPen className="w-4 h-4" />
+            </span>
+            {t("tabs.setupsNotes")}
+          </button>
+        </>
+      )}
       {setupIndicator && (
         <TooltipProvider>
           <Tooltip>
diff --git a/src/pages/Leaderboards.tsx b/src/pages/Leaderboards.tsx
new file mode 100644
index 00000000..0e8cc2ed
--- /dev/null
+++ b/src/pages/Leaderboards.tsx
@@ -0,0 +1,339 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Link, useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { ChevronRight, Trophy, Cpu, Hash, Layers } from "lucide-react";
+import { toast } from "sonner";
+import { SiteHeader } from "@/components/SiteHeader";
+import { SettingsModal } from "@/components/SettingsModal";
+import { BackToHome } from "@/components/BackToHome";
+import { ProfileAvatar } from "@/components/ProfileAvatar";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import { Label } from "@/components/ui/label";
+import {
+  Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
+} from "@/components/ui/select";
+import { useSettings } from "@/hooks/useSettings";
+import { formatLapTime } from "@/lib/lapCalculation";
+import { buildBrowseTree, type CourseNode, type GroupNode, type TrackNode } from "@/lib/leaderboardBrowse";
+import { buildLeaderboardSession } from "@/lib/leaderboardSession";
+import { setPendingLeaderboardSession } from "@/lib/leaderboardHandoff";
+import type { EngineClass, LeaderboardEntry } from "@/lib/leaderboardTypes";
+import { cn } from "@/lib/utils";
+
+const enableCloud = import.meta.env.VITE_ENABLE_CLOUD === "true";
+const TOP_OPTIONS = [3, 10, 25, 50, 100] as const;
+const DEFAULT_TOP = 50;
+
+/** A little data bubble (same visual language used elsewhere in the app). */
+function Bubble({ icon: Icon, children }: { icon: typeof Cpu; children: React.ReactNode }) {
+  return (
+    <span className="inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-xs text-muted-foreground">
+      <Icon className="h-3 w-3" />
+      {children}
+    </span>
+  );
+}
+
+export default function Leaderboards() {
+  const navigate = useNavigate();
+  const { t } = useTranslation(["leaderboard", "common"]);
+  const { settings, setSettings, toggleFieldDefault } = useSettings();
+
+  const [entries, setEntries] = useState<LeaderboardEntry[] | null>(null);
+  const [classes, setClasses] = useState<EngineClass[]>([]);
+  const [avatars, setAvatars] = useState<Map<string, string | null>>(new Map());
+  const [error, setError] = useState<string | null>(null);
+  const [groupByWeight, setGroupByWeight] = useState(false);
+  const [top, setTop] = useState<number | "all">(DEFAULT_TOP);
+  const [openTracks, setOpenTracks] = useState<Set<string>>(new Set());
+  const [openCourses, setOpenCourses] = useState<Set<string>>(new Set());
+  const [openGroups, setOpenGroups] = useState<Set<string>>(new Set());
+  const [loadingKey, setLoadingKey] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const { fetchApprovedLight, fetchEngineClasses } = await import("@/plugins/cloud-sync/leaderboardClient");
+        const { fetchAllPublicProfiles } = await import("@/plugins/cloud-sync/publicProfile");
+        const [light, cls, profiles] = await Promise.all([
+          fetchApprovedLight(),
+          fetchEngineClasses(),
+          fetchAllPublicProfiles().catch(() => new Map()),
+        ]);
+        if (cancelled) return;
+        setEntries(light);
+        setClasses(cls);
+        setAvatars(new Map([...profiles].map(([id, p]) => [id, p.avatarUrl])));
+      } catch (e) {
+        if (!cancelled) setError(e instanceof Error ? e.message : t("loadFailed"));
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [t]);
+
+  const tree = useMemo(
+    () => (entries ? buildBrowseTree(entries, classes, groupByWeight) : []),
+    [entries, classes, groupByWeight],
+  );
+
+  const toggle = (set: Set<string>, key: string, setter: (s: Set<string>) => void) => {
+    const next = new Set(set);
+    if (next.has(key)) next.delete(key); else next.add(key);
+    setter(next);
+  };
+
+  // Build + hand off a read-only session from a set of entry ids (one lap, or the
+  // top-N of a group), then jump to the viewer.
+  const loadSession = useCallback(
+    async (course: CourseNode, group: GroupNode, ids: string[], limit: number | null, loadingKey: string) => {
+      setLoadingKey(loadingKey);
+      try {
+        const { fetchGroupEntries } = await import("@/plugins/cloud-sync/leaderboardClient");
+        const full = await fetchGroupEntries(ids, limit);
+        const bundle = buildLeaderboardSession(full, {
+          courseName: course.courseName,
+          engineLabel: group.engineLabel,
+          weightLabel: group.weightLabel,
+        });
+        if (!bundle) {
+          toast.error(t("buildFailed"));
+          return;
+        }
+        setPendingLeaderboardSession(bundle);
+        navigate("/");
+      } catch (e) {
+        toast.error(e instanceof Error ? e.message : t("buildFailed"));
+      } finally {
+        setLoadingKey(null);
+      }
+    },
+    [navigate, t],
+  );
+
+  const openTopSession = useCallback(
+    (course: CourseNode, group: GroupNode) =>
+      loadSession(course, group, group.entryIds, top === "all" ? null : top, `top:${course.courseKey}|${group.key}`),
+    [loadSession, top],
+  );
+
+  const openSingle = useCallback(
+    (course: CourseNode, group: GroupNode, entryId: string) =>
+      loadSession(course, group, [entryId], 1, `one:${entryId}`),
+    [loadSession],
+  );
+
+  const settingsButton = (
+    <SettingsModal
+      settings={settings}
+      onSettingsChange={setSettings}
+      onToggleFieldDefault={toggleFieldDefault}
+      canHideSampleFiles
+      triggerLabelBreakpoint="sm"
+    />
+  );
+
+  return (
+    <div className="min-h-screen bg-background flex flex-col safe-area-x">
+      <SiteHeader
+        settingsButton={settingsButton}
+        enableCloud={enableCloud}
+        onOpenProfile={() => navigate("/", { state: { openProfile: true } })}
+        showSupportedFiles={false}
+        showAbout={false}
+      />
+
+      <main className="flex-1 px-6 py-8">
+        <div className="mx-auto w-full max-w-4xl space-y-5">
+          <BackToHome />
+          <div className="flex items-center gap-3">
+            <Trophy className="h-6 w-6 text-primary" />
+            <div>
+              <h2 className="text-2xl font-bold text-foreground">{t("title")}</h2>
+              <p className="text-sm text-muted-foreground">{t("subtitle")}</p>
+            </div>
+          </div>
+
+          <div className="flex flex-wrap items-center justify-between gap-3">
+            <div className="flex items-center gap-2">
+              <Switch id="gbw" checked={groupByWeight} onCheckedChange={setGroupByWeight} />
+              <Label htmlFor="gbw" className="text-sm text-muted-foreground">{t("groupByWeight")}</Label>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-sm text-muted-foreground">{t("showTop")}</span>
+              <Select value={String(top)} onValueChange={(v) => setTop(v === "all" ? "all" : Number(v))}>
+                <SelectTrigger className="h-8 w-24"><SelectValue /></SelectTrigger>
+                <SelectContent>
+                  {TOP_OPTIONS.map((n) => (
+                    <SelectItem key={n} value={String(n)}>{n}</SelectItem>
+                  ))}
+                  <SelectItem value="all">{t("all")}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+
+          {error && <p className="text-sm text-destructive">{error}</p>}
+          {!entries && !error && <p className="text-sm text-muted-foreground">{t("loading")}</p>}
+          {entries && tree.length === 0 && (
+            <div className="rounded-xl border border-dashed border-border p-10 text-center text-muted-foreground">
+              {t("empty")}
+            </div>
+          )}
+
+          <div className="space-y-2">
+            {tree.map((track) => (
+              <TrackRow
+                key={track.trackName}
+                track={track}
+                open={openTracks.has(track.trackName)}
+                onToggle={() => toggle(openTracks, track.trackName, setOpenTracks)}
+                openCourses={openCourses}
+                onToggleCourse={(ck) => toggle(openCourses, ck, setOpenCourses)}
+                openGroups={openGroups}
+                onToggleGroup={(gk) => toggle(openGroups, gk, setOpenGroups)}
+                onOpenTopSession={openTopSession}
+                onOpenSingle={openSingle}
+                top={top}
+                loadingKey={loadingKey}
+                avatars={avatars}
+              />
+            ))}
+          </div>
+        </div>
+      </main>
+    </div>
+  );
+}
+
+function TrackRow({
+  track, open, onToggle, openCourses, onToggleCourse, openGroups, onToggleGroup,
+  onOpenTopSession, onOpenSingle, top, loadingKey, avatars,
+}: {
+  track: TrackNode;
+  open: boolean;
+  onToggle: () => void;
+  openCourses: Set<string>;
+  onToggleCourse: (courseKey: string) => void;
+  openGroups: Set<string>;
+  onToggleGroup: (groupKey: string) => void;
+  onOpenTopSession: (course: CourseNode, group: GroupNode) => void;
+  onOpenSingle: (course: CourseNode, group: GroupNode, entryId: string) => void;
+  top: number | "all";
+  loadingKey: string | null;
+  avatars: Map<string, string | null>;
+}) {
+  const { t } = useTranslation("leaderboard");
+  return (
+    <div className="rounded-lg border border-border">
+      <button
+        type="button"
+        onClick={onToggle}
+        className="flex w-full items-center gap-3 px-4 py-3 text-left hover:bg-muted/50"
+      >
+        <ChevronRight className={cn("h-4 w-4 shrink-0 transition-transform", open && "rotate-90")} />
+        <span className="flex-1 font-semibold text-foreground">{track.trackName}</span>
+        <span className="flex flex-wrap gap-1.5">
+          <Bubble icon={Cpu}>{t("bubbles.engines", { count: track.engineCount })}</Bubble>
+          <Bubble icon={Hash}>{t("bubbles.records", { count: track.recordCount })}</Bubble>
+          <Bubble icon={Trophy}>{t("bubbles.fastest", { time: formatLapTime(track.fastestMs) })}</Bubble>
+        </span>
+      </button>
+
+      {open && (
+        <div className="border-t border-border px-2 py-2 space-y-1.5">
+          {track.courses.map((course) => {
+            const courseOpen = openCourses.has(course.courseKey);
+            return (
+              <div key={course.courseKey} className="rounded-md border border-border/60">
+                <button
+                  type="button"
+                  onClick={() => onToggleCourse(course.courseKey)}
+                  className="flex w-full items-center gap-3 px-3 py-2 text-left hover:bg-muted/40"
+                >
+                  <ChevronRight className={cn("h-4 w-4 shrink-0 transition-transform", courseOpen && "rotate-90")} />
+                  <span className="flex-1 text-sm font-medium text-foreground">{course.courseName}</span>
+                  <span className="flex flex-wrap gap-1.5">
+                    <Bubble icon={Cpu}>{t("bubbles.engines", { count: course.engineCount })}</Bubble>
+                    <Bubble icon={Hash}>{t("bubbles.records", { count: course.recordCount })}</Bubble>
+                    <Bubble icon={Trophy}>{t("bubbles.fastest", { time: formatLapTime(course.fastestMs) })}</Bubble>
+                  </span>
+                </button>
+
+                {courseOpen && (
+                  <div className="border-t border-border/60 px-2 py-1.5 space-y-1">
+                    {course.groups.map((group) => {
+                      const groupKey = `${course.courseKey}|${group.key}`;
+                      const groupOpen = openGroups.has(groupKey);
+                      const topN = top === "all" ? group.recordCount : Math.min(top, group.recordCount);
+                      return (
+                        <div key={group.key} className="rounded border border-border/50">
+                          <button
+                            type="button"
+                            onClick={() => onToggleGroup(groupKey)}
+                            className="flex w-full items-center gap-2 px-3 py-2 text-left text-sm hover:bg-primary/10"
+                          >
+                            <ChevronRight className={cn("h-3.5 w-3.5 shrink-0 transition-transform", groupOpen && "rotate-90")} />
+                            <span className="flex-1 text-foreground">{group.label}</span>
+                            <span className="font-mono text-xs text-muted-foreground">
+                              {formatLapTime(group.fastestMs)}
+                            </span>
+                            <Bubble icon={Hash}>{t("bubbles.records", { count: group.recordCount })}</Bubble>
+                          </button>
+
+                          {groupOpen && (
+                            <div className="border-t border-border/50 px-2 py-1.5 space-y-1">
+                              {group.recordCount > 1 && (
+                                <Button
+                                  size="sm"
+                                  variant="secondary"
+                                  className="w-full h-8 justify-center gap-1.5"
+                                  disabled={loadingKey === `top:${course.courseKey}|${group.key}`}
+                                  onClick={() => onOpenTopSession(course, group)}
+                                >
+                                  <Layers className="h-3.5 w-3.5" />
+                                  {top === "all"
+                                    ? t("loadAllSession")
+                                    : t("loadTopSession", { count: topN })}
+                                </Button>
+                              )}
+                              {group.entries.map((entry, i) => (
+                                <div
+                                  key={entry.id}
+                                  className="flex w-full items-center gap-2 rounded px-2 py-1.5 text-sm hover:bg-primary/10"
+                                >
+                                  <span className="w-6 shrink-0 text-center font-mono text-xs text-muted-foreground">{i + 1}</span>
+                                  <Link
+                                    to={`/driver/${encodeURIComponent(entry.displayName)}`}
+                                    title={t("viewProfile")}
+                                    className="shrink-0 rounded-full transition-opacity hover:opacity-80"
+                                  >
+                                    <ProfileAvatar url={avatars.get(entry.userId)} alt={entry.displayName} sizeClassName="h-5 w-5" />
+                                  </Link>
+                                  <button
+                                    type="button"
+                                    disabled={loadingKey === `one:${entry.id}`}
+                                    onClick={() => onOpenSingle(course, group, entry.id)}
+                                    className="flex flex-1 items-center gap-2 text-left disabled:opacity-60"
+                                  >
+                                    <span className="flex-1 truncate text-foreground">{entry.displayName}</span>
+                                    <span className="font-mono text-xs text-muted-foreground">{formatLapTime(entry.lapTimeMs)}</span>
+                                  </button>
+                                </div>
+                              ))}
+                            </div>
+                          )}
+                        </div>
+                      );
+                    })}
+                  </div>
+                )}
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/plugins/cloud-sync/LeaderboardSubmitPanel.tsx b/src/plugins/cloud-sync/LeaderboardSubmitPanel.tsx
new file mode 100644
index 00000000..3c1e1fd7
--- /dev/null
+++ b/src/plugins/cloud-sync/LeaderboardSubmitPanel.tsx
@@ -0,0 +1,226 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Trophy, Check, MapPin } from "lucide-react";
+import { toast } from "sonner";
+import type { PluginPanelProps } from "@/plugins/panels";
+import { Button } from "@/components/ui/button";
+import { autoSubmitSnapshotTrack } from "./trackAutoSubmit";
+import { Input } from "@/components/ui/input";
+import { Switch } from "@/components/ui/switch";
+import { Label } from "@/components/ui/label";
+import {
+  Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger,
+} from "@/components/ui/dialog";
+import { useAuth } from "@/contexts/AuthContext";
+import { formatLapTime } from "@/lib/lapCalculation";
+import type { LapSnapshot } from "@/lib/lapSnapshot";
+import { listSnapshots } from "@/lib/lapSnapshotStorage";
+import { onGarageChange } from "@/lib/garageEvents";
+import { STORE_NAMES } from "@/lib/dbUtils";
+import {
+  contentHashForSnapshot, defaultListedWeight, isValidListedWeight,
+} from "./leaderboardSubmission";
+import { buildNewEntryRow, fetchMyEntries, insertEntries } from "./leaderboardClient";
+
+/** Per-snapshot form state in the submit dialog. */
+interface RowState {
+  weight: string;
+  unit: "lb" | "kg";
+  shareEngine: boolean;
+  busy: boolean;
+}
+
+// Profile-tab panel: submit your lap snapshots to the public leaderboards. Visible
+// only when signed in (submission needs an account) and you have ≥1 snapshot.
+export default function LeaderboardSubmitPanel(_props: PluginPanelProps) {
+  const { t } = useTranslation("plugins");
+  const { user, loading } = useAuth();
+  const [snaps, setSnaps] = useState<LapSnapshot[]>([]);
+  const [submittedHashes, setSubmittedHashes] = useState<Set<string>>(new Set());
+  const [rows, setRows] = useState<Record<string, RowState>>({});
+  const [open, setOpen] = useState(false);
+
+  const refresh = useCallback(async () => {
+    const local = await listSnapshots();
+    setSnaps(local);
+    if (user) {
+      try {
+        const mine = await fetchMyEntries(user.id);
+        setSubmittedHashes(new Set(mine.map((e) => e.contentHash)));
+      } catch (e) {
+        // Leave the known set as-is; the DB unique constraint is the backstop.
+        console.warn("[leaderboard] couldn't load existing entries:", e);
+      }
+    }
+  }, [user]);
+
+  useEffect(() => {
+    void refresh();
+    return onGarageChange((c) => {
+      if (c.store === STORE_NAMES.LAP_SNAPSHOTS) void refresh();
+    });
+  }, [refresh]);
+
+  // Seed per-row form defaults whenever the snapshot list changes.
+  useEffect(() => {
+    setRows((prev) => {
+      const next: Record<string, RowState> = {};
+      for (const s of snaps) {
+        const d = defaultListedWeight(s);
+        next[s.id] = prev[s.id] ?? {
+          weight: d.weight !== null ? String(d.weight) : "",
+          unit: d.unit,
+          shareEngine: false,
+          busy: false,
+        };
+      }
+      return next;
+    });
+  }, [snaps]);
+
+  const hashes = useMemo(() => new Map(snaps.map((s) => [s.id, contentHashForSnapshot(s)])), [snaps]);
+
+  if (loading) return <p className="text-sm text-muted-foreground">{t("loading")}</p>;
+  if (!user) return <p className="text-xs text-muted-foreground">{t("leaderboard.signInHint")}</p>;
+  if (snaps.length === 0) return <p className="text-xs text-muted-foreground">{t("leaderboard.noSnapshots")}</p>;
+
+  const setRow = (id: string, patch: Partial<RowState>) =>
+    setRows((r) => ({ ...r, [id]: { ...r[id], ...patch } }));
+
+  const submit = async (snap: LapSnapshot) => {
+    const row = rows[snap.id];
+    const weight = Number(row.weight);
+    if (!isValidListedWeight(weight)) {
+      toast.error(t("leaderboard.weightRequired"));
+      return;
+    }
+    setRow(snap.id, { busy: true });
+    try {
+      const newRow = buildNewEntryRow(snap, {
+        userId: user.id,
+        engineTelemetryPublic: row.shareEngine,
+        listedWeight: weight,
+        listedWeightUnit: row.unit,
+      });
+      await insertEntries([newRow]);
+      setSubmittedHashes((s) => new Set(s).add(newRow.content_hash));
+      toast.success(t("leaderboard.submitSuccess"));
+      // A custom (non-built-in) track rides along to the community track DB too,
+      // best-effort — never block or fail the snapshot submission over it.
+      void autoSubmitSnapshotTrack(snap)
+        .then((added) => { if (added) toast.success(t("leaderboard.trackAdded")); })
+        .catch((err) => console.warn("[leaderboard] track auto-submit failed:", err));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error("[leaderboard] submit failed:", e);
+      toast.error(/duplicate key|unique/i.test(msg) ? t("leaderboard.alreadySubmitted") : t("leaderboard.submitFailed"));
+    } finally {
+      setRow(snap.id, { busy: false });
+    }
+  };
+
+  const submittableCount = snaps.filter((s) => !submittedHashes.has(hashes.get(s.id) ?? "")).length;
+
+  return (
+    <div className="space-y-2">
+      <p className="text-xs text-muted-foreground">
+        {t("leaderboard.intro", { count: snaps.length })}
+      </p>
+      <Dialog open={open} onOpenChange={setOpen}>
+        <DialogTrigger asChild>
+          <Button size="sm" className="h-8 gap-1.5" disabled={submittableCount === 0}>
+            <Trophy className="h-4 w-4" />
+            {t("leaderboard.submitButton")}
+          </Button>
+        </DialogTrigger>
+        <DialogContent className="max-h-[85vh] overflow-y-auto sm:max-w-lg">
+          <DialogHeader>
+            <DialogTitle>{t("leaderboard.dialogTitle")}</DialogTitle>
+            <DialogDescription>{t("leaderboard.dialogDescription")}</DialogDescription>
+          </DialogHeader>
+
+          <div className="space-y-3">
+            {snaps.map((snap) => {
+              const row = rows[snap.id];
+              if (!row) return null;
+              const done = submittedHashes.has(hashes.get(snap.id) ?? "");
+              return (
+                <div key={snap.id} className="rounded-md border border-border p-3 space-y-2.5">
+                  <div className="flex items-center justify-between gap-2">
+                    <div className="min-w-0">
+                      <p className="truncate text-sm text-foreground">
+                        {snap.engine}
+                        <span className="ml-1.5 font-mono text-xs text-muted-foreground">
+                          {formatLapTime(snap.lapTimeMs)}
+                        </span>
+                      </p>
+                      <p className="truncate text-[11px] text-muted-foreground">
+                        {snap.trackName} — {snap.courseName}
+                      </p>
+                    </div>
+                    {done ? (
+                      <span className="flex items-center gap-1 text-xs text-muted-foreground">
+                        <Check className="h-3.5 w-3.5 text-green-500" />
+                        {t("leaderboard.submitted")}
+                      </span>
+                    ) : (
+                      <Button size="sm" className="h-7 text-xs" disabled={row.busy} onClick={() => void submit(snap)}>
+                        {row.busy ? t("leaderboard.submitting") : t("leaderboard.submitOne")}
+                      </Button>
+                    )}
+                  </div>
+
+                  {!done && (
+                    <>
+                      <div className="flex items-end gap-2">
+                        <div className="flex-1">
+                          <Label htmlFor={`w-${snap.id}`} className="text-xs text-muted-foreground">
+                            {t("leaderboard.listedWeight")}
+                          </Label>
+                          <Input
+                            id={`w-${snap.id}`}
+                            type="number"
+                            inputMode="decimal"
+                            className="h-8"
+                            value={row.weight}
+                            onChange={(e) => setRow(snap.id, { weight: e.target.value })}
+                          />
+                        </div>
+                        <select
+                          className="h-8 rounded-md border border-input bg-background px-2 text-sm"
+                          value={row.unit}
+                          onChange={(e) => setRow(snap.id, { unit: e.target.value as "lb" | "kg" })}
+                          aria-label={t("leaderboard.listedWeight")}
+                        >
+                          <option value="lb">lb</option>
+                          <option value="kg">kg</option>
+                        </select>
+                      </div>
+                      <p className="text-[11px] text-muted-foreground">{t("leaderboard.listedWeightHint")}</p>
+
+                      <div className="flex items-center gap-2">
+                        <Switch id={`eng-${snap.id}`} checked={row.shareEngine} onCheckedChange={(v) => setRow(snap.id, { shareEngine: v })} />
+                        <Label htmlFor={`eng-${snap.id}`} className="text-xs text-muted-foreground">{t("leaderboard.shareEngineData")}</Label>
+                      </div>
+                      <p className="text-[11px] text-muted-foreground">{t("leaderboard.publicNotice")}</p>
+
+                      {/* Custom (non-built-in) track: its layout + sectors ride along in the
+                          snapshot data AND get auto-submitted to the community track DB on
+                          submit (best-effort, attributed to the signed-in user). */}
+                      {snap.course?.isUserDefined && (
+                        <p className="flex items-start gap-1.5 rounded-md border border-amber-500/40 bg-amber-500/10 px-2.5 py-2 text-[11px] text-amber-700 dark:text-amber-400">
+                          <MapPin className="mt-0.5 h-3.5 w-3.5 shrink-0" />
+                          {t("leaderboard.customTrackNotice")}
+                        </p>
+                      )}
+                    </>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
diff --git a/src/plugins/cloud-sync/StoragePanel.tsx b/src/plugins/cloud-sync/StoragePanel.tsx
index 4d1abf18..03d4e5a5 100644
--- a/src/plugins/cloud-sync/StoragePanel.tsx
+++ b/src/plugins/cloud-sync/StoragePanel.tsx
@@ -1,14 +1,15 @@
-import { useCallback, useEffect, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { Link } from "react-router-dom";
 import {
-  Check, CloudOff, CreditCard, Info, Loader2, LogOut, Pencil, RefreshCw,
-  User as UserIcon, WifiOff, X,
+  Camera, Check, CloudOff, CreditCard, Info, Link2, Loader2, LogOut, Pencil, RefreshCw,
+  WifiOff, X,
 } from "lucide-react";
 import { toast } from "sonner";
 import type { PluginPanelProps } from "@/plugins/panels";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
+import { ProfileAvatar } from "@/components/ProfileAvatar";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
 import { useAuth } from "@/contexts/AuthContext";
 import { useOnlineStatus } from "@/hooks/useOnlineStatus";
@@ -17,9 +18,10 @@ import { isPaidTier, isComped, hasCompGrant, daysUntilTrim } from "@/lib/billing
 import { createPortal } from "@/lib/billingClient";
 import { isNativeApp } from "@/lib/platform";
 import { onGarageChange } from "@/lib/garageEvents";
+import { cropToSquareAvatar } from "@/lib/imageCrop";
 import { getStorageUsage } from "./syncEngine";
 import { getLocalStorageUsage } from "./localUsage";
-import { getMyProfile, updateDisplayName } from "./profile";
+import { avatarPublicUrl, getMyProfile, updateDisplayName, uploadAvatar } from "./profile";
 import { pendingCount } from "./pendingSync";
 import {
   formatBytes, segmentFractions, totalUsed, usageFraction,
@@ -163,24 +165,59 @@ function SignInPrompt() {
 function DisplayName({ userId, email, action }: { userId: string; email: string; action?: ReactNode }) {
   const { t } = useTranslation("plugins");
   const [name, setName] = useState<string | null>(null);
+  const [avatarUrl, setAvatarUrl] = useState<string | null>(null);
   const [editing, setEditing] = useState(false);
   const [draft, setDraft] = useState("");
   const [saving, setSaving] = useState(false);
+  const [uploading, setUploading] = useState(false);
+  const fileRef = useRef<HTMLInputElement>(null);
 
   useEffect(() => {
     let cancelled = false;
     void getMyProfile(userId)
       .then((p) => {
-        if (!cancelled) setName(p?.display_name ?? null);
+        if (cancelled) return;
+        setName(p?.display_name ?? null);
+        setAvatarUrl(avatarPublicUrl(p));
       })
       .catch(() => {
-        if (!cancelled) setName(null);
+        if (!cancelled) {
+          setName(null);
+          setAvatarUrl(null);
+        }
       });
     return () => {
       cancelled = true;
     };
   }, [userId]);
 
+  // Crop to a centered ≤256px square on-device, then upload to the public bucket.
+  const onPickAvatar = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    e.target.value = ""; // allow re-picking the same file
+    if (!file) return;
+    setUploading(true);
+    try {
+      const { blob } = await cropToSquareAvatar(file);
+      const saved = await uploadAvatar(userId, blob);
+      setAvatarUrl(avatarPublicUrl(saved));
+      toast.success(t("account.avatarUpdated"));
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : t("account.avatarFailed"));
+    } finally {
+      setUploading(false);
+    }
+  };
+
+  const copyProfileLink = () => {
+    if (!name) return;
+    const url = `${window.location.origin}/driver/${encodeURIComponent(name)}`;
+    void navigator.clipboard
+      ?.writeText(url)
+      .then(() => toast.success(t("account.linkCopied")))
+      .catch(() => toast.error(t("account.linkCopyFailed")));
+  };
+
   const startEdit = () => {
     setDraft(name ?? "");
     setEditing(true);
@@ -207,9 +244,25 @@ function DisplayName({ userId, email, action }: { userId: string; email: string;
 
   return (
     <div className="flex items-center gap-3">
-      <div className="flex h-12 w-12 shrink-0 items-center justify-center rounded-full bg-muted text-muted-foreground">
-        <UserIcon className="h-6 w-6" />
-      </div>
+      <button
+        type="button"
+        onClick={() => fileRef.current?.click()}
+        disabled={uploading}
+        aria-label={t("account.changeAvatar")}
+        className="group relative shrink-0 rounded-full ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+      >
+        <ProfileAvatar url={avatarUrl} alt={name ?? ""} sizeClassName="h-12 w-12" />
+        <span className="absolute inset-0 flex items-center justify-center rounded-full bg-black/45 text-white opacity-0 transition-opacity group-hover:opacity-100">
+          {uploading ? <Loader2 className="h-5 w-5 animate-spin" /> : <Camera className="h-5 w-5" />}
+        </span>
+        <input
+          ref={fileRef}
+          type="file"
+          accept="image/*"
+          className="hidden"
+          onChange={(e) => void onPickAvatar(e)}
+        />
+      </button>
       <div className="min-w-0 flex-1">
         {editing ? (
           <div className="flex items-center gap-1.5">
@@ -242,7 +295,18 @@ function DisplayName({ userId, email, action }: { userId: string; email: string;
         )}
         <p className="truncate text-xs text-muted-foreground">{email}</p>
       </div>
-      {action}
+      <div className="flex shrink-0 flex-col items-end gap-1">
+        {action}
+        <Button
+          variant="ghost"
+          size="sm"
+          className="text-muted-foreground"
+          disabled={!name}
+          onClick={copyProfileLink}
+        >
+          <Link2 className="mr-1.5 h-4 w-4" /> {t("account.copyProfileLink")}
+        </Button>
+      </div>
     </div>
   );
 }
diff --git a/src/plugins/cloud-sync/autoSync.ts b/src/plugins/cloud-sync/autoSync.ts
index 2af154cb..7c30a015 100644
--- a/src/plugins/cloud-sync/autoSync.ts
+++ b/src/plugins/cloud-sync/autoSync.ts
@@ -22,6 +22,7 @@ import { unselectFile } from "./fileSync";
 import { setActiveUserId } from "./activeUser";
 import { pendingId } from "./merge";
 import { FILE_STORE } from "./syncStores";
+import { syncPublicVehicle } from "./publicVehicleSync";
 
 const DEBOUNCE_MS = 800;
 
@@ -72,6 +73,9 @@ async function pushOne(userId: string, change: GarageChange): Promise<void> {
   }
   if (change.type === "delete") await deleteRecord(userId, change.store, change.key);
   else await pushRecord(userId, change.store, change.key);
+
+  // Vehicles carry an opt-in public projection alongside their private backup.
+  if (change.store === STORE_NAMES.KARTS) await syncPublicVehicle(userId, change);
 }
 
 async function flush(change: GarageChange): Promise<void> {
diff --git a/src/plugins/cloud-sync/cloudClient.ts b/src/plugins/cloud-sync/cloudClient.ts
index 4b1c85af..b6462ffe 100644
--- a/src/plugins/cloud-sync/cloudClient.ts
+++ b/src/plugins/cloud-sync/cloudClient.ts
@@ -12,6 +12,7 @@ import type { SupabaseClient } from "@supabase/supabase-js";
 import { supabase } from "@/integrations/supabase/client";
 
 export const SYNC_BUCKET = "user-files";
+export const AVATAR_BUCKET = "user-avatars";
 
 /** A row in public.sync_records — one client record stored as a jsonb document. */
 export interface SyncRecordRow {
@@ -50,6 +51,11 @@ export function userFiles() {
   return untyped.storage.from(SYNC_BUCKET);
 }
 
+/** Storage API for the public per-user avatar bucket. */
+export function userAvatars() {
+  return untyped.storage.from(AVATAR_BUCKET);
+}
+
 /** The single-row pooled-usage shape returned by the server's sync_storage_usage() RPC. */
 export interface StorageUsageRow {
   documents_bytes: number;
@@ -73,17 +79,50 @@ export function isQuotaError(err: unknown): boolean {
   return err instanceof Error && /quota_exceeded/i.test(err.message);
 }
 
-/** A row in public.profiles — the user's unique, editable display name. */
+/** A row in public.profiles — the user's unique, editable display name + avatar. */
 export interface ProfileRow {
   user_id: string;
   display_name: string;
+  /** Object path in the user-avatars bucket, or null when no avatar is set. */
+  avatar_path?: string | null;
+  /** Last avatar change — used as a ?v= cache-buster on the public URL. */
+  avatar_updated_at?: string | null;
 }
 
-/** Query builder for the profiles table. */
+/** Query builder for the profiles table (owner reads/writes). */
 export function profiles() {
   return untyped.from("profiles");
 }
 
+/** A row in public.public_profiles — the anon-readable, column-limited view. */
+export interface PublicProfileRow {
+  user_id: string;
+  display_name: string;
+  avatar_path: string | null;
+  avatar_updated_at: string | null;
+}
+
+/** Query builder for the anon-readable public_profiles view. */
+export function publicProfilesView() {
+  return untyped.from("public_profiles");
+}
+
+/** A row in public.public_vehicles — a user's opt-in, public-safe vehicle. */
+export interface PublicVehicleRow {
+  user_id: string;
+  vehicle_id: string;
+  name: string;
+  type_name: string | null;
+  engine: string;
+  number: number;
+  updated_at?: string;
+}
+
+/** Query builder for the public_vehicles projection table. */
+export function publicVehicles() {
+  return untyped.from("public_vehicles");
+}
+
 /** True when a Postgres error is a unique-constraint violation (e.g. taken name). */
 export function isUniqueViolation(err: unknown): boolean {
   if (!err || typeof err !== "object") return false;
diff --git a/src/plugins/cloud-sync/index.ts b/src/plugins/cloud-sync/index.ts
index 254f4d0b..63744817 100644
--- a/src/plugins/cloud-sync/index.ts
+++ b/src/plugins/cloud-sync/index.ts
@@ -1,5 +1,5 @@
 import { lazy } from "react";
-import { Camera, Cloud, ShieldCheck, User } from "lucide-react";
+import { Camera, Cloud, ShieldCheck, Trophy, User } from "lucide-react";
 import { toast } from "sonner";
 import type { DataViewerPlugin } from "@/plugins/types";
 import { PANELS_POINT, PanelSlot, type PluginPanel } from "@/plugins/panels";
@@ -21,6 +21,7 @@ const FileDeleteToggle = lazy(() => import("./FileDeleteToggle"));
 const StoragePanel = lazy(() => import("./StoragePanel"));
 const CloudLogsPanel = lazy(() => import("./CloudLogsPanel"));
 const LapSnapshotsPanel = lazy(() => import("./LapSnapshotsPanel"));
+const LeaderboardSubmitPanel = lazy(() => import("./LeaderboardSubmitPanel"));
 // Profile tab: GDPR self-service — export everything + scheduled account deletion.
 const DataPrivacyPanel = lazy(() => import("./DataPrivacyPanel"));
 
@@ -107,6 +108,17 @@ const plugin: DataViewerPlugin = {
       component: LapSnapshotsPanel,
     } satisfies PluginPanel);
 
+    // Profile tab: submit lap snapshots to the public leaderboards (just below
+    // the snapshots panel, since that's the data it acts on).
+    ctx.registry.contribute(PANELS_POINT, {
+      id: "cloud-sync-leaderboard-submit",
+      title: "panels.leaderboards",
+      slot: PanelSlot.Profile,
+      order: 7,
+      icon: Trophy,
+      component: LeaderboardSubmitPanel,
+    } satisfies PluginPanel);
+
     // Profile tab: manage (delete) the log files stored in the cloud.
     ctx.registry.contribute(PANELS_POINT, {
       id: "cloud-sync-logs",
diff --git a/src/plugins/cloud-sync/leaderboardClient.test.ts b/src/plugins/cloud-sync/leaderboardClient.test.ts
new file mode 100644
index 00000000..4cfa1d6f
--- /dev/null
+++ b/src/plugins/cloud-sync/leaderboardClient.test.ts
@@ -0,0 +1,47 @@
+import { describe, it, expect, vi } from "vitest";
+import type { Course } from "@/types/racing";
+import type { LapSnapshot } from "@/lib/lapSnapshot";
+
+// The real supabase client calls createClient() at import time (needs localStorage,
+// absent in node). Stub it so buildNewEntryRow (a pure helper) is testable.
+vi.mock("@/integrations/supabase/client", () => ({
+  supabase: { from: () => ({}), storage: { from: () => ({}) }, rpc: async () => ({ data: null, error: null }) },
+}));
+
+import { buildNewEntryRow } from "./leaderboardClient";
+
+const course: Course = {
+  name: "Full CW",
+  startFinishA: { lat: 35, lon: -97 },
+  startFinishB: { lat: 35, lon: -97.001 },
+};
+
+function snap(): LapSnapshot {
+  return {
+    id: "s1", trackName: "OKC", courseName: "Full CW", courseKey: "OKCFull CW",
+    engine: "Rotax", engineKey: "rotax", course,
+    lapTimeMs: 55603.51768562128, // fractional — the integer column rejects this raw
+    sourceFileName: "s.dove", sourceLapNumber: 2,
+    samples: [
+      { t: 0, lat: 35, lon: -97, speedMps: 20, speedMph: 44, speedKph: 72, extraFields: {} },
+      { t: 1000, lat: 35.001, lon: -97.001, speedMps: 20, speedMph: 44, speedKph: 72, extraFields: {} },
+    ],
+    lapStartMs: 0, lapEndMs: 1000,
+    vehicle: { id: "v", name: "k", number: 1, weight: 365, weightUnit: "lb" },
+    createdAt: 1, updatedAt: 1,
+  };
+}
+
+describe("buildNewEntryRow", () => {
+  it("rounds lap_time_ms to an integer (the column type)", () => {
+    const row = buildNewEntryRow(snap(), {
+      userId: "u1", engineTelemetryPublic: false,
+      listedWeight: 365, listedWeightUnit: "lb",
+    });
+    expect(row.lap_time_ms).toBe(55604);
+    expect(Number.isInteger(row.lap_time_ms)).toBe(true);
+    // display_name is no longer denormalized onto the row — it's resolved live
+    // from the linked profile at read time.
+    expect(row).not.toHaveProperty("display_name");
+  });
+});
diff --git a/src/plugins/cloud-sync/leaderboardClient.ts b/src/plugins/cloud-sync/leaderboardClient.ts
new file mode 100644
index 00000000..3d761104
--- /dev/null
+++ b/src/plugins/cloud-sync/leaderboardClient.ts
@@ -0,0 +1,262 @@
+// Untyped access to the leaderboard tables (plan 0005). Same pattern as
+// cloudClient.ts: the generated Database type doesn't yet include
+// leaderboard_entries / engine_classes, so route them through an untyped view of
+// the shared client and hand-map rows. Public reads work for anonymous visitors
+// (RLS allows anon select on approved rows + engine classes).
+
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { supabase } from "@/integrations/supabase/client";
+import type { LapSnapshot } from "@/lib/lapSnapshot";
+import type {
+  EngineClass,
+  LeaderboardEntry,
+  LeaderboardEntryData,
+} from "@/lib/leaderboardTypes";
+import { buildEntryData, contentHashForSnapshot } from "./leaderboardSubmission";
+
+/** A snapshot courseKey for a reverse-direction lap ends with the "reverse" marker. */
+function isReverseCourseKey(courseKey: string): boolean {
+  return courseKey.endsWith("reverse");
+}
+
+const untyped = supabase as unknown as SupabaseClient;
+
+export function leaderboardEntriesTable() {
+  return untyped.from("leaderboard_entries");
+}
+export function engineClassesTable() {
+  return untyped.from("engine_classes");
+}
+
+// Columns for the lightweight browse tree (everything except `data`). The display
+// name is embedded LIVE from profiles (FK leaderboard_entries.user_id → profiles),
+// not read from the denormalized column, so a rename propagates everywhere.
+export const LIGHT_COLUMNS =
+  "id,user_id,track_name,course_name,course_key,direction,engine,engine_key,engine_class_id,listed_weight,listed_weight_unit,lap_time_ms,content_hash,engine_telemetry_public,status,created_at,profiles!leaderboard_entries_profile_fkey(display_name)";
+
+/** Embedded profile shape (PostgREST returns the to-one relationship as an object). */
+type EmbeddedProfile = { display_name: string | null } | { display_name: string | null }[] | null;
+
+interface EntryRow {
+  id: string;
+  user_id: string;
+  profiles?: EmbeddedProfile;
+  track_name: string;
+  course_name: string;
+  course_key: string;
+  direction: string | null;
+  engine: string;
+  engine_key: string;
+  engine_class_id: string | null;
+  listed_weight: number | null;
+  listed_weight_unit: "lb" | "kg" | null;
+  lap_time_ms: number;
+  content_hash: string;
+  engine_telemetry_public: boolean;
+  status: "approved" | "denied";
+  created_at: string;
+  class_source?: "auto" | "admin";
+  admin_notes?: string | null;
+  data?: LeaderboardEntryData;
+}
+
+export function mapEntryRow(r: EntryRow): LeaderboardEntry {
+  const prof = Array.isArray(r.profiles) ? r.profiles[0] : r.profiles;
+  return {
+    id: r.id,
+    userId: r.user_id,
+    displayName: prof?.display_name ?? "Unknown",
+    trackName: r.track_name,
+    courseName: r.course_name,
+    courseKey: r.course_key,
+    direction: r.direction,
+    engine: r.engine,
+    engineKey: r.engine_key,
+    engineClassId: r.engine_class_id,
+    listedWeight: r.listed_weight,
+    listedWeightUnit: r.listed_weight_unit,
+    lapTimeMs: r.lap_time_ms,
+    contentHash: r.content_hash,
+    engineTelemetryPublic: r.engine_telemetry_public,
+    status: r.status,
+    createdAt: r.created_at,
+    classSource: r.class_source,
+    adminNotes: r.admin_notes,
+    data: r.data,
+  };
+}
+
+interface EngineClassRow {
+  id: string;
+  name: string;
+  keywords: string[] | null;
+  sort_order: number;
+}
+
+export function mapEngineClassRow(r: EngineClassRow): EngineClass {
+  return { id: r.id, name: r.name, keywords: r.keywords ?? [], sortOrder: r.sort_order };
+}
+
+/** All engine classes (public read), ordered as the admin arranged them. */
+export async function fetchEngineClasses(): Promise<EngineClass[]> {
+  const { data, error } = await engineClassesTable().select("*").order("sort_order");
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as EngineClassRow[]).map(mapEngineClassRow);
+}
+
+/** Lightweight rows (no `data`) for every approved entry — the browse tree. */
+export async function fetchApprovedLight(): Promise<LeaderboardEntry[]> {
+  const { data, error } = await leaderboardEntriesTable()
+    .select(LIGHT_COLUMNS)
+    .eq("status", "approved");
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as EntryRow[]).map(mapEntryRow);
+}
+
+/** Lightweight approved rows for one user — the public driver profile page (anon). */
+export async function fetchApprovedLightByUser(userId: string): Promise<LeaderboardEntry[]> {
+  const { data, error } = await leaderboardEntriesTable()
+    .select(LIGHT_COLUMNS)
+    .eq("status", "approved")
+    .eq("user_id", userId);
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as EntryRow[]).map(mapEntryRow);
+}
+
+/**
+ * Full rows (with `data`) for one engine[/weight] group, fastest first. `limit`
+ * null loads all. Grouping is resolved client-side, so callers pass the already
+ * computed entry ids for the chosen group.
+ */
+export async function fetchGroupEntries(ids: string[], limit: number | null): Promise<LeaderboardEntry[]> {
+  if (ids.length === 0) return [];
+  let q = leaderboardEntriesTable()
+    .select(`${LIGHT_COLUMNS},data`)
+    .in("id", ids)
+    .eq("status", "approved")
+    .order("lap_time_ms", { ascending: true });
+  if (limit !== null) q = q.limit(limit);
+  const { data, error } = await q;
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as EntryRow[]).map(mapEntryRow);
+}
+
+/** The signed-in user's own entries (light) — for the submitted/withdraw list. */
+export async function fetchMyEntries(userId: string): Promise<LeaderboardEntry[]> {
+  const { data, error } = await leaderboardEntriesTable()
+    .select(LIGHT_COLUMNS)
+    .eq("user_id", userId)
+    .order("created_at", { ascending: false });
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as EntryRow[]).map(mapEntryRow);
+}
+
+/** A row to insert into leaderboard_entries (snake_case, server fills defaults). */
+export interface NewEntryRow {
+  user_id: string;
+  track_name: string;
+  course_name: string;
+  course_key: string;
+  direction: string | null;
+  engine: string;
+  engine_key: string;
+  listed_weight: number;
+  listed_weight_unit: "lb" | "kg";
+  lap_time_ms: number;
+  content_hash: string;
+  engine_telemetry_public: boolean;
+  data: LeaderboardEntryData;
+}
+
+export interface SubmitOptions {
+  userId: string;
+  engineTelemetryPublic: boolean;
+  listedWeight: number;
+  listedWeightUnit: "lb" | "kg";
+}
+
+/** Assemble the insert row for a snapshot, applying privacy + content hashing. */
+export function buildNewEntryRow(snap: LapSnapshot, opts: SubmitOptions): NewEntryRow {
+  return {
+    user_id: opts.userId,
+    track_name: snap.trackName,
+    course_name: snap.courseName,
+    course_key: snap.courseKey,
+    direction: isReverseCourseKey(snap.courseKey) ? "reverse" : null,
+    engine: snap.engine,
+    engine_key: snap.engineKey,
+    listed_weight: opts.listedWeight,
+    listed_weight_unit: opts.listedWeightUnit,
+    lap_time_ms: Math.round(snap.lapTimeMs), // integer column; lapTimeMs is fractional
+    content_hash: contentHashForSnapshot(snap),
+    engine_telemetry_public: opts.engineTelemetryPublic,
+    data: buildEntryData(snap, { engineTelemetryPublic: opts.engineTelemetryPublic }),
+  };
+}
+
+export async function insertEntries(rows: NewEntryRow[]): Promise<void> {
+  const { error } = await leaderboardEntriesTable().insert(rows);
+  if (error) throw new Error(error.message);
+}
+
+export async function withdrawEntry(id: string): Promise<void> {
+  const { error } = await leaderboardEntriesTable().delete().eq("id", id);
+  if (error) throw new Error(error.message);
+}
+
+// ── Admin ────────────────────────────────────────────────────────────────────
+const ADMIN_COLUMNS = `${LIGHT_COLUMNS},class_source,admin_notes`;
+
+/** Every entry (any status) for the admin moderation table. Admin RLS gates this. */
+export async function fetchAllEntriesAdmin(): Promise<LeaderboardEntry[]> {
+  const { data, error } = await leaderboardEntriesTable()
+    .select(ADMIN_COLUMNS)
+    .order("created_at", { ascending: false });
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as EntryRow[]).map(mapEntryRow);
+}
+
+export interface AdminEntryPatch {
+  status?: "approved" | "denied";
+  /** Setting/clearing a class also pins class_source so reclassify skips it. */
+  engineClassId?: string | null;
+  adminNotes?: string | null;
+}
+
+export async function updateEntryAdmin(id: string, patch: AdminEntryPatch): Promise<void> {
+  const row: Record<string, unknown> = { reviewed_at: new Date().toISOString() };
+  if (patch.status !== undefined) row.status = patch.status;
+  if (patch.adminNotes !== undefined) row.admin_notes = patch.adminNotes;
+  if (patch.engineClassId !== undefined) {
+    row.engine_class_id = patch.engineClassId;
+    row.class_source = "admin"; // manual assignment is protected from reclassify
+  }
+  const { error } = await leaderboardEntriesTable().update(row).eq("id", id);
+  if (error) throw new Error(error.message);
+}
+
+export async function createEngineClass(name: string, keywords: string[], sortOrder: number): Promise<void> {
+  const { error } = await engineClassesTable().insert({ name, keywords, sort_order: sortOrder });
+  if (error) throw new Error(error.message);
+}
+
+export async function updateEngineClass(id: string, patch: { name?: string; keywords?: string[]; sortOrder?: number }): Promise<void> {
+  const row: Record<string, unknown> = { updated_at: new Date().toISOString() };
+  if (patch.name !== undefined) row.name = patch.name;
+  if (patch.keywords !== undefined) row.keywords = patch.keywords;
+  if (patch.sortOrder !== undefined) row.sort_order = patch.sortOrder;
+  const { error } = await engineClassesTable().update(row).eq("id", id);
+  if (error) throw new Error(error.message);
+}
+
+export async function deleteEngineClass(id: string): Promise<void> {
+  const { error } = await engineClassesTable().delete().eq("id", id);
+  if (error) throw new Error(error.message);
+}
+
+/** Re-run auto classification across non-admin-pinned rows; returns rows changed. */
+export async function reclassifyEntries(): Promise<number> {
+  const { data, error } = await untyped.rpc("reclassify_entries");
+  if (error) throw new Error(error.message);
+  return (data as number) ?? 0;
+}
diff --git a/src/plugins/cloud-sync/leaderboardSubmission.test.ts b/src/plugins/cloud-sync/leaderboardSubmission.test.ts
new file mode 100644
index 00000000..6438d6c1
--- /dev/null
+++ b/src/plugins/cloud-sync/leaderboardSubmission.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import type { Course, GpsSample } from "@/types/racing";
+import type { LapSnapshot } from "@/lib/lapSnapshot";
+import {
+  buildEntryData,
+  contentHashForSnapshot,
+  defaultListedWeight,
+  isValidListedWeight,
+} from "./leaderboardSubmission";
+
+const course: Course = {
+  name: "Full CW",
+  startFinishA: { lat: 35.0, lon: -97.0 },
+  startFinishB: { lat: 35.0, lon: -97.001 },
+};
+
+function sample(t: number, extra: Record<string, number>): GpsSample {
+  return { t, lat: 35 + t * 1e-6, lon: -97 + t * 1e-6, speedMps: 20, speedMph: 44, speedKph: 72, extraFields: extra };
+}
+
+function snap(overrides: Partial<LapSnapshot> = {}): LapSnapshot {
+  const samples = [
+    sample(0, { rpm: 11000, lat_g: 0.5 }),
+    sample(1000, { rpm: 12000, lat_g: 0.8 }),
+    sample(2000, { rpm: 11500, lat_g: 0.2 }),
+  ];
+  return {
+    id: "snap-1",
+    trackName: "OKC",
+    courseName: "Full CW",
+    courseKey: "OKCFull CW",
+    engine: "Rotax",
+    engineKey: "rotax",
+    course,
+    lapTimeMs: 62000,
+    sourceFileName: "s.dove",
+    sourceLapNumber: 3,
+    recordedAt: 1700000000000,
+    samples,
+    lapStartMs: 0,
+    lapEndMs: 2000,
+    vehicle: { id: "v1", name: "Kart", number: 7, weight: 365, weightUnit: "lb" },
+    setup: { id: "setup-1" } as LapSnapshot["setup"],
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  };
+}
+
+describe("contentHashForSnapshot", () => {
+  it("is stable for identical snapshots and varies with lap time", () => {
+    expect(contentHashForSnapshot(snap())).toBe(contentHashForSnapshot(snap()));
+    expect(contentHashForSnapshot(snap())).not.toBe(contentHashForSnapshot(snap({ lapTimeMs: 61000 })));
+  });
+});
+
+describe("buildEntryData privacy", () => {
+  it("never includes setup data", () => {
+    expect("setup" in buildEntryData(snap(), { engineTelemetryPublic: false })).toBe(false);
+    expect("setup" in buildEntryData(snap(), { engineTelemetryPublic: true })).toBe(false);
+  });
+
+  it("strips engine-telemetry channels by default", () => {
+    const data = buildEntryData(snap(), { engineTelemetryPublic: false });
+    for (const s of data.samples) {
+      expect(s.extraFields.rpm).toBeUndefined();
+      expect(s.extraFields.lat_g).toBeDefined(); // non-engine channel kept
+    }
+    expect(data.fieldMappings.map((f) => f.name)).toContain("lat_g");
+    expect(data.fieldMappings.map((f) => f.name)).not.toContain("rpm");
+  });
+
+  it("keeps engine telemetry when shared", () => {
+    const data = buildEntryData(snap(), { engineTelemetryPublic: true });
+    expect(data.samples[0].extraFields.rpm).toBe(11000);
+    expect(data.fieldMappings.map((f) => f.name)).toContain("rpm");
+  });
+});
+
+describe("listed weight", () => {
+  it("defaults to the vehicle weight when present", () => {
+    expect(defaultListedWeight(snap())).toEqual({ weight: 365, unit: "lb" });
+  });
+  it("is null when the vehicle has no weight", () => {
+    expect(defaultListedWeight(snap({ vehicle: { id: "v", name: "k", number: 1 } })).weight).toBeNull();
+  });
+  it("validates positive numbers only", () => {
+    expect(isValidListedWeight(365)).toBe(true);
+    expect(isValidListedWeight(0)).toBe(false);
+    expect(isValidListedWeight(null)).toBe(false);
+  });
+});
diff --git a/src/plugins/cloud-sync/leaderboardSubmission.ts b/src/plugins/cloud-sync/leaderboardSubmission.ts
new file mode 100644
index 00000000..4ba554f6
--- /dev/null
+++ b/src/plugins/cloud-sync/leaderboardSubmission.ts
@@ -0,0 +1,91 @@
+// Pure leaderboard-submission logic (plan 0005): content hashing + payload
+// building (privacy stripping). No Supabase / React here so it stays unit-testable;
+// the client (leaderboardClient.ts) and panel wire it to the network + UI.
+
+import type { GpsSample } from "@/types/racing";
+import { fnv1a } from "@/lib/fnv1a";
+import { snapshotLapSamples, type LapSnapshot } from "@/lib/lapSnapshot";
+import { ENGINE_TELEMETRY_CHANNELS, type LeaderboardEntryData } from "@/lib/leaderboardTypes";
+
+/**
+ * Stable content hash of a snapshot's immutable identity, used as the per-user
+ * anti-resubmit key (mirrors the DB `unique (user_id, content_hash)`). Built from
+ * fields that never change for a given captured lap — lap time, recording time,
+ * course key, sample count, and the first/last coordinates.
+ */
+export function contentHashForSnapshot(snap: LapSnapshot): string {
+  const clean = snapshotLapSamples(snap);
+  const first = clean[0];
+  const last = clean[clean.length - 1];
+  const coord = (s: GpsSample | undefined): string =>
+    s ? `${s.lat.toFixed(6)},${s.lon.toFixed(6)}` : "";
+  return fnv1a(
+    [
+      snap.courseKey,
+      snap.lapTimeMs,
+      snap.recordedAt ?? 0,
+      clean.length,
+      coord(first),
+      coord(last),
+    ].join("|"),
+  );
+}
+
+export interface BuildEntryOptions {
+  engineTelemetryPublic: boolean;
+}
+
+/**
+ * Build the frozen `data` payload for a leaderboard entry, applying privacy:
+ * engine-telemetry channels are stripped from both the samples' `extraFields` and
+ * the `fieldMappings` unless shared. Setup data is never included. GPS, speed, and
+ * everything else stay. Always trims to the clean lap (no buffer).
+ */
+export function buildEntryData(snap: LapSnapshot, opts: BuildEntryOptions): LeaderboardEntryData {
+  const clean = snapshotLapSamples(snap);
+  const stripTelemetry = !opts.engineTelemetryPublic;
+
+  const samples: GpsSample[] = clean.map((s) => {
+    if (!stripTelemetry) return { ...s };
+    const extraFields: Record<string, number> = {};
+    for (const [k, v] of Object.entries(s.extraFields)) {
+      if (!ENGINE_TELEMETRY_CHANNELS.has(k)) extraFields[k] = v;
+    }
+    return { ...s, extraFields };
+  });
+
+  // The snapshot doesn't carry its own fieldMappings; derive the channel list from
+  // the surviving extraFields keys (union across samples). Engine telemetry is
+  // already excluded above when not shared.
+  const channelNames = new Set<string>();
+  for (const s of samples) {
+    for (const k of Object.keys(s.extraFields)) channelNames.add(k);
+  }
+  const fieldMappings = Array.from(channelNames).map((name, index) => ({
+    index,
+    name,
+    enabled: true,
+  }));
+
+  return {
+    samples,
+    fieldMappings,
+    course: snap.course,
+    lapStartMs: snap.lapStartMs,
+    lapEndMs: snap.lapEndMs,
+  };
+}
+
+/** Resolve the default listed weight for a snapshot (the vehicle weight, if any). */
+export function defaultListedWeight(snap: LapSnapshot): { weight: number | null; unit: "lb" | "kg" } {
+  const w = snap.vehicle?.weight;
+  return {
+    weight: typeof w === "number" && w > 0 ? w : null,
+    unit: snap.vehicle?.weightUnit ?? "lb",
+  };
+}
+
+/** A listed weight is valid for submission when it's a positive number. */
+export function isValidListedWeight(weight: number | null | undefined): weight is number {
+  return typeof weight === "number" && Number.isFinite(weight) && weight > 0;
+}
diff --git a/src/plugins/cloud-sync/profile.test.ts b/src/plugins/cloud-sync/profile.test.ts
index fd11993f..bb9b3202 100644
--- a/src/plugins/cloud-sync/profile.test.ts
+++ b/src/plugins/cloud-sync/profile.test.ts
@@ -26,12 +26,17 @@ vi.mock("./cloudClient", () => {
   };
   return {
     profiles: () => builder,
+    userAvatars: () => ({
+      getPublicUrl: (path: string) => ({
+        data: { publicUrl: `https://cdn.test/user-avatars/${path}` },
+      }),
+    }),
     isUniqueViolation: (err: unknown) =>
       typeof err === "object" && err !== null && (err as { code?: string }).code === "23505",
   };
 });
 
-import { getMyProfile, updateDisplayName } from "./profile";
+import { avatarPublicUrl, getMyProfile, updateDisplayName } from "./profile";
 
 beforeEach(() => {
   state.read = { data: null, error: null };
@@ -56,6 +61,29 @@ describe("getMyProfile", () => {
   });
 });
 
+describe("avatarPublicUrl", () => {
+  it("returns null when no avatar path is set", () => {
+    expect(avatarPublicUrl(null)).toBeNull();
+    expect(avatarPublicUrl({ avatar_path: null, avatar_updated_at: null })).toBeNull();
+  });
+
+  it("builds a public URL with a ?v= cache-buster from avatar_updated_at", () => {
+    const url = avatarPublicUrl({
+      avatar_path: "u1/avatar.webp",
+      avatar_updated_at: "2026-06-27T00:00:00.000Z",
+    });
+    expect(url).toBe(
+      `https://cdn.test/user-avatars/u1/avatar.webp?v=${Date.parse("2026-06-27T00:00:00.000Z")}`,
+    );
+  });
+
+  it("omits the cache-buster when there is no timestamp", () => {
+    expect(avatarPublicUrl({ avatar_path: "u1/avatar.jpg", avatar_updated_at: null })).toBe(
+      "https://cdn.test/user-avatars/u1/avatar.jpg",
+    );
+  });
+});
+
 describe("updateDisplayName", () => {
   it("rejects an empty / whitespace-only name without hitting the DB", async () => {
     expect(await updateDisplayName("u1", "   ")).toEqual({ ok: false, reason: "empty" });
diff --git a/src/plugins/cloud-sync/profile.ts b/src/plugins/cloud-sync/profile.ts
index 953f7050..34896147 100644
--- a/src/plugins/cloud-sync/profile.ts
+++ b/src/plugins/cloud-sync/profile.ts
@@ -3,18 +3,62 @@
 // while an explicit edit surfaces a "taken" result so the user can pick another.
 
 import { containsProfanity } from "@/lib/profanity";
-import { isUniqueViolation, profiles, type ProfileRow } from "./cloudClient";
+import { isUniqueViolation, profiles, userAvatars, type ProfileRow } from "./cloudClient";
 
 /** The signed-in user's profile, or null if it doesn't exist yet. */
 export async function getMyProfile(userId: string): Promise<ProfileRow | null> {
   const { data, error } = await profiles()
-    .select("user_id,display_name")
+    .select("user_id,display_name,avatar_path,avatar_updated_at")
     .eq("user_id", userId)
     .maybeSingle();
   if (error) throw new Error(error.message);
   return (data as ProfileRow | null) ?? null;
 }
 
+/**
+ * Public URL for a profile's avatar, with a ?v= cache-buster derived from
+ * avatar_updated_at (the object path is fixed, so a replaced avatar would
+ * otherwise serve the stale cached image). Null when no avatar is set.
+ */
+export function avatarPublicUrl(
+  p: Pick<ProfileRow, "avatar_path" | "avatar_updated_at"> | null | undefined,
+): string | null {
+  if (!p?.avatar_path) return null;
+  const { data } = userAvatars().getPublicUrl(p.avatar_path);
+  if (!data?.publicUrl) return null;
+  const v = p.avatar_updated_at ? Date.parse(p.avatar_updated_at) : 0;
+  return v ? `${data.publicUrl}?v=${v}` : data.publicUrl;
+}
+
+/** Extension for the stored avatar object, derived from the (already-cropped) blob type. */
+function avatarExt(type: string): string {
+  return type.includes("webp") ? "webp" : "jpg";
+}
+
+/**
+ * Upload a cropped avatar blob to the public bucket at a fixed per-user path and
+ * record the new path + timestamp on the profile. Returns the stored fields so
+ * the caller can repaint immediately via the cache-buster.
+ */
+export async function uploadAvatar(
+  userId: string,
+  blob: Blob,
+): Promise<{ avatar_path: string; avatar_updated_at: string }> {
+  const path = `${userId}/avatar.${avatarExt(blob.type)}`;
+  const up = await userAvatars().upload(path, blob, {
+    upsert: true,
+    contentType: blob.type || "image/jpeg",
+  });
+  if (up.error) throw new Error(up.error.message);
+
+  const now = new Date().toISOString();
+  const { error } = await profiles()
+    .update({ avatar_path: path, avatar_updated_at: now })
+    .eq("user_id", userId);
+  if (error) throw new Error(error.message);
+  return { avatar_path: path, avatar_updated_at: now };
+}
+
 export type UpdateNameResult =
   | { ok: true }
   | { ok: false; reason: "taken" | "empty" | "profanity" | "error"; message?: string };
diff --git a/src/plugins/cloud-sync/publicProfile.test.ts b/src/plugins/cloud-sync/publicProfile.test.ts
new file mode 100644
index 00000000..47cf70c5
--- /dev/null
+++ b/src/plugins/cloud-sync/publicProfile.test.ts
@@ -0,0 +1,38 @@
+import { describe, it, expect, vi } from "vitest";
+
+// escapeLike is pure, but importing the module pulls in ./profile → ./cloudClient
+// (which would instantiate the supabase client). Stub cloudClient so the import
+// graph stays side-effect-free; we only exercise the pure escaping helper here.
+vi.mock("./cloudClient", () => ({
+  publicProfilesView: () => ({}),
+  publicVehicles: () => ({}),
+  userAvatars: () => ({}),
+}));
+
+import { escapeLike } from "./publicProfile";
+
+describe("escapeLike", () => {
+  it("passes a plain name through unchanged", () => {
+    expect(escapeLike("Ayrton Senna")).toBe("Ayrton Senna");
+  });
+
+  it("escapes an underscore so it isn't an ilike single-char wildcard", () => {
+    expect(escapeLike("a_b")).toBe("a\\_b");
+  });
+
+  it("escapes a percent so it isn't an ilike multi-char wildcard", () => {
+    expect(escapeLike("50%")).toBe("50\\%");
+  });
+
+  it("escapes a literal backslash", () => {
+    expect(escapeLike("a\\b")).toBe("a\\\\b");
+  });
+
+  it("escapes every wildcard in a mixed name", () => {
+    expect(escapeLike("_100%\\done_")).toBe("\\_100\\%\\\\done\\_");
+  });
+
+  it("leaves the empty string empty", () => {
+    expect(escapeLike("")).toBe("");
+  });
+});
diff --git a/src/plugins/cloud-sync/publicProfile.ts b/src/plugins/cloud-sync/publicProfile.ts
new file mode 100644
index 00000000..38291eea
--- /dev/null
+++ b/src/plugins/cloud-sync/publicProfile.ts
@@ -0,0 +1,82 @@
+// Anonymous, public reads for the driver profile page (/driver/:username) and
+// the Leaderboards avatar thumbnails. Kept separate from profile.ts (owner-only
+// reads/writes): everything here goes through the column-limited public_profiles
+// view and the public_vehicles projection, both anon-readable by RLS. Names are
+// matched case-insensitively so a profile resolves regardless of URL casing.
+
+import {
+  avatarPublicUrl,
+} from "./profile";
+import {
+  publicProfilesView,
+  publicVehicles,
+  type PublicProfileRow,
+  type PublicVehicleRow,
+} from "./cloudClient";
+
+export interface PublicProfile {
+  userId: string;
+  displayName: string;
+  avatarUrl: string | null;
+}
+
+export interface PublicVehicle {
+  vehicleId: string;
+  name: string;
+  typeName: string | null;
+  engine: string;
+  number: number;
+}
+
+/** Escape PostgREST ilike wildcards so a name is matched literally (not as a pattern). */
+export function escapeLike(value: string): string {
+  return value.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+}
+
+function toPublicProfile(row: PublicProfileRow): PublicProfile {
+  return {
+    userId: row.user_id,
+    displayName: row.display_name,
+    avatarUrl: avatarPublicUrl(row),
+  };
+}
+
+/** Resolve a display name (case-insensitive, exact) to its public profile, or null. */
+export async function fetchPublicProfileByName(name: string): Promise<PublicProfile | null> {
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  const { data, error } = await publicProfilesView()
+    .select("user_id,display_name,avatar_path,avatar_updated_at")
+    .ilike("display_name", escapeLike(trimmed))
+    .maybeSingle();
+  if (error) throw new Error(error.message);
+  return data ? toPublicProfile(data as PublicProfileRow) : null;
+}
+
+/** The user's opt-in, public-safe vehicles (no weight, no setup), number-ordered. */
+export async function fetchPublicVehicles(userId: string): Promise<PublicVehicle[]> {
+  const { data, error } = await publicVehicles()
+    .select("vehicle_id,name,type_name,engine,number")
+    .eq("user_id", userId)
+    .order("number", { ascending: true });
+  if (error) throw new Error(error.message);
+  return ((data ?? []) as PublicVehicleRow[]).map((r) => ({
+    vehicleId: r.vehicle_id,
+    name: r.name,
+    typeName: r.type_name,
+    engine: r.engine,
+    number: r.number,
+  }));
+}
+
+/** All public profiles keyed by user id — one query, used for leaderboard avatar thumbnails. */
+export async function fetchAllPublicProfiles(): Promise<Map<string, PublicProfile>> {
+  const { data, error } = await publicProfilesView()
+    .select("user_id,display_name,avatar_path,avatar_updated_at");
+  if (error) throw new Error(error.message);
+  const map = new Map<string, PublicProfile>();
+  for (const row of (data ?? []) as PublicProfileRow[]) {
+    map.set(row.user_id, toPublicProfile(row));
+  }
+  return map;
+}
diff --git a/src/plugins/cloud-sync/publicVehicleSync.test.ts b/src/plugins/cloud-sync/publicVehicleSync.test.ts
new file mode 100644
index 00000000..8703bcaa
--- /dev/null
+++ b/src/plugins/cloud-sync/publicVehicleSync.test.ts
@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import type { Vehicle } from "@/lib/vehicleStorage";
+
+// Capture the calls the projection makes against the public_vehicles builder.
+const { state } = vi.hoisted(() => ({
+  state: {
+    vehicle: null as Vehicle | null,
+    typeName: "Shifter Kart" as string | null,
+    upsertArg: undefined as Record<string, unknown> | undefined,
+    deleted: [] as Array<Record<string, string>>,
+  },
+}));
+
+vi.mock("@/lib/vehicleStorage", () => ({
+  getVehicle: async () => state.vehicle,
+}));
+vi.mock("@/lib/templateStorage", () => ({
+  getVehicleType: async () => (state.typeName === null ? null : { id: "vt1", name: state.typeName }),
+}));
+vi.mock("./cloudClient", () => {
+  const deleteBuilder = {
+    _eqs: {} as Record<string, string>,
+    eq(col: string, val: string) {
+      this._eqs[col] = val;
+      return this;
+    },
+    then(onFulfilled: (v: unknown) => unknown) {
+      state.deleted.push({ ...this._eqs });
+      return onFulfilled({ error: null });
+    },
+  };
+  return {
+    publicVehicles: () => ({
+      upsert: (arg: Record<string, unknown>) => {
+        state.upsertArg = arg;
+        return Promise.resolve({ error: null });
+      },
+      delete: () => {
+        deleteBuilder._eqs = {};
+        return deleteBuilder;
+      },
+    }),
+  };
+});
+
+import { syncPublicVehicle } from "./publicVehicleSync";
+
+const baseVehicle: Vehicle = {
+  id: "v1",
+  name: "Kart 7",
+  vehicleTypeId: "vt1",
+  engine: "IAME X30",
+  number: 7,
+  weight: 165,
+  weightUnit: "lb",
+  publicProfile: true,
+};
+
+beforeEach(() => {
+  state.vehicle = { ...baseVehicle };
+  state.typeName = "Shifter Kart";
+  state.upsertArg = undefined;
+  state.deleted = [];
+});
+
+describe("syncPublicVehicle", () => {
+  it("upserts only public-safe columns for a flagged vehicle (never weight)", async () => {
+    await syncPublicVehicle("u1", { store: "karts", key: "v1", type: "put" });
+    expect(state.upsertArg).toMatchObject({
+      user_id: "u1",
+      vehicle_id: "v1",
+      name: "Kart 7",
+      type_name: "Shifter Kart",
+      engine: "IAME X30",
+      number: 7,
+    });
+    expect(state.upsertArg).not.toHaveProperty("weight");
+    expect(state.upsertArg).not.toHaveProperty("weightUnit");
+    expect(state.deleted).toHaveLength(0);
+  });
+
+  it("deletes the public row when the vehicle is not flagged", async () => {
+    state.vehicle = { ...baseVehicle, publicProfile: false };
+    await syncPublicVehicle("u1", { store: "karts", key: "v1", type: "put" });
+    expect(state.upsertArg).toBeUndefined();
+    expect(state.deleted).toEqual([{ user_id: "u1", vehicle_id: "v1" }]);
+  });
+
+  it("deletes the public row when the vehicle no longer exists", async () => {
+    state.vehicle = null;
+    await syncPublicVehicle("u1", { store: "karts", key: "v1", type: "put" });
+    expect(state.upsertArg).toBeUndefined();
+    expect(state.deleted).toEqual([{ user_id: "u1", vehicle_id: "v1" }]);
+  });
+
+  it("deletes the public row on a vehicle delete", async () => {
+    await syncPublicVehicle("u1", { store: "karts", key: "v1", type: "delete" });
+    expect(state.upsertArg).toBeUndefined();
+    expect(state.deleted).toEqual([{ user_id: "u1", vehicle_id: "v1" }]);
+  });
+
+  it("tolerates a missing vehicle type (null type_name)", async () => {
+    state.typeName = null;
+    await syncPublicVehicle("u1", { store: "karts", key: "v1", type: "put" });
+    expect(state.upsertArg).toMatchObject({ type_name: null });
+  });
+});
diff --git a/src/plugins/cloud-sync/publicVehicleSync.ts b/src/plugins/cloud-sync/publicVehicleSync.ts
new file mode 100644
index 00000000..6b8b68e8
--- /dev/null
+++ b/src/plugins/cloud-sync/publicVehicleSync.ts
@@ -0,0 +1,51 @@
+// Projects a user's opt-in vehicles to the public_vehicles table (plan 0006).
+//
+// Vehicles back up privately to sync_records like every garage record; this is a
+// SECOND, public-safe projection driven off the same garage-change event. Only
+// vehicles flagged `publicProfile` are published, and only public-safe columns
+// (name/type/engine/number) — never weight or any setup. Unflagging or deleting
+// a vehicle removes its public row. Best-effort: a failed projection is logged,
+// not retried (it self-heals on the next vehicle edit), so it never blocks the
+// authoritative private backup.
+
+import type { GarageChange } from "@/lib/garageEvents";
+import { getVehicle } from "@/lib/vehicleStorage";
+import { getVehicleType } from "@/lib/templateStorage";
+import { publicVehicles } from "./cloudClient";
+
+async function removePublicVehicle(userId: string, vehicleId: string): Promise<void> {
+  const { error } = await publicVehicles()
+    .delete()
+    .eq("user_id", userId)
+    .eq("vehicle_id", vehicleId);
+  if (error) throw new Error(error.message);
+}
+
+/** Mirror one garage vehicle change into the public projection (best-effort). */
+export async function syncPublicVehicle(userId: string, change: GarageChange): Promise<void> {
+  try {
+    if (change.type === "delete") {
+      await removePublicVehicle(userId, change.key);
+      return;
+    }
+    const vehicle = await getVehicle(change.key);
+    // Gone, or opted out → ensure no public row lingers.
+    if (!vehicle || !vehicle.publicProfile) {
+      await removePublicVehicle(userId, change.key);
+      return;
+    }
+    const type = vehicle.vehicleTypeId ? await getVehicleType(vehicle.vehicleTypeId) : null;
+    const { error } = await publicVehicles().upsert({
+      user_id: userId,
+      vehicle_id: vehicle.id,
+      name: vehicle.name,
+      type_name: type?.name ?? null,
+      engine: vehicle.engine,
+      number: vehicle.number,
+      updated_at: new Date().toISOString(),
+    });
+    if (error) throw new Error(error.message);
+  } catch (err) {
+    console.error("public vehicle projection failed", err);
+  }
+}
diff --git a/src/plugins/cloud-sync/trackAutoSubmit.test.ts b/src/plugins/cloud-sync/trackAutoSubmit.test.ts
new file mode 100644
index 00000000..1cda8876
--- /dev/null
+++ b/src/plugins/cloud-sync/trackAutoSubmit.test.ts
@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import type { LapSnapshot } from "@/lib/lapSnapshot";
+
+// Drive the orchestration branches of autoSubmitSnapshotTrack by faking its
+// dynamically-imported collaborators. buildCourseSubmission's own geometry is
+// covered in trackSubmission.test.ts; here we only assert the skip/dedupe/invoke
+// decisions that gate whether the submit-track edge call fires.
+const { state } = vi.hoisted(() => ({
+  state: {
+    submission: null as Record<string, unknown> | null,
+    submittedRecords: {} as Record<string, { hash: string }>,
+    invokeResult: { data: { batch_id: "b1" } as { batch_id: string } | null, error: null as unknown },
+    invokeCalls: [] as unknown[],
+    marked: [] as unknown[],
+  },
+}));
+
+vi.mock("@/lib/trackStorage", () => ({
+  loadDefaultTracks: async () => [],
+}));
+vi.mock("@/lib/trackSubmission", () => ({
+  buildCourseSubmission: () => state.submission,
+}));
+vi.mock("@/lib/submittedTracksStorage", () => ({
+  loadSubmittedRecords: () => state.submittedRecords,
+  markCoursesSubmitted: (subs: unknown, batchId: unknown) => {
+    state.marked.push({ subs, batchId });
+  },
+}));
+vi.mock("@/integrations/supabase/client", () => ({
+  supabase: {
+    functions: {
+      invoke: (name: string, opts: unknown) => {
+        state.invokeCalls.push({ name, opts });
+        return Promise.resolve(state.invokeResult);
+      },
+    },
+  },
+}));
+
+import { autoSubmitSnapshotTrack } from "./trackAutoSubmit";
+
+const sub = {
+  key: "MyTrack|MyCourse",
+  type: "new_track" as const,
+  trackName: "MyTrack",
+  trackShortName: "MYT",
+  courseName: "MyCourse",
+  courseData: { foo: 1 },
+  layout: [{ lat: 1, lon: 2 }],
+  contentHash: "hash-1",
+};
+
+function snapshot(overrides: Partial<LapSnapshot> = {}): LapSnapshot {
+  return {
+    trackName: "MyTrack",
+    courseName: "MyCourse",
+    course: { isUserDefined: true } as LapSnapshot["course"],
+    ...overrides,
+  } as LapSnapshot;
+}
+
+beforeEach(() => {
+  state.submission = sub;
+  state.submittedRecords = {};
+  state.invokeResult = { data: { batch_id: "b1" }, error: null };
+  state.invokeCalls = [];
+  state.marked = [];
+});
+
+describe("autoSubmitSnapshotTrack", () => {
+  it("skips a course that isn't user-defined (no invoke)", async () => {
+    const result = await autoSubmitSnapshotTrack(snapshot({ course: { isUserDefined: false } as LapSnapshot["course"] }));
+    expect(result).toBe(false);
+    expect(state.invokeCalls).toHaveLength(0);
+  });
+
+  it("skips when buildCourseSubmission returns null (matches a built-in)", async () => {
+    state.submission = null;
+    const result = await autoSubmitSnapshotTrack(snapshot());
+    expect(result).toBe(false);
+    expect(state.invokeCalls).toHaveLength(0);
+  });
+
+  it("skips when this exact content was already submitted (dedupe)", async () => {
+    state.submittedRecords = { [sub.key]: { hash: sub.contentHash } };
+    const result = await autoSubmitSnapshotTrack(snapshot());
+    expect(result).toBe(false);
+    expect(state.invokeCalls).toHaveLength(0);
+  });
+
+  it("submits a new course once and records it", async () => {
+    const result = await autoSubmitSnapshotTrack(snapshot());
+    expect(result).toBe(true);
+    expect(state.invokeCalls).toHaveLength(1);
+    expect(state.invokeCalls[0]).toMatchObject({ name: "submit-track" });
+    expect(state.marked).toEqual([{ subs: [sub], batchId: "b1" }]);
+  });
+
+  it("re-submits when the content hash changed (different revision)", async () => {
+    state.submittedRecords = { [sub.key]: { hash: "stale-hash" } };
+    const result = await autoSubmitSnapshotTrack(snapshot());
+    expect(result).toBe(true);
+    expect(state.invokeCalls).toHaveLength(1);
+  });
+
+  it("propagates an edge-function error", async () => {
+    state.invokeResult = { data: null, error: new Error("boom") };
+    await expect(autoSubmitSnapshotTrack(snapshot())).rejects.toThrow("boom");
+    expect(state.marked).toHaveLength(0);
+  });
+});
diff --git a/src/plugins/cloud-sync/trackAutoSubmit.ts b/src/plugins/cloud-sync/trackAutoSubmit.ts
new file mode 100644
index 00000000..b963526e
--- /dev/null
+++ b/src/plugins/cloud-sync/trackAutoSubmit.ts
@@ -0,0 +1,50 @@
+// Auto-submit a snapshot's custom track to the community track database.
+//
+// When a leaderboard snapshot is for a track that isn't in the built-in list, we
+// also push that course to the `submissions` review queue via the same submit-track
+// edge function the manual SubmitTrackDialog uses — so the community DB gathers the
+// geometry of tracks people are actually posting laps on (the snapshot already
+// carries the full course in its `data`). Best-effort: a failure here must never
+// block the snapshot submission. The signed-in user's JWT is attached, which skips
+// the CAPTCHA and attributes the submission; already-contributed courses are skipped
+// via the local submitted-records dedupe.
+
+import type { LapSnapshot } from "@/lib/lapSnapshot";
+
+/** Returns true when a track submission was actually sent (false = nothing to add). */
+export async function autoSubmitSnapshotTrack(snap: LapSnapshot): Promise<boolean> {
+  if (!snap.course?.isUserDefined) return false;
+
+  const [{ loadDefaultTracks }, { buildCourseSubmission }, { loadSubmittedRecords, markCoursesSubmitted }] =
+    await Promise.all([
+      import("@/lib/trackStorage"),
+      import("@/lib/trackSubmission"),
+      import("@/lib/submittedTracksStorage"),
+    ]);
+
+  const defaults = await loadDefaultTracks();
+  const sub = buildCourseSubmission(snap.trackName, snap.courseName, snap.course, defaults);
+  if (!sub) return false; // identical to a built-in course — nothing to add
+
+  // Skip if this exact content was already contributed.
+  if (loadSubmittedRecords()[sub.key]?.hash === sub.contentHash) return false;
+
+  const { supabase } = await import("@/integrations/supabase/client");
+  const { data, error } = await supabase.functions.invoke("submit-track", {
+    body: {
+      submissions: [{
+        type: sub.type,
+        track_name: sub.trackName,
+        track_short_name: sub.type === "new_track" ? sub.trackShortName : undefined,
+        course_name: sub.courseName,
+        course_data: sub.courseData,
+        layout_data: sub.layout,
+      }],
+    },
+  });
+  if (error) throw error;
+
+  const batchId = (data as { batch_id?: string } | null)?.batch_id ?? `local-${Date.now()}`;
+  markCoursesSubmitted([sub], batchId);
+  return true;
+}
diff --git a/src/types/i18next.d.ts b/src/types/i18next.d.ts
index bd4b69a4..e52bbbb5 100644
--- a/src/types/i18next.d.ts
+++ b/src/types/i18next.d.ts
@@ -18,6 +18,8 @@ import type plugins from "@/locales/en/plugins.json";
 import type auth from "@/locales/en/auth.json";
 import type admin from "@/locales/en/admin.json";
 import type logger from "@/locales/en/logger.json";
+import type leaderboard from "@/locales/en/leaderboard.json";
+import type driver from "@/locales/en/driver.json";
 
 declare module "i18next" {
   interface CustomTypeOptions {
@@ -35,6 +37,8 @@ declare module "i18next" {
       auth: typeof auth;
       admin: typeof admin;
       logger: typeof logger;
+      leaderboard: typeof leaderboard;
+      driver: typeof driver;
     };
   }
 }
diff --git a/supabase/functions/process-account-deletions/index.ts b/supabase/functions/process-account-deletions/index.ts
index f2a709ca..c6cd784c 100644
--- a/supabase/functions/process-account-deletions/index.ts
+++ b/supabase/functions/process-account-deletions/index.ts
@@ -11,15 +11,20 @@ const corsHeaders = {
 };
 
 const SYNC_BUCKET = 'user-files';
+const AVATAR_BUCKET = 'user-avatars';
 
 const json = (body: unknown, status = 200) =>
   new Response(JSON.stringify(body), {
     status, headers: { ...corsHeaders, 'Content-Type': 'application/json' },
   });
 
-/** Remove every object under `${userId}/` in the private user-files bucket. */
-async function removeUserFiles(admin: ReturnType<typeof createClient>, userId: string): Promise<void> {
-  const bucket = admin.storage.from(SYNC_BUCKET);
+/** Remove every object under `${userId}/` in a flat ({userId}/{name}) bucket. */
+async function removeUserObjects(
+  admin: ReturnType<typeof createClient>,
+  bucketId: string,
+  userId: string,
+): Promise<void> {
+  const bucket = admin.storage.from(bucketId);
   // List in pages; the folder is flat ({userId}/{filename}), so one level is enough.
   for (;;) {
     const { data: objects, error } = await bucket.list(userId, { limit: 1000 });
@@ -70,8 +75,11 @@ Deno.serve(async (req) => {
         // harmful than losing files before the account is confirmed deleted. The
         // user is no longer in due_account_deletions, so log loudly for manual
         // sweeping rather than failing the (successful) deletion.
+        // Avatars live in a separate public bucket; public_vehicles rows cascade
+        // via FK, but Storage objects are never FK-cascaded, so wipe both folders.
         try {
-          await removeUserFiles(admin, userId);
+          await removeUserObjects(admin, SYNC_BUCKET, userId);
+          await removeUserObjects(admin, AVATAR_BUCKET, userId);
         } catch (fileErr) {
           console.error('process-account-deletions: blob cleanup failed after delete for', userId, fileErr);
         }
diff --git a/supabase/functions/submit-message/index.ts b/supabase/functions/submit-message/index.ts
index c7b67402..e19cfc5b 100644
--- a/supabase/functions/submit-message/index.ts
+++ b/supabase/functions/submit-message/index.ts
@@ -5,7 +5,7 @@ const corsHeaders = {
   'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type, x-supabase-client-platform, x-supabase-client-platform-version, x-supabase-client-runtime, x-supabase-client-runtime-version',
 };
 
-const ALLOWED_CATEGORIES = ["Comment", "Feature Request", "Complaint", "Bug Report"];
+const ALLOWED_CATEGORIES = ["Comment", "Feature Request", "Complaint", "Bug Report", "New Datalogger Connection"];
 
 Deno.serve(async (req) => {
   if (req.method === 'OPTIONS') {
diff --git a/supabase/functions/submit-track/index.ts b/supabase/functions/submit-track/index.ts
index efb29265..b70761fb 100644
--- a/supabase/functions/submit-track/index.ts
+++ b/supabase/functions/submit-track/index.ts
@@ -169,8 +169,12 @@ Deno.serve(async (req) => {
       }
     }
 
-    // Verify Turnstile token (once for the whole batch)
-    if (Deno.env.get('TURNSTILE_SECRET_KEY')) {
+    // Verify Turnstile token (once for the whole batch). Skipped for signed-in
+    // users: they're already accountable via their account (and submissions are
+    // attributed to them), so the anti-bot CAPTCHA only gates anonymous submits.
+    // This lets the client auto-submit a custom track alongside a leaderboard
+    // snapshot without an interactive CAPTCHA. IP ban + rate limit still apply.
+    if (Deno.env.get('TURNSTILE_SECRET_KEY') && !submittedByUserId) {
       if (!turnstile_token || typeof turnstile_token !== 'string') {
         return jsonError('Verification required. Please complete the CAPTCHA.', 400);
       }
diff --git a/supabase/migrations/20260626000000_leaderboards.sql b/supabase/migrations/20260626000000_leaderboards.sql
new file mode 100644
index 00000000..549d30d5
--- /dev/null
+++ b/supabase/migrations/20260626000000_leaderboards.sql
@@ -0,0 +1,174 @@
+-- Leaderboards (plan 0005): public community leaderboard built from lap snapshots.
+--
+-- A user opt-in submits a frozen snapshot (one verified lap) as a leaderboard
+-- entry. Entries are PUBLIC (readable by anyone, signed-in or not — the browse
+-- page works without an account) so the whole point is cross-driver comparison.
+--
+-- Two tables:
+--   * leaderboard_entries — one row per submitted snapshot. GPS, engine name and
+--     the listed weight are always public; the chassis setup and engine-telemetry
+--     channels are stripped client-side unless the submitter opts to share them.
+--   * engine_classes — admin-managed keyword groups that collapse free-text engine
+--     names ("Tillotson 225" / "225RS" / "Tilly") into one canonical class so
+--     records group correctly. Classification is automatic on insert and the class
+--     is admin-overridable per row WITHOUT touching the user's raw `engine` string.
+--
+-- Moderation is allow-by-default: status starts 'approved' and only a public read
+-- filter hides denied rows. Admins flip status / class / notes via RLS policies.
+
+-- ── engine_classes ───────────────────────────────────────────────────────────
+create table if not exists public.engine_classes (
+  id          uuid primary key default gen_random_uuid(),
+  name        text not null,                 -- canonical display, e.g. "Tillotson 225"
+  keywords    text[] not null default '{}',  -- case-insensitive substrings of engine_key
+  sort_order  integer not null default 0,
+  created_at  timestamptz not null default now(),
+  updated_at  timestamptz not null default now()
+);
+
+alter table public.engine_classes enable row level security;
+
+-- Public read (labels + grouping work for anonymous visitors); admin-only writes.
+drop policy if exists "Anyone reads engine classes"   on public.engine_classes;
+drop policy if exists "Admins insert engine classes"   on public.engine_classes;
+drop policy if exists "Admins update engine classes"   on public.engine_classes;
+drop policy if exists "Admins delete engine classes"   on public.engine_classes;
+
+create policy "Anyone reads engine classes"
+  on public.engine_classes for select to anon, authenticated using (true);
+create policy "Admins insert engine classes"
+  on public.engine_classes for insert to authenticated with check (public.has_role(auth.uid(), 'admin'));
+create policy "Admins update engine classes"
+  on public.engine_classes for update to authenticated
+  using (public.has_role(auth.uid(), 'admin')) with check (public.has_role(auth.uid(), 'admin'));
+create policy "Admins delete engine classes"
+  on public.engine_classes for delete to authenticated using (public.has_role(auth.uid(), 'admin'));
+
+-- ── Classification helper ────────────────────────────────────────────────────
+-- First class (by sort_order) any of whose keywords is a substring of the engine
+-- key. SECURITY DEFINER so the insert trigger can resolve it under the submitter.
+create or replace function public.classify_engine(p_engine_key text)
+returns uuid language sql stable security definer set search_path = public as $$
+  select c.id
+    from public.engine_classes c
+   where exists (
+     select 1 from unnest(c.keywords) kw
+      where kw <> '' and position(lower(kw) in lower(coalesce(p_engine_key, ''))) > 0
+   )
+   order by c.sort_order, c.created_at
+   limit 1;
+$$;
+grant execute on function public.classify_engine(text) to anon, authenticated;
+
+-- ── leaderboard_entries ──────────────────────────────────────────────────────
+create table if not exists public.leaderboard_entries (
+  id                       uuid primary key default gen_random_uuid(),
+  user_id                  uuid not null references auth.users(id) on delete cascade,
+  -- Denormalized submitter profile name: the public label / lap label. Snapshotted
+  -- at submit time so it stays stable if the user later renames, and so anonymous
+  -- readers never need access to the profiles table.
+  display_name             text not null,
+
+  -- Identity / grouping
+  track_name               text not null,
+  course_name              text not null,
+  course_key               text not null,
+  direction                text,
+  engine                   text not null,             -- raw user string, never mutated
+  engine_key               text not null,             -- normalized (trim + lower)
+  engine_class_id          uuid references public.engine_classes(id) on delete set null,
+  class_source             text not null default 'auto' check (class_source in ('auto','admin')),
+
+  listed_weight            numeric,                   -- public weight (groups exact-match)
+  listed_weight_unit       text check (listed_weight_unit in ('lb','kg')),
+  lap_time_ms              integer not null,
+
+  -- Privacy + anti-resubmit
+  content_hash             text not null,             -- stable hash of the snapshot identity
+  setup_public             boolean not null default false,
+  engine_telemetry_public  boolean not null default false,
+
+  -- Frozen payload: clean-lap samples + course geometry (+ setup only when shared,
+  -- engine-telemetry channels stripped unless shared). All stripping is client-side.
+  data                     jsonb not null,
+
+  -- Moderation (allow-by-default)
+  status                   text not null default 'approved' check (status in ('approved','denied')),
+  created_at               timestamptz not null default now(),
+  reviewed_at              timestamptz,
+  reviewed_by              uuid references auth.users(id) on delete set null,
+  admin_notes              text,
+
+  unique (user_id, content_hash)                      -- can't resubmit an identical snapshot
+);
+
+create index if not exists leaderboard_entries_course_idx on public.leaderboard_entries (course_key);
+create index if not exists leaderboard_entries_status_idx  on public.leaderboard_entries (status);
+create index if not exists leaderboard_entries_class_idx   on public.leaderboard_entries (engine_class_id);
+
+alter table public.leaderboard_entries enable row level security;
+
+drop policy if exists "Anyone reads approved entries"  on public.leaderboard_entries;
+drop policy if exists "Users insert own entries"        on public.leaderboard_entries;
+drop policy if exists "Users delete own entries"        on public.leaderboard_entries;
+drop policy if exists "Admins read all entries"         on public.leaderboard_entries;
+drop policy if exists "Admins update entries"           on public.leaderboard_entries;
+
+-- Public can read approved rows (anonymous browse); a user always sees their own
+-- (so a denied entry still shows in their submitted list).
+create policy "Anyone reads approved entries"
+  on public.leaderboard_entries for select to anon, authenticated
+  using (status = 'approved' or auth.uid() = user_id);
+create policy "Users insert own entries"
+  on public.leaderboard_entries for insert to authenticated with check (auth.uid() = user_id);
+create policy "Users delete own entries"
+  on public.leaderboard_entries for delete to authenticated using (auth.uid() = user_id);
+create policy "Admins read all entries"
+  on public.leaderboard_entries for select to authenticated using (public.has_role(auth.uid(), 'admin'));
+create policy "Admins update entries"
+  on public.leaderboard_entries for update to authenticated
+  using (public.has_role(auth.uid(), 'admin')) with check (public.has_role(auth.uid(), 'admin'));
+
+-- Auto-classify on insert when the client didn't pin a class.
+create or replace function public.leaderboard_set_class()
+returns trigger language plpgsql security definer set search_path = public as $$
+begin
+  if NEW.engine_class_id is null then
+    NEW.engine_class_id := public.classify_engine(NEW.engine_key);
+  end if;
+  return NEW;
+end;
+$$;
+
+drop trigger if exists leaderboard_entries_classify on public.leaderboard_entries;
+create trigger leaderboard_entries_classify
+  before insert on public.leaderboard_entries
+  for each row execute function public.leaderboard_set_class();
+
+-- ── Admin reclassify ─────────────────────────────────────────────────────────
+-- Re-run auto-classification for every row whose class was NOT admin-set, so
+-- editing keyword groups retroactively regroups the auto-classified records while
+-- leaving manual overrides (class_source='admin') untouched.
+create or replace function public.reclassify_entries()
+returns integer language plpgsql security definer set search_path = public as $$
+declare
+  v_count integer;
+begin
+  if not public.has_role(auth.uid(), 'admin') then
+    raise exception 'not authorized';
+  end if;
+  with updated as (
+    update public.leaderboard_entries e
+       set engine_class_id = public.classify_engine(e.engine_key)
+     where e.class_source = 'auto'
+       and e.engine_class_id is distinct from public.classify_engine(e.engine_key)
+    returning 1
+  )
+  select count(*) into v_count from updated;
+  return v_count;
+end;
+$$;
+grant execute on function public.reclassify_entries() to authenticated;
+
+-- Surface the new tables + functions to PostgREST immediately.
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/20260627000000_leaderboards_drop_setup.sql b/supabase/migrations/20260627000000_leaderboards_drop_setup.sql
new file mode 100644
index 00000000..7889222c
--- /dev/null
+++ b/supabase/migrations/20260627000000_leaderboards_drop_setup.sql
@@ -0,0 +1,14 @@
+-- Leaderboards (plan 0005): drop setup from submissions entirely.
+--
+-- Sharing chassis setup data on a public leaderboard made people uneasy, so the
+-- submission flow no longer collects or stores it. Remove the now-unused
+-- setup_public column and strip any `setup` key from existing entry payloads so
+-- nothing lingers from the beta window.
+
+alter table public.leaderboard_entries drop column if exists setup_public;
+
+update public.leaderboard_entries
+   set data = data - 'setup'
+ where data ? 'setup';
+
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/20260627120000_profiles_ci_avatars.sql b/supabase/migrations/20260627120000_profiles_ci_avatars.sql
new file mode 100644
index 00000000..e24a48f2
--- /dev/null
+++ b/supabase/migrations/20260627120000_profiles_ci_avatars.sql
@@ -0,0 +1,108 @@
+-- Plan 0006 — User profiles, part 1: case-insensitive-unique display names,
+-- avatar columns, and a column-limited anon-readable view.
+--
+-- Display names were previously unique only case-sensitively, so "aetter" and
+-- "Aetter" could coexist and one could impersonate the other by changing case.
+-- We collapse any case-insensitive duplicates (destructive — acceptable at the
+-- current ~5-user scale) and replace the unique constraint with a functional
+-- unique index on lower(display_name). Avatars live in the user-avatars bucket;
+-- the path + an updated-at cache-buster are stored here. A public_profiles view
+-- exposes ONLY the four public columns to anonymous visitors (the driver page).
+
+-- ── Pre-flight: collapse case-insensitive duplicate names ────────────────────
+-- Keep the earliest row per lower(name); suffix later collisions so the new
+-- unique index can build. Destructive by design (a renamed account keeps its id).
+do $$
+declare r record;
+begin
+  for r in
+    select user_id, display_name,
+      row_number() over (partition by lower(display_name) order by created_at, user_id) as rn
+    from public.profiles
+  loop
+    if r.rn > 1 then
+      update public.profiles
+        set display_name = r.display_name || '-' || r.rn::text,
+            updated_at = now()
+        where user_id = r.user_id;
+    end if;
+  end loop;
+end $$;
+
+-- ── Swap the case-sensitive unique constraint for a case-insensitive index ────
+alter table public.profiles drop constraint if exists profiles_display_name_key;
+drop index if exists profiles_display_name_lower_idx;
+create unique index profiles_display_name_lower_idx
+  on public.profiles (lower(display_name));
+
+-- ── Avatar columns ───────────────────────────────────────────────────────────
+-- avatar_path: stable object path in the user-avatars bucket ({user_id}/avatar.<ext>).
+-- avatar_updated_at: appended to the public URL as ?v= so a replaced avatar (same
+-- path, upsert) repaints instead of serving the cached image.
+alter table public.profiles add column if not exists avatar_path text;
+alter table public.profiles add column if not exists avatar_updated_at timestamptz;
+
+-- ── Make server-side name resolution case-insensitive ────────────────────────
+-- These compared with `=`; switch to lower(...) so auto-generated / suffixed
+-- names never collide case-insensitively with the new unique index.
+create or replace function public.random_display_name()
+returns text language plpgsql as $$
+declare
+  adjs text[] := array[
+    'Speedy','Turbo','Drifty','Nitro','Reckless','Smooth','Apex','Sideways',
+    'Greasy','Loose','Sketchy','Mighty','Sneaky','Wobbly','Blazing','Rowdy',
+    'Janky','Cosmic','Feral','Zippy'];
+  nouns text[] := array[
+    'Racer','Driver','Pilot','Hooligan','Throttle','Slider','Charger','Rocket',
+    'Gremlin','Goblin','Wrench','Piston','Sender','Drifter','Maniac','Comet',
+    'Bandit','Cheetah','Noodle','Menace'];
+  candidate text;
+begin
+  loop
+    candidate :=
+      adjs[1 + floor(random() * array_length(adjs, 1))::int]
+      || replace(nouns[1 + floor(random() * array_length(nouns, 1))::int], 'e', '3')
+      || '-' || (100 + floor(random() * 900))::int::text;
+    exit when not exists (
+      select 1 from public.profiles where lower(display_name) = lower(candidate)
+    );
+  end loop;
+  return candidate;
+end;
+$$;
+
+create or replace function public.unique_display_name(desired text)
+returns text language plpgsql as $$
+declare
+  d text := nullif(btrim(coalesce(desired, '')), '');
+  candidate text;
+  tries int := 0;
+begin
+  if d is null then
+    return public.random_display_name();
+  end if;
+  candidate := d;
+  while exists (
+    select 1 from public.profiles where lower(display_name) = lower(candidate)
+  ) loop
+    tries := tries + 1;
+    candidate := d || '-' || (100 + floor(random() * 9900))::int::text;
+    if tries > 50 then
+      candidate := d || '-' || replace(gen_random_uuid()::text, '-', '');
+      exit;
+    end if;
+  end loop;
+  return candidate;
+end;
+$$;
+
+-- ── Anon-readable, column-limited public view ────────────────────────────────
+-- RLS can restrict rows but not columns, so a view is the right tool: anonymous
+-- visitors of /driver/:username may read only these four columns. The view runs
+-- with the (definer) migration role's rights; base-table RLS still gates writes.
+create or replace view public.public_profiles as
+  select user_id, display_name, avatar_path, avatar_updated_at
+  from public.profiles;
+grant select on public.public_profiles to anon, authenticated;
+
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/20260627120100_public_vehicles_and_avatar_bucket.sql b/supabase/migrations/20260627120100_public_vehicles_and_avatar_bucket.sql
new file mode 100644
index 00000000..59d47081
--- /dev/null
+++ b/supabase/migrations/20260627120100_public_vehicles_and_avatar_bucket.sql
@@ -0,0 +1,75 @@
+-- Plan 0006 — User profiles, part 2: the opt-in public vehicle projection and
+-- the public avatar bucket.
+--
+-- A user's garage lives privately in sync_records (owner-only RLS, weights and
+-- setups attached). The driver profile page must show vehicles publicly, so
+-- vehicles the user flags "show on profile" are projected into public_vehicles
+-- with ONLY public-safe columns — never weight/weightUnit or any setup. Avatars
+-- go in a public bucket so the page can render them with a plain public URL.
+
+-- ── Opt-in public vehicle projection ─────────────────────────────────────────
+create table if not exists public.public_vehicles (
+  user_id    uuid not null references auth.users (id) on delete cascade,
+  vehicle_id text not null,                 -- the client Vehicle.id
+  name       text not null,
+  type_name  text,                          -- resolved vehicle-type label (denormalized)
+  engine     text not null,
+  number     integer not null default 0,
+  updated_at timestamptz not null default now(),
+  primary key (user_id, vehicle_id)
+);
+-- NEVER add weight / weightUnit / setup columns here — that is the whole point.
+
+alter table public.public_vehicles enable row level security;
+
+drop policy if exists "Anyone reads public vehicles" on public.public_vehicles;
+create policy "Anyone reads public vehicles"
+  on public.public_vehicles for select to anon, authenticated using (true);
+
+drop policy if exists "Users insert own public vehicles" on public.public_vehicles;
+create policy "Users insert own public vehicles"
+  on public.public_vehicles for insert to authenticated
+  with check (auth.uid() = user_id);
+
+drop policy if exists "Users update own public vehicles" on public.public_vehicles;
+create policy "Users update own public vehicles"
+  on public.public_vehicles for update to authenticated
+  using (auth.uid() = user_id) with check (auth.uid() = user_id);
+
+drop policy if exists "Users delete own public vehicles" on public.public_vehicles;
+create policy "Users delete own public vehicles"
+  on public.public_vehicles for delete to authenticated
+  using (auth.uid() = user_id);
+
+-- ── Public avatar bucket ─────────────────────────────────────────────────────
+-- Public read (it's a public bucket); writes stay scoped to the owner's folder,
+-- mirroring the user-files policies.
+insert into storage.buckets (id, name, public)
+values ('user-avatars', 'user-avatars', true)
+on conflict (id) do nothing;
+
+drop policy if exists "Users upload own avatar" on storage.objects;
+create policy "Users upload own avatar"
+  on storage.objects for insert to authenticated
+  with check (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
+
+drop policy if exists "Users update own avatar" on storage.objects;
+create policy "Users update own avatar"
+  on storage.objects for update to authenticated
+  using (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
+
+drop policy if exists "Users delete own avatar" on storage.objects;
+create policy "Users delete own avatar"
+  on storage.objects for delete to authenticated
+  using (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
+
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/20260628000000_user_profiles_backend_repair.sql b/supabase/migrations/20260628000000_user_profiles_backend_repair.sql
new file mode 100644
index 00000000..622daee7
--- /dev/null
+++ b/supabase/migrations/20260628000000_user_profiles_backend_repair.sql
@@ -0,0 +1,166 @@
+-- Plan 0006 — self-healing repair of the user-profiles backend.
+--
+-- The original two migrations (20260627120000_profiles_ci_avatars +
+-- 20260627120100_public_vehicles_and_avatar_bucket) did not fully take on the
+-- beta *preview* database: the user-avatars bucket row was present but its
+-- storage.objects RLS policies were missing, so avatar uploads failed with
+-- "violates row-level security policy". Rather than hand-run SQL (which defeats
+-- migrations), this migration re-asserts the ENTIRE plan-0006 backend in a single
+-- fully idempotent pass. It is safe to run against any database — a DB where the
+-- originals applied cleanly sees only no-ops; a DB where they were skipped is
+-- brought fully up to spec. A fresh DB runs the originals first, then this as a
+-- superset no-op.
+
+-- ── profiles: avatar columns ─────────────────────────────────────────────────
+alter table public.profiles add column if not exists avatar_path text;
+alter table public.profiles add column if not exists avatar_updated_at timestamptz;
+
+-- ── profiles: case-insensitive-unique display name ───────────────────────────
+-- De-dup any case-collisions first so the functional unique index can build
+-- (no-op once the originals ran). Then drop the legacy case-sensitive constraint
+-- and ensure the lower(display_name) index exists.
+do $$
+declare r record;
+begin
+  for r in
+    select user_id, display_name,
+      row_number() over (partition by lower(display_name) order by created_at, user_id) as rn
+    from public.profiles
+  loop
+    if r.rn > 1 then
+      update public.profiles
+        set display_name = r.display_name || '-' || r.rn::text,
+            updated_at = now()
+        where user_id = r.user_id;
+    end if;
+  end loop;
+end $$;
+
+alter table public.profiles drop constraint if exists profiles_display_name_key;
+create unique index if not exists profiles_display_name_lower_idx
+  on public.profiles (lower(display_name));
+
+-- ── profiles: case-insensitive server-side name resolution ───────────────────
+create or replace function public.random_display_name()
+returns text language plpgsql as $$
+declare
+  adjs text[] := array[
+    'Speedy','Turbo','Drifty','Nitro','Reckless','Smooth','Apex','Sideways',
+    'Greasy','Loose','Sketchy','Mighty','Sneaky','Wobbly','Blazing','Rowdy',
+    'Janky','Cosmic','Feral','Zippy'];
+  nouns text[] := array[
+    'Racer','Driver','Pilot','Hooligan','Throttle','Slider','Charger','Rocket',
+    'Gremlin','Goblin','Wrench','Piston','Sender','Drifter','Maniac','Comet',
+    'Bandit','Cheetah','Noodle','Menace'];
+  candidate text;
+begin
+  loop
+    candidate :=
+      adjs[1 + floor(random() * array_length(adjs, 1))::int]
+      || replace(nouns[1 + floor(random() * array_length(nouns, 1))::int], 'e', '3')
+      || '-' || (100 + floor(random() * 900))::int::text;
+    exit when not exists (
+      select 1 from public.profiles where lower(display_name) = lower(candidate)
+    );
+  end loop;
+  return candidate;
+end;
+$$;
+
+create or replace function public.unique_display_name(desired text)
+returns text language plpgsql as $$
+declare
+  d text := nullif(btrim(coalesce(desired, '')), '');
+  candidate text;
+  tries int := 0;
+begin
+  if d is null then
+    return public.random_display_name();
+  end if;
+  candidate := d;
+  while exists (
+    select 1 from public.profiles where lower(display_name) = lower(candidate)
+  ) loop
+    tries := tries + 1;
+    candidate := d || '-' || (100 + floor(random() * 9900))::int::text;
+    if tries > 50 then
+      candidate := d || '-' || replace(gen_random_uuid()::text, '-', '');
+      exit;
+    end if;
+  end loop;
+  return candidate;
+end;
+$$;
+
+-- ── profiles: anon-readable, column-limited view ─────────────────────────────
+create or replace view public.public_profiles as
+  select user_id, display_name, avatar_path, avatar_updated_at
+  from public.profiles;
+grant select on public.public_profiles to anon, authenticated;
+
+-- ── public_vehicles: opt-in public projection (no weight/setup, ever) ────────
+create table if not exists public.public_vehicles (
+  user_id    uuid not null references auth.users (id) on delete cascade,
+  vehicle_id text not null,
+  name       text not null,
+  type_name  text,
+  engine     text not null,
+  number     integer not null default 0,
+  updated_at timestamptz not null default now(),
+  primary key (user_id, vehicle_id)
+);
+
+alter table public.public_vehicles enable row level security;
+
+drop policy if exists "Anyone reads public vehicles" on public.public_vehicles;
+create policy "Anyone reads public vehicles"
+  on public.public_vehicles for select to anon, authenticated using (true);
+
+drop policy if exists "Users insert own public vehicles" on public.public_vehicles;
+create policy "Users insert own public vehicles"
+  on public.public_vehicles for insert to authenticated
+  with check (auth.uid() = user_id);
+
+drop policy if exists "Users update own public vehicles" on public.public_vehicles;
+create policy "Users update own public vehicles"
+  on public.public_vehicles for update to authenticated
+  using (auth.uid() = user_id) with check (auth.uid() = user_id);
+
+drop policy if exists "Users delete own public vehicles" on public.public_vehicles;
+create policy "Users delete own public vehicles"
+  on public.public_vehicles for delete to authenticated
+  using (auth.uid() = user_id);
+
+-- ── user-avatars bucket + storage RLS (the part that was missing) ────────────
+-- Force `public = true` even if the bucket row already existed (e.g. created by
+-- a prior partial apply) as private, then re-assert the owner-folder write
+-- policies. THIS is what unblocks the avatar upload.
+insert into storage.buckets (id, name, public)
+values ('user-avatars', 'user-avatars', true)
+on conflict (id) do update set public = true;
+
+drop policy if exists "Users upload own avatar" on storage.objects;
+create policy "Users upload own avatar"
+  on storage.objects for insert to authenticated
+  with check (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
+
+drop policy if exists "Users update own avatar" on storage.objects;
+create policy "Users update own avatar"
+  on storage.objects for update to authenticated
+  using (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
+
+drop policy if exists "Users delete own avatar" on storage.objects;
+create policy "Users delete own avatar"
+  on storage.objects for delete to authenticated
+  using (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
+
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/20260629000000_user_avatars_select_policy.sql b/supabase/migrations/20260629000000_user_avatars_select_policy.sql
new file mode 100644
index 00000000..dc3b91ba
--- /dev/null
+++ b/supabase/migrations/20260629000000_user_avatars_select_policy.sql
@@ -0,0 +1,21 @@
+-- Plan 0006 — avatar upload fix: add the missing SELECT policy on user-avatars.
+--
+-- Avatar uploads use `upsert: true`, so storage-api first checks whether the
+-- object already exists — a SELECT on storage.objects under the caller's role.
+-- The user-avatars bucket got INSERT/UPDATE/DELETE policies but NO SELECT, so
+-- that existence check was denied and the upload 403'd ("Unauthorized") even
+-- though the INSERT policy itself was correct (verified: request folder ==
+-- auth.uid(), valid authenticated JWT). The user-files bucket has always carried
+-- this read policy — mirror it here so the upsert can complete. Public reads of
+-- avatars go through the bucket's public URL and are unaffected either way.
+--
+-- Idempotent + a fresh version, so it self-heals the beta DB (where the bucket's
+-- write policies already exist) and is a clean addition on main / any fresh DB.
+
+drop policy if exists "Users read own avatar" on storage.objects;
+create policy "Users read own avatar"
+  on storage.objects for select to authenticated
+  using (
+    bucket_id = 'user-avatars'
+    and (storage.foldername(name))[1] = auth.uid()::text
+  );
diff --git a/supabase/migrations/20260630000000_public_profiles_security_invoker.sql b/supabase/migrations/20260630000000_public_profiles_security_invoker.sql
new file mode 100644
index 00000000..9bb64fc2
--- /dev/null
+++ b/supabase/migrations/20260630000000_public_profiles_security_invoker.sql
@@ -0,0 +1,25 @@
+-- Plan 0006 — resolve the "Security Definer View" linter warning on public_profiles.
+--
+-- public_profiles was a SECURITY DEFINER view (the Postgres default), which the
+-- Supabase linter flags because it bypasses RLS on its base table. Recreate it as
+-- a security_invoker view so it runs with the *querying* role's privileges, and
+-- grant public (anon) read on profiles so anonymous /driver and leaderboard reads
+-- still resolve. The only profile columns are public by design (display name,
+-- avatar path/timestamp), so exposing the row to anon is fine. Writes are
+-- unchanged and stay owner-only — the public can read but cannot insert/update.
+
+create or replace view public.public_profiles
+  with (security_invoker = true) as
+  select user_id, display_name, avatar_path, avatar_updated_at
+  from public.profiles;
+grant select on public.public_profiles to anon, authenticated;
+
+-- Public read of profiles (replaces the authenticated-only policy) so the
+-- invoker-security view resolves for anonymous visitors. Insert/update policies
+-- are untouched: only the owner can write their row.
+drop policy if exists "Profiles readable by authenticated" on public.profiles;
+drop policy if exists "Public can read profiles" on public.profiles;
+create policy "Public can read profiles"
+  on public.profiles for select to anon, authenticated using (true);
+
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/20260630120000_leaderboard_display_name_link.sql b/supabase/migrations/20260630120000_leaderboard_display_name_link.sql
new file mode 100644
index 00000000..438a2e1c
--- /dev/null
+++ b/supabase/migrations/20260630120000_leaderboard_display_name_link.sql
@@ -0,0 +1,30 @@
+-- leaderboard_entries.display_name was denormalized — frozen at submit time — so a
+-- user renaming themselves never updated their existing leaderboard rows. Link it
+-- to the user instead: add an FK to profiles so reads embed the LIVE display name,
+-- and stop requiring the column (new inserts omit it). Kept nullable rather than
+-- dropped so a client still mid-deploy that sends it won't error; a later migration
+-- can drop the column once nothing writes it.
+
+alter table public.leaderboard_entries alter column display_name drop not null;
+
+-- Safety / self-correct: ensure every account has a profile before adding the FK,
+-- so the constraint validates even if some pre-trigger account slipped through.
+-- handle_new_user already creates one per sign-up; this backfills any gap (same
+-- logic as the original profiles backfill). With this, the migration can't fail
+-- on prod's existing accounts — a missing profile is created, not rejected.
+insert into public.profiles (user_id, display_name)
+select u.id, public.unique_display_name(u.raw_user_meta_data->>'display_name')
+from auth.users u
+left join public.profiles p on p.user_id = u.id
+where p.user_id is null;
+
+-- FK on user_id → profiles(user_id) so PostgREST can embed `profiles(display_name)`.
+-- The existing user_id → auth.users FK stays; the `auth` schema isn't exposed to the
+-- API, so the embeddable relationship is unambiguously `profiles`.
+alter table public.leaderboard_entries
+  drop constraint if exists leaderboard_entries_profile_fkey;
+alter table public.leaderboard_entries
+  add constraint leaderboard_entries_profile_fkey
+  foreign key (user_id) references public.profiles (user_id) on delete cascade;
+
+notify pgrst, 'reload schema';
diff --git a/vite.config.ts b/vite.config.ts
index 81d81bb3..5efe9d73 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -4,6 +4,7 @@ import path from "path";
 import fs from "fs";
 import { execSync } from "child_process";
 import { VitePWA } from "vite-plugin-pwa";
+import { resolveBranchBackend } from "./scripts/resolveSupabaseBranch";
 
 // Build-time version metadata for the footer "what changed" stamp. The app
 // version comes from package.json; the commit hash + build date are baked in at
@@ -110,7 +111,7 @@ const PUBLIC_BACKEND_FALLBACKS = {
 } as const;
 
 // https://vitejs.dev/config/
-export default defineConfig(({ mode }) => {
+export default defineConfig(async ({ mode }) => {
   const env = loadEnv(mode, process.cwd(), "");
 
   // Some secret stores reject the `VITE_` prefix (those are public, build-time
@@ -131,11 +132,25 @@ export default defineConfig(({ mode }) => {
   // instead of production. Production (`main`) builds and local dev never see
   // the _PREVIEW values, so they're untouched. The creds are build-time-baked,
   // not runtime — picking them here is the only place to switch backends.
+  // Backend tier is chosen by the build's git branch:
+  //   main          → base build vars (production database)
+  //   BETA          → static `*_PREVIEW` vars (the one shared beta database)
+  //   any other     → that branch's OWN Supabase preview-branch DB (resolved
+  //                   below via the Management API), falling back to the
+  //                   `*_PREVIEW`/beta creds when no such branch exists.
+  // `_PREVIEW` is preferred for BETA *and* feature branches; only feature
+  // branches additionally consult the resolver (BETA must never be hijacked onto
+  // a per-branch DB — it's the shared integration database).
   const ciBranch = process.env.WORKERS_CI_BRANCH || process.env.CF_PAGES_BRANCH;
   const PROD_BRANCH = "main";
+  const BETA_BRANCH = "BETA";
   const isPreviewBuild = !!ciBranch && ciBranch !== PROD_BRANCH;
+  const isFeatureBranch = isPreviewBuild && ciBranch !== BETA_BRANCH;
 
-  const pick = (viteKey: string, httKey: string, fallback: string) => {
+  const pick = (viteKey: string, httKey: string, fallback: string, override?: string) => {
+    // A resolved per-branch Supabase preview DB (feature branches only) wins over
+    // everything — it's the whole point: this branch's own database.
+    if (override) return override;
     if (isPreviewBuild) {
       const previewVal =
         env[`${viteKey}_PREVIEW`] ||
@@ -147,6 +162,42 @@ export default defineConfig(({ mode }) => {
     return env[viteKey] || process.env[viteKey] || env[httKey] || process.env[httKey] || fallback;
   };
 
+  // DYNAMIC PER-BRANCH BACKEND — FEATURE BRANCHES ONLY (never main, never BETA).
+  // Ask the Supabase Management API whether a preview-branch database exists for
+  // THIS git branch and, if so, bake its creds in; otherwise fall back to the
+  // `*_PREVIEW`/beta chain via pick(). Requires a SUPABASE_ACCESS_TOKEN build
+  // secret; without it (or when Supabase made no branch) `branchBackend` stays
+  // null. The resolver never throws and times out fast, so it can't break a deploy.
+  const prodProjectRef =
+    env.VITE_SUPABASE_PROJECT_ID ||
+    process.env.VITE_SUPABASE_PROJECT_ID ||
+    env.HTT_SUPABASE_PROJECT_ID ||
+    process.env.HTT_SUPABASE_PROJECT_ID ||
+    "";
+  const branchBackend = isFeatureBranch
+    ? await resolveBranchBackend({
+        gitBranch: ciBranch ?? "",
+        prodProjectRef,
+        accessToken: process.env.SUPABASE_ACCESS_TOKEN || env.SUPABASE_ACCESS_TOKEN || "",
+      })
+    : null;
+
+  // Resolve the URL once and log which database this build baked in, so a deploy's
+  // logs always state plainly which backend (and why) it points at.
+  const supabaseUrl = pick(
+    "VITE_SUPABASE_URL", "HTT_SUPABASE_URL", PUBLIC_BACKEND_FALLBACKS.VITE_SUPABASE_URL, branchBackend?.url,
+  );
+  const backendTier = !ciBranch
+    ? "local/dev (base vars)"
+    : ciBranch === PROD_BRANCH
+      ? "main (base/production vars)"
+      : ciBranch === BETA_BRANCH
+        ? "BETA (*_PREVIEW vars)"
+        : branchBackend
+          ? `feature "${ciBranch}" (branch DB ${branchBackend.projectId})`
+          : `feature "${ciBranch}" (no branch DB → *_PREVIEW fallback)`;
+  console.log(`[backend] Supabase URL baked: ${supabaseUrl || "(none — offline-only build)"} — ${backendTier}`);
+
   const appVersion = readAppVersion();
   const gitHash = gitShortHash();
   const buildDate = new Date().toISOString();
@@ -166,14 +217,12 @@ export default defineConfig(({ mode }) => {
     },
     define: {
       "import.meta.env.VITE_SUPABASE_PROJECT_ID": JSON.stringify(
-        pick("VITE_SUPABASE_PROJECT_ID", "HTT_SUPABASE_PROJECT_ID", PUBLIC_BACKEND_FALLBACKS.VITE_SUPABASE_PROJECT_ID),
+        pick("VITE_SUPABASE_PROJECT_ID", "HTT_SUPABASE_PROJECT_ID", PUBLIC_BACKEND_FALLBACKS.VITE_SUPABASE_PROJECT_ID, branchBackend?.projectId),
       ),
       "import.meta.env.VITE_SUPABASE_PUBLISHABLE_KEY": JSON.stringify(
-        pick("VITE_SUPABASE_PUBLISHABLE_KEY", "HTT_SUPABASE_PUBLISHABLE_KEY", PUBLIC_BACKEND_FALLBACKS.VITE_SUPABASE_PUBLISHABLE_KEY),
-      ),
-      "import.meta.env.VITE_SUPABASE_URL": JSON.stringify(
-        pick("VITE_SUPABASE_URL", "HTT_SUPABASE_URL", PUBLIC_BACKEND_FALLBACKS.VITE_SUPABASE_URL),
+        pick("VITE_SUPABASE_PUBLISHABLE_KEY", "HTT_SUPABASE_PUBLISHABLE_KEY", PUBLIC_BACKEND_FALLBACKS.VITE_SUPABASE_PUBLISHABLE_KEY, branchBackend?.anonKey),
       ),
+      "import.meta.env.VITE_SUPABASE_URL": JSON.stringify(supabaseUrl),
       "import.meta.env.VITE_ENABLE_ADMIN": JSON.stringify(
         pick("VITE_ENABLE_ADMIN", "HTT_ENABLE_ADMIN", PUBLIC_BACKEND_FALLBACKS.VITE_ENABLE_ADMIN),
       ),
diff --git a/vitest.config.ts b/vitest.config.ts
index eb1b1f6e..d5d39e4f 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -10,7 +10,13 @@ export default defineConfig({
     environment: "node",
     // App tests live under src/; also pick up pure logic extracted from Supabase
     // edge functions (Deno) so it can be unit-tested here (coverage stays src/-only).
-    include: ["src/**/*.{test,spec}.{ts,tsx}", "supabase/functions/**/*.{test,spec}.ts"],
+    include: [
+      "src/**/*.{test,spec}.{ts,tsx}",
+      "supabase/functions/**/*.{test,spec}.ts",
+      // Build tooling (CI-only, never shipped) — tested here, but kept out of the
+      // src-only coverage scope below.
+      "scripts/**/*.{test,spec}.ts",
+    ],
     exclude: ["node_modules", "dist"],
     setupFiles: ["./vitest.setup.ts"],
     coverage: {