diff --git a/FORMATS.md b/FORMATS.md
index 39bca87..669137d 100644
--- a/FORMATS.md
+++ b/FORMATS.md
@@ -104,7 +104,7 @@ Coordinates are `[lat, lng]`; the importer swaps to `[lng, lat]` internally. Gar
 - Non-finite or out-of-range lat/lng.
 - Jumps > 5 km between consecutive points.
 
-Stored only in memory (cleared by the **Loaded data → Clear** button or app restart).
+**Persisted in the SQLite database** (`video_metadata` table, keyed by `video_name`). Once imported, the polylines hydrate automatically on every app start — you don't have to re-pick the file each session. Cleared by the **Loaded data → Clear** button on the Per-video metadata row, or by **Reset DB** (which wipes the whole database).
 
 ### Metadata polyline (legacy single-track)
 Single-video legacy format used by the old FastAPI pipeline.
diff --git a/README.md b/README.md
index c33baad..cea0f79 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Tauri 2 desktop app for reviewing, correcting and exporting fixed-asset / range-
    - **Range assets (JSON)** — linear assets with start / mid / end (e.g., crash barriers).
    - **KML scope polygon** — defines which assets are "in scope". Points outside the polygon are hidden by default.
    - **OSM roads (GeoJSON)** — imported road network for snapping / direction lookups.
-   - **Metadata polyline (KML)** — vehicle GPS track from the source video; takes priority over OSM for direction inference.
+   - **Per-video metadata (JSON)** — vehicle GPS track per video; takes priority over OSM for direction inference. **Persists in the SQLite database**, so you only pick the file once — every subsequent app start hydrates it automatically. Cleared only by the **Clear** button on the Per-video metadata row, or by **Reset DB**.
 3. The map auto-centers on the first imported asset. Pan / zoom triggers viewport-bounded fetches (debounced) to keep the deck.gl rendering snappy.
 
 ---
@@ -51,6 +51,23 @@ Tauri 2 desktop app for reviewing, correcting and exporting fixed-asset / range-
 
 ---
 
+## Single-video focus mode
+
+When you want to inspect / clean one video's worth of data in isolation:
+
+- **Tap that video's metadata polyline on the map**, or
+- **Leave exactly one video checked in the Filters panel**.
+
+Either path triggers focus mode:
+
+- Other videos' metadata polylines are hidden — only the focused track renders.
+- OSM roads are spatially filtered to those within ~75 m of the focused track (cheap spatial-hash buffer; recomputed on each switch).
+- Clicking the metadata line again, or unchecking the lone video filter, restores the full view.
+
+Focus mode also unlocks the bulk OSM road tools (multi-select / hide / merge — see **OSM road editing**). Selection and hidden state are session-scoped: they reset whenever you exit OSM edit mode or change the focused video.
+
+---
+
 ## Cross-side / cross-video pair linking
 
 Common situation: one physical asset (e.g., a median streetlight) is captured in two videos (LHS and RHS) and shows up as two near-duplicate points. Pair linking marks them as the same physical thing without deleting either.
@@ -97,45 +114,70 @@ Range assets (start / mid / end) translate as a rigid body — all three vertice
 ## OSM road editing
 
 ### Modes
-- **OSM tools…** modal — generate roads for the visible bbox (Overpass), import existing GeoJSON, export current roads, prune small road classes.
+- **OSM tools…** modal — generate roads for the visible bbox or for a buffer around imported assets (Overpass), import existing GeoJSON, export current roads, prune small road classes.
 - **Edit OSM roads** button — toggles OSM edit mode. While on, every other layer is dimmed and only OSM roads are interactive.
+- **Magnifier** button — cursor-following circular lens that zooms +3 levels around the cursor; renders satellite + OSM cyan + dashed-green metadata + red asset dots. Toggle on, hover anywhere, then ESC or click again to exit.
 - **Lane offset (m)** — controls the parallel offset used by snap-to-road. Range 0.1–30 m.
 
-### Picking a road to edit
-1. Turn on **Edit OSM roads** (right panel → Data section).
-2. Zoom in to **z ≥ 14** — vertex handles only render at that zoom or deeper, to keep the map responsive.
-3. Click any road. Its yellow `•` vertex pins appear; other roads stay un-pinned. The selected road's id is shown in the OSM-edit panel.
+### Two click models
 
-### Modifying a road
-- **Drag a yellow `•` pin** — moves that vertex to wherever you drop it. The change is saved immediately.
-- **Click a yellow `+` ghost pin** between two vertices — inserts a new vertex at that midpoint. Useful when an OSM segment is too sparse for the curve.
-- **Flip direction** — cycles `oneway` through forward (`1`) → reverse (`-1`) → undirected (`0`). Use when OSM has the heading wrong on a divided road.
+OSM edit mode behaves differently depending on whether a single video is focused (see **Single-video focus mode**):
+
+- **Non-focus** — click a road to enter the legacy single-road vertex editor (the only road remains visible; vertex pins appear). One road at a time.
+- **Focus mode** — click a road to **toggle multi-select** (yellow highlight). All roads stay visible. When the selection narrows to **exactly one** road, the vertex editor automatically engages on it (Flip / Simplify / Delete this road / Ignore for snap appear inline). Click the road again to drop back to multi-select.
+
+### Modifying a road's vertices (single road active)
+- **Drag a yellow `•` pin** — moves that vertex. Saved immediately.
+- **Click a yellow `+` ghost pin** between two vertices — inserts a new vertex at that midpoint.
+- **Flip direction** — cycles `oneway` through forward (`1`) → reverse (`-1`) → undirected (`0`).
+- Vertex handles render at z ≥ 14; zoom in if you don't see them.
 
 ### Deleting vertices
-Two tools, depending on scope:
-
 **A. Surgical — Shift-click + Del**
-1. Hold **Shift** and click a vertex pin → it turns red with an `✕`.
-2. Repeat to mark more.
-3. Press **Del** (or Backspace) → all marked vertices are removed in one shot.
-4. The "Currently marked: N" label in the panel shows how many you've flagged. **Clear marks** unselects without deleting.
-5. Shift-click a marked vertex again to unmark it individually.
-6. The road must keep ≥ 2 vertices; the backend rejects deletes that would break that.
+1. **Shift-click** a vertex pin → turns red with `✕`. Repeat to mark more.
+2. Press **Del** → all marked vertices removed in one shot.
+3. **Clear marks** unselects without deleting. Shift-click a marked vertex to unmark.
+4. The road must keep ≥ 2 vertices.
 
 **B. Sweeping — Simplify by tolerance**
-1. Use the **Simplify (m)** slider in the panel (0.5–20 m, default 2 m). Higher = more aggressive.
-2. Click **Simplify this road**. Runs Douglas-Peucker on the polyline: any vertex within tolerance of the simplified line is dropped.
+1. **Simplify (m)** slider (0.5–20 m, default 2 m). Higher = more aggressive.
+2. Click **Simplify this road** → Douglas-Peucker on the polyline.
 3. Status bar reports `before → after` vertex counts.
-4. Try 1–2 m for cleanup, 5+ m for heavy decimation. Re-running with the same tolerance is idempotent.
 
-### Deleting / flipping the whole road
-- **Delete this road** — removes the road outright (with confirmation).
-- **Deselect road** — exits the per-road editing tool but keeps OSM edit mode on.
+### Bulk road tools (focus mode only)
 
-### Notes
-- OSM road edits are **not** undoable via the Recent actions panel — they're treated like reference-data tweaks. Be deliberate, especially with delete and simplify.
-- Dragging a vertex triggers a single `update_osm_road` write per drag. Bulk delete and simplify are also single writes.
-- After a vertex change, the road line refreshes in real time but the surrounding draggable pins re-render — slight visual flicker is normal.
+A "Bulk road tools — focus: <video>" panel appears when OSM edit mode is on inside single-video focus. Workflow:
+
+- **Click** roads to build a selection (yellow + thicker stroke).
+- **Right-click** any road → instantly hides it (no selection needed).
+- **Del** → moves all currently-selected roads into the hidden bucket and clears the selection.
+- **Hide selected / Clear selection / Restore hidden** buttons in the panel mirror those shortcuts.
+- **Merge selected** (≥ 2 picked) — concatenates connected ways into one. Endpoints within ~8 m of each other are clustered first, so OSM ways with near-but-not-touching endpoints still merge — both ends are snapped to the cluster centroid so the merged geometry has no visible gap. **Disconnected clusters become independent merged roads** (no false bridging).
+- **Merge all visible** — same logic over every non-hidden road in the focused area.
+- Branched clusters (any node with > 2 incident ways) are skipped rather than corrupted; the toast tells you how many.
+
+Both **hidden** and **selection** sets are session-scoped — cleared on **Exit OSM edit mode** or focused-video change, never persisted.
+
+### Ignore-for-snap (persistent)
+
+Per-road toggle that keeps a road on the map for visual reference but excludes it from snap candidates. Useful for service roads / driveways that the snap should never pick.
+
+- With **one road selected** in the vertex editor, the **Ignore for snap** button appears next to **Flip direction**.
+- Ignored roads render in **grey** (vs. the default cyan) and are skipped by both single-asset and bulk snap.
+- Stored as a `snap_ignored` column on the `roads` table — survives app restarts. Toggle again to re-enable.
+
+### Whole-road actions
+- **Delete this road** — removes the road (with confirmation).
+- **Deselect road** — exits the per-road editor (non-focus only; in focus mode, click the road again).
+
+### Per-session OSM edit undo
+
+A 3-deep ring buffer scoped to the current OSM edit session captures the last edits so you can revert them without affecting the global asset audit log.
+
+- **↶ Undo last edit (N)** button right under "Exit OSM edit mode" — visible in both focused and non-focused mode. Tooltip names the action it will undo.
+- Covers: **flip direction, simplify road, delete vertices, drag vertex, ignore-for-snap toggle, hide road (right-click + Del), restore hidden**.
+- **Not** undoable via this stack: merge selected / merge all visible (they consume source rows; this stack doesn't recreate them), creating new roads, deleting whole roads.
+- Cleared on **Exit OSM edit mode**.
 
 ---
 
@@ -149,6 +191,31 @@ Two tools, depending on scope:
 
 ---
 
+## Quality dashboard
+
+A `<details>` panel in the right sidebar that scans the live asset set for likely-bad rows. Click **Run scan** the first time, **Refresh** thereafter.
+
+Three checks (cap 500 hits each; totals shown even when capped):
+
+- **Moved far from import** — modified rows whose current position is > 50 m from the original (import-time) lat/lng. Flags accidental drags.
+- **Off track (far from metadata polyline)** — perpendicular distance to the asset's video metadata polyline exceeds the configured threshold (default **30 m**, tunable in Settings). Flags assets that were assigned to a video / side they don't actually belong to. Skipped silently for videos with no metadata loaded.
+- **Missing side** — `side IS NULL`. Flags assets the labeller didn't tag.
+
+For any non-zero count, **View** in the row launches a step-through:
+- Zooms the map to z=18 on the first issue.
+- **Prev / Next** in the same panel walks through the rest, one at a time at z=18.
+
+### Post-snap quality check
+
+Every snap entrypoint (single asset, bulk visible, snap by video, snap to road) runs a quality scan immediately after and surfaces a toast:
+
+- **Green** — "No quality issues."
+- **Red** — "N quality issues found (M moved · O off track · P no side)."
+
+The scan reuses your configured off-track threshold. Toast auto-dismisses after 8 s; click `×` to dismiss sooner.
+
+---
+
 ## Centerline override
 
 Some asset classes (expansion joint, vms gantry) belong on the road centerline, not the LHS/RHS offset. Settings → **Snap to centerline (instead of offset lane)** lets you tick those class names.
@@ -161,6 +228,10 @@ Some asset classes (expansion joint, vms gantry) belong on the road centerline,
   - On / off (when off, marker pins still appear but no image opens on click).
   - Width: S / M / L / XL.
   - Aspect ratio: 16:9 / 4:3 / 3:2 / 1:1.
+- **Quality thresholds**
+  - **Off-track distance (m)** — perpendicular distance from metadata polyline beyond which an asset is flagged "off track" by the Quality dashboard and post-snap scan. Default 30 m. **Reset to 30 m** button restores the default. Persisted in localStorage. Lowering below ~25 m starts producing noise on curved / sparse polylines (chord cuts a corner the asset is on).
+- **Diagnostics**
+  - **Performance mode** — while panning / zooming, render only basemap + asset markers + range paths (hide roads / scope / metadata / links / labels). Diagnostic; leave off for normal use.
 - **Snap to centerline names** — list of asset_names that should snap to centerline.
 - **Image folder (offline)** — a local folder used to resolve `image_path` URLs to disk (HTTPS URLs always pass through unchanged).
 
@@ -181,17 +252,27 @@ OSM roads can be exported separately via **OSM tools… → Export current roads
 
 ## Keyboard shortcuts
 
-| Key | Action |
-|---|---|
-| `[` / `]` | Step prev / next asset in the filtered list |
-| `ESC` | Cancel: lasso / link-pick / draw-road / road-edit / image popup |
-| `Delete` / `Backspace` | Unlink the currently-selected link line |
+| Key | Context | Action |
+|---|---|---|
+| `[` / `]` | filtered list | Step prev / next asset |
+| `ESC` | various | Cancel: lasso / link-pick / draw-road / road-edit / image popup / metadata focus / magnifier |
+| `Delete` / `Backspace` | link selected | Unlink the currently-selected link line |
+| `Shift` + click | OSM vertex | Mark / unmark a road vertex (red ✕) |
+| `Delete` / `Backspace` | OSM edit, marked vertices | Delete all marked vertices on the active road |
+| `Delete` / `Backspace` | OSM edit, focus + selection | Hide all currently-selected roads (session-only) |
+| Right-click | OSM edit, focus | Hide that road instantly |
 
 ---
 
 ## Undo / Redo
 
-Every state-changing action writes an audit row. The **Recent actions** panel shows the last N. Click **Undo** on any row to revert; **Redo** on a previously undone row replays it. Multi-asset operations (bulk delete, distribute, auto-link) revert as a single atomic step. Road edits (OSM vertex drag, create / delete / flip) are not audited.
+Two independent stacks:
+
+**Asset audit log** — every state-changing asset action writes an audit row. The **Recent actions** panel shows the last N. **Undo** on any row reverts; **Redo** replays. Multi-asset operations (bulk delete, distribute, auto-link, snap) revert atomically as a single step.
+
+**OSM edit ring buffer** — separate 3-deep, in-session undo for road edits, with its own **↶ Undo last edit** button in the OSM edit panel. Covers flip / simplify / delete vertices / drag vertex / ignore-for-snap toggle / hide / restore-hidden. Cleared on Exit OSM edit mode. Merge and whole-road creation / deletion are **not** captured here — be deliberate with those.
+
+Road edits do not appear in the asset audit log; the asset Undo and the OSM Undo never collide.
 
 ---
 
@@ -210,3 +291,8 @@ Every state-changing action writes an audit row. The **Recent actions** panel sh
 - **Streetlights not visible on satellite** — switch to **Google Satellite (deep zoom)** basemap and zoom to z≥22.
 - **Snap moves assets to the wrong side** — load the metadata polyline (gives true vehicle heading), or fix the OSM road's `oneway` direction.
 - **Re-importing wipes my edits** — re-import preserves rows where `modified=1` (manual moves) and rows the user deleted; only `modified=0` geometry is re-stamped from source. If you need a fresh start, use **Reset DB** in the Data section first.
+- **Per-video metadata didn't auto-load on startup** — confirm the **Per-video metadata** row in the Loaded data section shows a non-zero count. If it does and the polylines aren't drawing, toggle **Metadata** in the Layers picker. If the count is zero after a previous import, the DB was wiped (Reset DB or manual `markers.db` delete) — re-pick the JSON.
+- **Quality "Off track" flags too many / too few rows** — adjust **Settings → Quality thresholds → Off-track distance**. Default 30 m. Going below ~25 m starts producing noise on curved / sparse polylines (chord cuts a corner the asset is on).
+- **Off-track flagged assets that look fine on the map** — check that the asset's `video_name` has metadata loaded. If the metadata is for a different video the chord-distance calc compares against the wrong track.
+- **Bulk road tools panel doesn't show** — needs OSM edit mode AND a focused video. Tap a metadata polyline on the map (or check exactly one video in Filters) to focus, then press **Edit OSM roads**.
+- **Magnifier shows a black circle** — basemap tile fetch hadn't completed when the lens map mounted; move the cursor a couple of pixels to trigger a re-render, or close and re-open the magnifier.
diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs
index 7bbd02b..32d4f17 100644
--- a/src-tauri/src/commands.rs
+++ b/src-tauri/src/commands.rs
@@ -197,6 +197,157 @@ fn normalize_side(s: &str) -> Option<String> {
     }
 }
 
+// Per-row insert helpers extracted so the auto-detect importer
+// (`import_assets_auto`) can share the exact INSERT/ON CONFLICT logic with
+// the type-specific importers — keeps re-import preserve-edits semantics
+// identical no matter which entry path the user takes.
+async fn insert_fixed_row(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    input: &FixedAssetInput,
+) -> Result<(), String> {
+    let (lat, lng) = input.coord.to_lat_lng()?;
+    let side = input.side.as_deref().and_then(normalize_side);
+    sqlx::query(
+        r#"
+        INSERT INTO assets (
+            row_id, asset_type, asset_name, video_name,
+            lat, lng, min_lat, max_lat, min_lng, max_lng,
+            image_path, deleted, side
+        ) VALUES (?, 'fixed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(row_id) DO UPDATE SET
+            asset_type = excluded.asset_type,
+            asset_name = excluded.asset_name,
+            video_name = excluded.video_name,
+            lat        = CASE WHEN assets.modified = 0 THEN excluded.lat ELSE assets.lat END,
+            lng        = CASE WHEN assets.modified = 0 THEN excluded.lng ELSE assets.lng END,
+            min_lat    = CASE WHEN assets.modified = 0 THEN excluded.min_lat ELSE assets.min_lat END,
+            max_lat    = CASE WHEN assets.modified = 0 THEN excluded.max_lat ELSE assets.max_lat END,
+            min_lng    = CASE WHEN assets.modified = 0 THEN excluded.min_lng ELSE assets.min_lng END,
+            max_lng    = CASE WHEN assets.modified = 0 THEN excluded.max_lng ELSE assets.max_lng END,
+            image_path = excluded.image_path,
+            -- Clear range-only fields when a row migrates range → fixed.
+            -- Fixed assets carry only `image_path` and a single (lat, lng);
+            -- leaving the old triple paths or start/end coords in place
+            -- would render stale S/M/E pins and a stale popup image.
+            image_path1 = NULL,
+            image_path2 = NULL,
+            image_path3 = NULL,
+            start_lat   = NULL,
+            start_lng   = NULL,
+            end_lat     = NULL,
+            end_lng     = NULL,
+            deleted    = CASE WHEN assets.deleted = 1 THEN 1 ELSE excluded.deleted END,
+            side       = CASE WHEN assets.modified = 0 THEN excluded.side ELSE assets.side END
+        "#,
+    )
+    .bind(&input.row_id)
+    .bind(&input.asset_name)
+    .bind(&input.video_name)
+    .bind(lat)
+    .bind(lng)
+    .bind(lat)
+    .bind(lat)
+    .bind(lng)
+    .bind(lng)
+    .bind(&input.image_path)
+    .bind(input.deleted as i64)
+    .bind(&side)
+    .execute(&mut **tx)
+    .await
+    .map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+async fn insert_range_row(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    input: &RangeAssetInput,
+) -> Result<(), String> {
+    let mid_lat = input.coord_lat.to_f64()?;
+    let mid_lng = input.coord_lng.to_f64()?;
+    let s_lat = input.start_coord_lat.to_f64()?;
+    let s_lng = input.start_coord_lng.to_f64()?;
+    let e_lat = input.end_coord_lat.to_f64()?;
+    let e_lng = input.end_coord_lng.to_f64()?;
+    let min_lat = mid_lat.min(s_lat).min(e_lat);
+    let max_lat = mid_lat.max(s_lat).max(e_lat);
+    let min_lng = mid_lng.min(s_lng).min(e_lng);
+    let max_lng = mid_lng.max(s_lng).max(e_lng);
+    let side = input.side.as_deref().and_then(normalize_side);
+
+    sqlx::query(
+        r#"
+        INSERT INTO assets (
+            row_id, asset_type, asset_name, video_name,
+            lat, lng, start_lat, start_lng, end_lat, end_lng,
+            min_lat, max_lat, min_lng, max_lng,
+            image_path1, image_path2, image_path3, deleted, side
+        ) VALUES (?, 'range', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(row_id) DO UPDATE SET
+            asset_type   = excluded.asset_type,
+            asset_name   = excluded.asset_name,
+            video_name   = excluded.video_name,
+            lat          = CASE WHEN assets.modified = 0 THEN excluded.lat ELSE assets.lat END,
+            lng          = CASE WHEN assets.modified = 0 THEN excluded.lng ELSE assets.lng END,
+            start_lat    = CASE WHEN assets.modified = 0 THEN excluded.start_lat ELSE assets.start_lat END,
+            start_lng    = CASE WHEN assets.modified = 0 THEN excluded.start_lng ELSE assets.start_lng END,
+            end_lat      = CASE WHEN assets.modified = 0 THEN excluded.end_lat ELSE assets.end_lat END,
+            end_lng      = CASE WHEN assets.modified = 0 THEN excluded.end_lng ELSE assets.end_lng END,
+            min_lat      = CASE WHEN assets.modified = 0 THEN excluded.min_lat ELSE assets.min_lat END,
+            max_lat      = CASE WHEN assets.modified = 0 THEN excluded.max_lat ELSE assets.max_lat END,
+            min_lng      = CASE WHEN assets.modified = 0 THEN excluded.min_lng ELSE assets.min_lng END,
+            max_lng      = CASE WHEN assets.modified = 0 THEN excluded.max_lng ELSE assets.max_lng END,
+            image_path1  = excluded.image_path1,
+            image_path2  = excluded.image_path2,
+            image_path3  = excluded.image_path3,
+            -- Clear the singular `image_path` when a row migrates fixed →
+            -- range. Range assets use image_path1/2/3 only; leaving the old
+            -- singular path would surface as a stale "main" image in any
+            -- consumer that prefers it over the triple.
+            image_path   = NULL,
+            deleted      = CASE WHEN assets.deleted = 1 THEN 1 ELSE excluded.deleted END,
+            side         = CASE WHEN assets.modified = 0 THEN excluded.side ELSE assets.side END
+        "#,
+    )
+    .bind(&input.row_id)
+    .bind(&input.asset_name)
+    .bind(&input.video_name)
+    .bind(mid_lat)
+    .bind(mid_lng)
+    .bind(s_lat)
+    .bind(s_lng)
+    .bind(e_lat)
+    .bind(e_lng)
+    .bind(min_lat)
+    .bind(max_lat)
+    .bind(min_lng)
+    .bind(max_lng)
+    .bind(&input.image_path1)
+    .bind(&input.image_path2)
+    .bind(&input.image_path3)
+    .bind(input.deleted as i64)
+    .bind(&side)
+    .execute(&mut **tx)
+    .await
+    .map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+async fn stamp_orig_positions(pool: &SqlitePool) -> Result<(), String> {
+    sqlx::query(
+        "UPDATE assets
+         SET orig_lat       = COALESCE(orig_lat, lat),
+             orig_lng       = COALESCE(orig_lng, lng),
+             orig_start_lat = COALESCE(orig_start_lat, start_lat),
+             orig_start_lng = COALESCE(orig_start_lng, start_lng),
+             orig_end_lat   = COALESCE(orig_end_lat, end_lat),
+             orig_end_lng   = COALESCE(orig_end_lng, end_lng)",
+    )
+    .execute(pool)
+    .await
+    .map_err(|e| e.to_string())?;
+    Ok(())
+}
+
 #[tauri::command]
 pub async fn import_fixed_assets(
     path: String,
@@ -209,68 +360,11 @@ pub async fn import_fixed_assets(
     let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
     let mut count = 0usize;
     for input in parsed {
-        let (lat, lng) = input.coord.to_lat_lng()?;
-        // Side comes from the JSON only. We used to fall back to scanning
-        // image_path for /LHS/ or /RHS/, but those segments are storage
-        // folders in some pipelines, not side indicators — that produced
-        // confidently-wrong "Left" labels for every row. If the source has
-        // no side, we leave it NULL; the user can set it via the per-asset
-        // toggle or Lasso → Set Left / Set Right.
-        let side = input.side.as_deref().and_then(normalize_side);
-        sqlx::query(
-            r#"
-            INSERT INTO assets (
-                row_id, asset_type, asset_name, video_name,
-                lat, lng, min_lat, max_lat, min_lng, max_lng,
-                image_path, deleted, side
-            ) VALUES (?, 'fixed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(row_id) DO UPDATE SET
-                asset_name = excluded.asset_name,
-                video_name = excluded.video_name,
-                -- Preserve user edits: only re-stamp geometry when the row was
-                -- never modified by hand. modified=0 means no manual move/snap.
-                lat        = CASE WHEN assets.modified = 0 THEN excluded.lat ELSE assets.lat END,
-                lng        = CASE WHEN assets.modified = 0 THEN excluded.lng ELSE assets.lng END,
-                min_lat    = CASE WHEN assets.modified = 0 THEN excluded.min_lat ELSE assets.min_lat END,
-                max_lat    = CASE WHEN assets.modified = 0 THEN excluded.max_lat ELSE assets.max_lat END,
-                min_lng    = CASE WHEN assets.modified = 0 THEN excluded.min_lng ELSE assets.min_lng END,
-                max_lng    = CASE WHEN assets.modified = 0 THEN excluded.max_lng ELSE assets.max_lng END,
-                image_path = excluded.image_path,
-                -- Re-import never resurrects rows the user explicitly deleted.
-                deleted    = CASE WHEN assets.deleted = 1 THEN 1 ELSE excluded.deleted END,
-                -- Preserve manual side fixes (modified=1) across re-imports.
-                side       = CASE WHEN assets.modified = 0 THEN excluded.side ELSE assets.side END
-            "#,
-        )
-        .bind(&input.row_id)
-        .bind(&input.asset_name)
-        .bind(&input.video_name)
-        .bind(lat)
-        .bind(lng)
-        .bind(lat)
-        .bind(lat)
-        .bind(lng)
-        .bind(lng)
-        .bind(&input.image_path)
-        .bind(input.deleted as i64)
-        .bind(&side)
-        .execute(&mut *tx)
-        .await
-        .map_err(|e| e.to_string())?;
+        insert_fixed_row(&mut tx, &input).await?;
         count += 1;
     }
     tx.commit().await.map_err(|e| e.to_string())?;
-    // Capture original position once, never overwrite (preserves source-of-truth
-    // through subsequent edits and re-imports).
-    sqlx::query(
-        "UPDATE assets
-         SET orig_lat = COALESCE(orig_lat, lat),
-             orig_lng = COALESCE(orig_lng, lng)
-         WHERE asset_type = 'fixed'",
-    )
-    .execute(&state.pool)
-    .await
-    .map_err(|e| e.to_string())?;
+    stamp_orig_positions(&state.pool).await?;
     apply_scope_after_change(&state.pool).await?;
     Ok(count)
 }
@@ -287,91 +381,90 @@ pub async fn import_range_assets(
     let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
     let mut count = 0usize;
     for input in parsed {
-        let mid_lat = input.coord_lat.to_f64()?;
-        let mid_lng = input.coord_lng.to_f64()?;
-        let s_lat = input.start_coord_lat.to_f64()?;
-        let s_lng = input.start_coord_lng.to_f64()?;
-        let e_lat = input.end_coord_lat.to_f64()?;
-        let e_lng = input.end_coord_lng.to_f64()?;
-        let min_lat = mid_lat.min(s_lat).min(e_lat);
-        let max_lat = mid_lat.max(s_lat).max(e_lat);
-        let min_lng = mid_lng.min(s_lng).min(e_lng);
-        let max_lng = mid_lng.max(s_lng).max(e_lng);
-        // See note in import_fixed_assets: side comes from the JSON only.
-        let side = input.side.as_deref().and_then(normalize_side);
-
-        sqlx::query(
-            r#"
-            INSERT INTO assets (
-                row_id, asset_type, asset_name, video_name,
-                lat, lng, start_lat, start_lng, end_lat, end_lng,
-                min_lat, max_lat, min_lng, max_lng,
-                image_path1, image_path2, image_path3, deleted, side
-            ) VALUES (?, 'range', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(row_id) DO UPDATE SET
-                asset_type   = excluded.asset_type,
-                asset_name   = excluded.asset_name,
-                video_name   = excluded.video_name,
-                -- Preserve user edits: re-stamp geometry only when modified=0.
-                lat          = CASE WHEN assets.modified = 0 THEN excluded.lat ELSE assets.lat END,
-                lng          = CASE WHEN assets.modified = 0 THEN excluded.lng ELSE assets.lng END,
-                start_lat    = CASE WHEN assets.modified = 0 THEN excluded.start_lat ELSE assets.start_lat END,
-                start_lng    = CASE WHEN assets.modified = 0 THEN excluded.start_lng ELSE assets.start_lng END,
-                end_lat      = CASE WHEN assets.modified = 0 THEN excluded.end_lat ELSE assets.end_lat END,
-                end_lng      = CASE WHEN assets.modified = 0 THEN excluded.end_lng ELSE assets.end_lng END,
-                min_lat      = CASE WHEN assets.modified = 0 THEN excluded.min_lat ELSE assets.min_lat END,
-                max_lat      = CASE WHEN assets.modified = 0 THEN excluded.max_lat ELSE assets.max_lat END,
-                min_lng      = CASE WHEN assets.modified = 0 THEN excluded.min_lng ELSE assets.min_lng END,
-                max_lng      = CASE WHEN assets.modified = 0 THEN excluded.max_lng ELSE assets.max_lng END,
-                image_path1  = excluded.image_path1,
-                image_path2  = excluded.image_path2,
-                image_path3  = excluded.image_path3,
-                deleted      = CASE WHEN assets.deleted = 1 THEN 1 ELSE excluded.deleted END,
-                -- Preserve manual side fixes (modified=1) across re-imports.
-                side         = CASE WHEN assets.modified = 0 THEN excluded.side ELSE assets.side END
-            "#,
-        )
-        .bind(&input.row_id)
-        .bind(&input.asset_name)
-        .bind(&input.video_name)
-        .bind(mid_lat)
-        .bind(mid_lng)
-        .bind(s_lat)
-        .bind(s_lng)
-        .bind(e_lat)
-        .bind(e_lng)
-        .bind(min_lat)
-        .bind(max_lat)
-        .bind(min_lng)
-        .bind(max_lng)
-        .bind(&input.image_path1)
-        .bind(&input.image_path2)
-        .bind(&input.image_path3)
-        .bind(input.deleted as i64)
-        .bind(&side)
-        .execute(&mut *tx)
-        .await
-        .map_err(|e| e.to_string())?;
+        insert_range_row(&mut tx, &input).await?;
         count += 1;
     }
     tx.commit().await.map_err(|e| e.to_string())?;
-    sqlx::query(
-        "UPDATE assets
-         SET orig_lat       = COALESCE(orig_lat, lat),
-             orig_lng       = COALESCE(orig_lng, lng),
-             orig_start_lat = COALESCE(orig_start_lat, start_lat),
-             orig_start_lng = COALESCE(orig_start_lng, start_lng),
-             orig_end_lat   = COALESCE(orig_end_lat, end_lat),
-             orig_end_lng   = COALESCE(orig_end_lng, end_lng)
-         WHERE asset_type = 'range'",
-    )
-    .execute(&state.pool)
-    .await
-    .map_err(|e| e.to_string())?;
+    stamp_orig_positions(&state.pool).await?;
     apply_scope_after_change(&state.pool).await?;
     Ok(count)
 }
 
+#[derive(Debug, Serialize)]
+pub struct AutoImportResult {
+    pub fixed: usize,
+    pub range: usize,
+}
+
+/// Auto-detect importer: takes a JSON file containing either
+///   1. A flat `[ { row… }, { row… }, … ]` array where each row may be a
+///      fixed asset (has `coord`) or a range asset (has `start_coord_lat`
+///      etc.); both shapes can be mixed in one file.
+///   2. The round-trip export shape `{ "fixed": [...], "range": [...] }`.
+/// Each row is dispatched per-shape into the same INSERT/ON CONFLICT logic
+/// the type-specific importers use, so re-import preserve-edits semantics
+/// behave identically.
+#[tauri::command]
+pub async fn import_assets_auto(
+    path: String,
+    state: State<'_, AppState>,
+) -> Result<AutoImportResult, String> {
+    let bytes = tokio::fs::read(&path).await.map_err(|e| e.to_string())?;
+    let raw: serde_json::Value =
+        serde_json::from_slice(&bytes).map_err(|e| e.to_string())?;
+    // Two shapes: a top-level array (mixed rows) or the export object.
+    let rows: Vec<serde_json::Value> = match raw {
+        serde_json::Value::Array(a) => a,
+        serde_json::Value::Object(map) => {
+            let mut out: Vec<serde_json::Value> = Vec::new();
+            if let Some(serde_json::Value::Array(a)) = map.get("fixed").cloned() {
+                out.extend(a);
+            }
+            if let Some(serde_json::Value::Array(a)) = map.get("range").cloned() {
+                out.extend(a);
+            }
+            if out.is_empty() {
+                return Err(
+                    "expected an array of rows or an object with `fixed` / `range` arrays"
+                        .into(),
+                );
+            }
+            out
+        }
+        _ => return Err("expected JSON array or object".into()),
+    };
+
+    let mut fixed_count = 0usize;
+    let mut range_count = 0usize;
+    let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
+    for row in rows {
+        // Range assets carry start_coord_* and end_coord_* fields. Use both
+        // to disambiguate from fixed (which has only `coord`). A row that
+        // also carries `coord` is fine — RangeAssetInput's `coord_lat` /
+        // `coord_lng` capture mid; the `coord` field is just ignored.
+        let is_range = row.get("start_coord_lat").is_some()
+            && row.get("end_coord_lat").is_some();
+        if is_range {
+            let input: RangeAssetInput =
+                serde_json::from_value(row).map_err(|e| e.to_string())?;
+            insert_range_row(&mut tx, &input).await?;
+            range_count += 1;
+        } else {
+            let input: FixedAssetInput =
+                serde_json::from_value(row).map_err(|e| e.to_string())?;
+            insert_fixed_row(&mut tx, &input).await?;
+            fixed_count += 1;
+        }
+    }
+    tx.commit().await.map_err(|e| e.to_string())?;
+    stamp_orig_positions(&state.pool).await?;
+    apply_scope_after_change(&state.pool).await?;
+    Ok(AutoImportResult {
+        fixed: fixed_count,
+        range: range_count,
+    })
+}
+
 async fn apply_scope_after_change(pool: &SqlitePool) -> Result<(), String> {
     let geoms = scope::load_geoms(pool).await.map_err(|e| e.to_string())?;
     if geoms.is_empty() {
@@ -653,6 +746,7 @@ pub async fn bulk_translate(
     let by_id: HashMap<i64, &Asset> = rows.iter().map(|a| (a.id, a)).collect();
 
     let mut before_map = serde_json::Map::new();
+    let mut after_map = serde_json::Map::new();
     let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
     let mut changed = 0usize;
     for c in &corrections {
@@ -713,6 +807,18 @@ pub async fn bulk_translate(
         .execute(&mut *tx)
         .await
         .map_err(|e| e.to_string())?;
+        after_map.insert(
+            c.id.to_string(),
+            serde_json::json!({
+                "lat": new_lat,
+                "lng": new_lng,
+                "start_lat": new_slat,
+                "start_lng": new_slng,
+                "end_lat": new_elat,
+                "end_lng": new_elng,
+                "modified": 1,
+            }),
+        );
         changed += 1;
     }
     if changed == 0 {
@@ -720,12 +826,13 @@ pub async fn bulk_translate(
     }
     let ids_json = serde_json::to_string(&ids).map_err(|e| e.to_string())?;
     sqlx::query(
-        "INSERT INTO action_history (action_type, scope, asset_ids, user_id, before, ts)
-         VALUES ('bulk_translate', 'bulk', ?, ?, ?, datetime('now'))",
+        "INSERT INTO action_history (action_type, scope, asset_ids, user_id, before, after, ts)
+         VALUES ('bulk_translate', 'bulk', ?, ?, ?, ?, datetime('now'))",
     )
     .bind(&ids_json)
     .bind(user_id())
     .bind(serde_json::to_string(&before_map).map_err(|e| e.to_string())?)
+    .bind(serde_json::to_string(&after_map).map_err(|e| e.to_string())?)
     .execute(&mut *tx)
     .await
     .map_err(|e| e.to_string())?;
@@ -1504,6 +1611,7 @@ pub struct RoadOut {
     pub id: i64,
     pub name: Option<String>,
     pub geojson: String,
+    pub snap_ignored: bool,
 }
 
 // Generic over the executor: pass &state.pool for reads taken before any
@@ -2830,14 +2938,20 @@ pub async fn list_asset_names(
 
 #[tauri::command]
 pub async fn get_osm_roads(state: State<'_, AppState>) -> Result<Vec<RoadOut>, String> {
-    let rows: Vec<(i64, Option<String>, String)> =
-        sqlx::query_as("SELECT id, name, geojson FROM roads")
-            .fetch_all(&state.pool)
-            .await
-            .map_err(|e| e.to_string())?;
+    let rows: Vec<(i64, Option<String>, String, i64)> = sqlx::query_as(
+        "SELECT id, name, geojson, COALESCE(snap_ignored, 0) FROM roads",
+    )
+    .fetch_all(&state.pool)
+    .await
+    .map_err(|e| e.to_string())?;
     Ok(rows
         .into_iter()
-        .map(|(id, name, geojson)| RoadOut { id, name, geojson })
+        .map(|(id, name, geojson, si)| RoadOut {
+            id,
+            name,
+            geojson,
+            snap_ignored: si != 0,
+        })
         .collect())
 }
 
@@ -2999,9 +3113,9 @@ pub async fn merge_roads_by_name(
     use std::collections::{HashMap, HashSet};
 
     // Pull every named road. Empty / NULL names are skipped (we can't group them).
-    let rows: Vec<(i64, String, String, i64, Option<String>)> = sqlx::query_as(
+    let rows: Vec<(i64, String, String, i64, Option<String>, i64)> = sqlx::query_as(
         "SELECT id, geojson, COALESCE(name, ''), COALESCE(oneway, 0),
-                highway
+                highway, COALESCE(snap_ignored, 0)
          FROM roads
          WHERE name IS NOT NULL AND TRIM(name) <> ''",
     )
@@ -3009,10 +3123,14 @@ pub async fn merge_roads_by_name(
     .await
     .map_err(|e| e.to_string())?;
 
-    // Bucket by name.
-    let mut by_name: HashMap<String, Vec<(i64, LineString<f64>, i64, Option<String>)>> =
-        HashMap::new();
-    for (id, gj, name, ow, hw) in rows {
+    // Bucket by name. Carry snap_ignored alongside oneway/highway so the
+    // merged road can keep the dominant value (otherwise the merged row
+    // silently re-enables snapping for ways the user had muted).
+    let mut by_name: HashMap<
+        String,
+        Vec<(i64, LineString<f64>, i64, Option<String>, i64)>,
+    > = HashMap::new();
+    for (id, gj, name, ow, hw, si) in rows {
         let line = match parse_linestring(&gj) {
             Some(l) => l,
             None => continue,
@@ -3020,7 +3138,7 @@ pub async fn merge_roads_by_name(
         by_name
             .entry(name)
             .or_default()
-            .push((id, line, ow, hw));
+            .push((id, line, ow, hw, si));
     }
 
     // Endpoint keying: round to 5 decimals (~1 m). Two ways are adjacent if
@@ -3044,7 +3162,7 @@ pub async fn merge_roads_by_name(
         let n = ways.len();
         // Map each endpoint key to the list of way indices touching it.
         let mut node_to_ways: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
-        for (i, (_, line, _, _)) in ways.iter().enumerate() {
+        for (i, (_, line, _, _, _)) in ways.iter().enumerate() {
             let s = line.0.first().unwrap();
             let e = line.0.last().unwrap();
             node_to_ways.entry(key(s)).or_default().push(i);
@@ -3153,6 +3271,10 @@ pub async fn merge_roads_by_name(
                 .iter()
                 .find_map(|&i| ways[i].3.clone())
                 .unwrap_or_default();
+            // Preserve snap_ignored: if ANY member of the cluster was muted
+            // for snap, the merged road inherits that — better to err on the
+            // side of "keep the user's mute" than to silently re-enable.
+            let any_ignored = comp.iter().any(|&i| ways[i].4 != 0);
 
             // Compute bbox.
             let mut mn_lat = f64::INFINITY;
@@ -3181,8 +3303,8 @@ pub async fn merge_roads_by_name(
                 "coordinates": coords_array,
             });
             sqlx::query(
-                "INSERT INTO roads(name, geojson, min_lat, max_lat, min_lng, max_lng, oneway, highway)
-                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                "INSERT INTO roads(name, geojson, min_lat, max_lat, min_lng, max_lng, oneway, highway, snap_ignored)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
             )
             .bind(&name)
             .bind(geom.to_string())
@@ -3192,6 +3314,7 @@ pub async fn merge_roads_by_name(
             .bind(mx_lng)
             .bind(dom_ow)
             .bind(&dom_hw)
+            .bind(if any_ignored { 1i64 } else { 0i64 })
             .execute(&mut *tx)
             .await
             .map_err(|e| e.to_string())?;
@@ -3208,6 +3331,335 @@ pub async fn merge_roads_by_name(
     })
 }
 
+/// Merge an explicit set of road ids. Connected clusters become single
+/// LineStrings; non-touching clusters stay as independent merged roads (or
+/// untouched if a cluster has < 2 ways or is branched). Endpoints within
+/// `snap_meters` (default 8 m) of each other are clustered so OSM ways with
+/// near-but-not-touching endpoints can still merge — the resulting geometry
+/// snaps both ends to the cluster centroid so there's no visible gap.
+#[tauri::command]
+pub async fn merge_roads_by_ids(
+    ids: Vec<i64>,
+    snap_meters: Option<f64>,
+    state: State<'_, AppState>,
+) -> Result<MergeRoadsResult, String> {
+    use std::collections::{HashMap, HashSet};
+
+    if ids.is_empty() {
+        return Ok(MergeRoadsResult {
+            names_processed: 0,
+            ways_consumed: 0,
+            merged_into: 0,
+            skipped_branched: 0,
+        });
+    }
+    let snap_m = snap_meters.unwrap_or(8.0).max(0.0);
+    // Load the requested rows. Chunk to stay under the 999-bind ceiling.
+    // Tuple shape: (id, line, oneway, highway, name, snap_ignored).
+    let mut ways: Vec<(
+        i64,
+        LineString<f64>,
+        i64,
+        Option<String>,
+        Option<String>,
+        i64,
+    )> = Vec::with_capacity(ids.len());
+    for chunk in ids.chunks(500) {
+        let placeholders = vec!["?"; chunk.len()].join(",");
+        let sql = format!(
+            "SELECT id, geojson, COALESCE(oneway, 0), highway, name,
+                    COALESCE(snap_ignored, 0)
+             FROM roads WHERE id IN ({})",
+            placeholders
+        );
+        let mut q = sqlx::query_as::<
+            _,
+            (i64, String, i64, Option<String>, Option<String>, i64),
+        >(&sql);
+        for &i in chunk {
+            q = q.bind(i);
+        }
+        let rows = q.fetch_all(&state.pool).await.map_err(|e| e.to_string())?;
+        for (id, gj, ow, hw, nm, si) in rows {
+            if let Some(line) = parse_linestring(&gj) {
+                ways.push((id, line, ow, hw, nm, si));
+            }
+        }
+    }
+    if ways.len() < 2 {
+        return Ok(MergeRoadsResult {
+            names_processed: 0,
+            ways_consumed: 0,
+            merged_into: 0,
+            skipped_branched: 0,
+        });
+    }
+
+    let n = ways.len();
+
+    // Endpoint clustering: greedy spatial-grid pass that joins endpoints
+    // within snap_m. Each endpoint either lands in an existing cluster (≤ snap_m
+    // from its representative) or starts a new one. After clustering, every
+    // way's first/last vertex is rewritten to its cluster's centroid so the
+    // walk produces continuous geometry without visible gaps.
+    let cell_deg = if snap_m > 0.0 {
+        (snap_m / 111_320.0).max(1e-7)
+    } else {
+        1e-7
+    };
+    fn dist_m(a: (f64, f64), b: (f64, f64)) -> f64 {
+        let lat0 = ((a.1 + b.1) * 0.5) * std::f64::consts::PI / 180.0;
+        let dx = (b.0 - a.0) * 111_320.0 * lat0.cos();
+        let dy = (b.1 - a.1) * 111_320.0;
+        (dx * dx + dy * dy).sqrt()
+    }
+    // (sum_x, sum_y, count) per cluster — running centroid so successive
+    // endpoints don't drift the representative away from earlier members.
+    let mut cluster_sum: Vec<(f64, f64, usize)> = vec![];
+    let mut grid: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
+    let mut endpoint_cluster: Vec<usize> = Vec::with_capacity(n * 2);
+    for w in 0..n {
+        for end in 0..2 {
+            let coord = if end == 0 {
+                *ways[w].1 .0.first().unwrap()
+            } else {
+                *ways[w].1 .0.last().unwrap()
+            };
+            let p = (coord.x, coord.y);
+            let gx = (p.0 / cell_deg).floor() as i64;
+            let gy = (p.1 / cell_deg).floor() as i64;
+            let mut found: Option<usize> = None;
+            'search: for dy in -1..=1 {
+                for dx in -1..=1 {
+                    if let Some(cell_clusters) = grid.get(&(gx + dx, gy + dy)) {
+                        for &cid in cell_clusters {
+                            let (sx, sy, c) = cluster_sum[cid];
+                            let centroid = (sx / c as f64, sy / c as f64);
+                            if dist_m(p, centroid) <= snap_m {
+                                found = Some(cid);
+                                break 'search;
+                            }
+                        }
+                    }
+                }
+            }
+            let cid = if let Some(c) = found {
+                let (sx, sy, k) = cluster_sum[c];
+                cluster_sum[c] = (sx + p.0, sy + p.1, k + 1);
+                c
+            } else {
+                let cid = cluster_sum.len();
+                cluster_sum.push((p.0, p.1, 1));
+                grid.entry((gx, gy)).or_default().push(cid);
+                cid
+            };
+            endpoint_cluster.push(cid);
+        }
+    }
+    // Rewrite each way's first/last vertex to its cluster centroid so the
+    // resulting geometry is continuous after the walk.
+    for w in 0..n {
+        let s_cid = endpoint_cluster[w * 2];
+        let e_cid = endpoint_cluster[w * 2 + 1];
+        let (ssx, ssy, sc) = cluster_sum[s_cid];
+        let (esx, esy, ec) = cluster_sum[e_cid];
+        let s_rep = (ssx / sc as f64, ssy / sc as f64);
+        let e_rep = (esx / ec as f64, esy / ec as f64);
+        if let Some(first) = ways[w].1 .0.first_mut() {
+            first.x = s_rep.0;
+            first.y = s_rep.1;
+        }
+        if let Some(last) = ways[w].1 .0.last_mut() {
+            last.x = e_rep.0;
+            last.y = e_rep.1;
+        }
+    }
+    // After clustering every endpoint coord is exact, so the rounded `key()`
+    // collapses both ends of a connection to the same map key. Keeps the rest
+    // of the walk identical to merge_roads_by_name.
+    fn key(c: &Coord<f64>) -> (i64, i64) {
+        ((c.x * 1e5).round() as i64, (c.y * 1e5).round() as i64)
+    }
+    let mut node_to_ways: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
+    for (i, (_, line, _, _, _, _)) in ways.iter().enumerate() {
+        let s = line.0.first().unwrap();
+        let e = line.0.last().unwrap();
+        node_to_ways.entry(key(s)).or_default().push(i);
+        node_to_ways.entry(key(e)).or_default().push(i);
+    }
+
+    let mut ways_consumed = 0usize;
+    let mut merged_into = 0usize;
+    let mut skipped_branched = 0usize;
+    let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
+
+    let mut visited = vec![false; n];
+    for start in 0..n {
+        if visited[start] {
+            continue;
+        }
+        let mut comp: Vec<usize> = vec![];
+        let mut stack = vec![start];
+        while let Some(u) = stack.pop() {
+            if visited[u] {
+                continue;
+            }
+            visited[u] = true;
+            comp.push(u);
+            let line = &ways[u].1;
+            for k in [
+                key(line.0.first().unwrap()),
+                key(line.0.last().unwrap()),
+            ] {
+                if let Some(peers) = node_to_ways.get(&k) {
+                    for &v in peers {
+                        if !visited[v] {
+                            stack.push(v);
+                        }
+                    }
+                }
+            }
+        }
+        if comp.len() < 2 {
+            continue;
+        }
+        let comp_set: HashSet<usize> = comp.iter().copied().collect();
+        let mut deg: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
+        for &i in &comp {
+            let line = &ways[i].1;
+            deg.entry(key(line.0.first().unwrap())).or_default().push(i);
+            deg.entry(key(line.0.last().unwrap())).or_default().push(i);
+        }
+        let max_deg = deg.values().map(|v| v.len()).max().unwrap_or(0);
+        if max_deg > 2 {
+            skipped_branched += 1;
+            continue;
+        }
+        let start_node = deg
+            .iter()
+            .find(|(_, v)| v.len() == 1)
+            .map(|(k, _)| *k)
+            .unwrap_or_else(|| *deg.keys().next().unwrap());
+        let mut ordered_segments: Vec<Vec<Coord<f64>>> = vec![];
+        let mut current_node = start_node;
+        let mut used: HashSet<usize> = HashSet::new();
+        while used.len() < comp.len() {
+            let nexts = deg.get(&current_node).cloned().unwrap_or_default();
+            let pick = nexts
+                .into_iter()
+                .find(|i| !used.contains(i) && comp_set.contains(i));
+            let way_idx = match pick {
+                Some(x) => x,
+                None => break,
+            };
+            used.insert(way_idx);
+            let line = &ways[way_idx].1;
+            let s_key = key(line.0.first().unwrap());
+            let e_key = key(line.0.last().unwrap());
+            let coords: Vec<Coord<f64>> = if s_key == current_node {
+                line.0.clone()
+            } else {
+                line.0.iter().rev().copied().collect()
+            };
+            let next_node = if s_key == current_node { e_key } else { s_key };
+            ordered_segments.push(coords);
+            current_node = next_node;
+        }
+        if used.len() != comp.len() {
+            skipped_branched += 1;
+            continue;
+        }
+        let mut merged: Vec<Coord<f64>> = vec![];
+        for (i, seg) in ordered_segments.into_iter().enumerate() {
+            let start = if i == 0 { 0 } else { 1 };
+            merged.extend(seg.into_iter().skip(start));
+        }
+        if merged.len() < 2 {
+            continue;
+        }
+        // Pick the most common non-empty name across the cluster; fall back
+        // to "" if none has one.
+        let mut name_count: HashMap<String, usize> = HashMap::new();
+        for &i in &comp {
+            if let Some(n) = ways[i].4.as_ref() {
+                let t = n.trim();
+                if !t.is_empty() {
+                    *name_count.entry(t.to_string()).or_default() += 1;
+                }
+            }
+        }
+        let dom_name = name_count
+            .into_iter()
+            .max_by_key(|(_, c)| *c)
+            .map(|(k, _)| k)
+            .unwrap_or_default();
+        let mut ow_count: HashMap<i64, usize> = HashMap::new();
+        for &i in &comp {
+            *ow_count.entry(ways[i].2).or_default() += 1;
+        }
+        let dom_ow = ow_count
+            .into_iter()
+            .max_by_key(|(_, c)| *c)
+            .map(|(k, _)| k)
+            .unwrap_or(0);
+        let dom_hw = comp
+            .iter()
+            .find_map(|&i| ways[i].3.clone())
+            .unwrap_or_default();
+        // Preserve snap_ignored: if any cluster member was muted, the merged
+        // road inherits the mute. Avoids silently re-enabling snap on roads
+        // the user had explicitly excluded.
+        let any_ignored = comp.iter().any(|&i| ways[i].5 != 0);
+        let mut mn_lat = f64::INFINITY;
+        let mut mx_lat = f64::NEG_INFINITY;
+        let mut mn_lng = f64::INFINITY;
+        let mut mx_lng = f64::NEG_INFINITY;
+        for c in &merged {
+            if c.y < mn_lat { mn_lat = c.y; }
+            if c.y > mx_lat { mx_lat = c.y; }
+            if c.x < mn_lng { mn_lng = c.x; }
+            if c.x > mx_lng { mx_lng = c.x; }
+        }
+        for &i in &comp {
+            sqlx::query("DELETE FROM roads WHERE id = ?")
+                .bind(ways[i].0)
+                .execute(&mut *tx)
+                .await
+                .map_err(|e| e.to_string())?;
+        }
+        let coords_array: Vec<[f64; 2]> = merged.iter().map(|c| [c.x, c.y]).collect();
+        let geom = serde_json::json!({
+            "type": "LineString",
+            "coordinates": coords_array,
+        });
+        sqlx::query(
+            "INSERT INTO roads(name, geojson, min_lat, max_lat, min_lng, max_lng, oneway, highway, snap_ignored)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind(if dom_name.is_empty() { None } else { Some(dom_name) })
+        .bind(geom.to_string())
+        .bind(mn_lat)
+        .bind(mx_lat)
+        .bind(mn_lng)
+        .bind(mx_lng)
+        .bind(dom_ow)
+        .bind(if dom_hw.is_empty() { None } else { Some(dom_hw) })
+        .bind(if any_ignored { 1i64 } else { 0i64 })
+        .execute(&mut *tx)
+        .await
+        .map_err(|e| e.to_string())?;
+        ways_consumed += comp.len();
+        merged_into += 1;
+    }
+    tx.commit().await.map_err(|e| e.to_string())?;
+    Ok(MergeRoadsResult {
+        names_processed: 0,
+        ways_consumed,
+        merged_into,
+        skipped_branched,
+    })
+}
+
 #[tauri::command]
 pub async fn export_osm_roads(
     path: String,
@@ -3686,6 +4138,21 @@ pub async fn generate_osm_for_bbox(
     Ok(features.len())
 }
 
+#[tauri::command]
+pub async fn set_road_snap_ignored(
+    id: i64,
+    ignored: bool,
+    state: State<'_, AppState>,
+) -> Result<bool, String> {
+    sqlx::query("UPDATE roads SET snap_ignored = ? WHERE id = ?")
+        .bind(if ignored { 1 } else { 0 })
+        .bind(id)
+        .execute(&state.pool)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(ignored)
+}
+
 #[tauri::command]
 pub async fn flip_road_direction(
     id: i64,
@@ -3922,6 +4389,131 @@ pub async fn simplify_road(
     Ok((before, after))
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RoadSnapshot {
+    pub id: i64,
+    pub name: Option<String>,
+    pub geojson: String,
+    pub oneway: i64,
+    pub highway: Option<String>,
+    pub snap_ignored: i64,
+}
+
+/// Capture the full state of a small set of roads so the frontend can revert
+/// edits via `restore_road_state`. Used by the in-session OSM edit undo
+/// (3-step ring buffer); not part of the global audit log.
+#[tauri::command]
+pub async fn osm_road_snapshot(
+    ids: Vec<i64>,
+    state: State<'_, AppState>,
+) -> Result<Vec<RoadSnapshot>, String> {
+    if ids.is_empty() {
+        return Ok(vec![]);
+    }
+    let mut out: Vec<RoadSnapshot> = Vec::with_capacity(ids.len());
+    for chunk in ids.chunks(500) {
+        let placeholders = vec!["?"; chunk.len()].join(",");
+        let sql = format!(
+            "SELECT id, name, geojson, COALESCE(oneway, 0), highway,
+                    COALESCE(snap_ignored, 0)
+             FROM roads WHERE id IN ({})",
+            placeholders
+        );
+        let mut q = sqlx::query_as::<
+            _,
+            (i64, Option<String>, String, i64, Option<String>, i64),
+        >(&sql);
+        for &i in chunk {
+            q = q.bind(i);
+        }
+        let rows = q.fetch_all(&state.pool).await.map_err(|e| e.to_string())?;
+        for (id, name, geojson, oneway, highway, snap_ignored) in rows {
+            out.push(RoadSnapshot {
+                id,
+                name,
+                geojson,
+                oneway,
+                highway,
+                snap_ignored,
+            });
+        }
+    }
+    Ok(out)
+}
+
+/// Replay a list of snapshots back into `roads`, updating geometry/bbox/tags
+/// for each id. Rows that no longer exist (e.g. consumed by a merge) are
+/// skipped — this undo is not designed to revive merged roads.
+#[tauri::command]
+pub async fn restore_road_state(
+    snapshots: Vec<RoadSnapshot>,
+    state: State<'_, AppState>,
+) -> Result<usize, String> {
+    if snapshots.is_empty() {
+        return Ok(0);
+    }
+    let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
+    let mut applied = 0usize;
+    for s in snapshots {
+        let line = match parse_linestring(&s.geojson) {
+            Some(l) => l,
+            None => continue,
+        };
+        let (mut mn_lat, mut mx_lat) = (f64::INFINITY, f64::NEG_INFINITY);
+        let (mut mn_lng, mut mx_lng) = (f64::INFINITY, f64::NEG_INFINITY);
+        for c in &line.0 {
+            if c.y < mn_lat { mn_lat = c.y; }
+            if c.y > mx_lat { mx_lat = c.y; }
+            if c.x < mn_lng { mn_lng = c.x; }
+            if c.x > mx_lng { mx_lng = c.x; }
+        }
+        let res = sqlx::query(
+            "UPDATE roads
+                SET name = ?, geojson = ?,
+                    min_lat = ?, max_lat = ?, min_lng = ?, max_lng = ?,
+                    oneway = ?, highway = ?, snap_ignored = ?
+              WHERE id = ?",
+        )
+        .bind(&s.name)
+        .bind(&s.geojson)
+        .bind(mn_lat)
+        .bind(mx_lat)
+        .bind(mn_lng)
+        .bind(mx_lng)
+        .bind(s.oneway)
+        .bind(&s.highway)
+        .bind(s.snap_ignored)
+        .bind(s.id)
+        .execute(&mut *tx)
+        .await
+        .map_err(|e| e.to_string())?;
+        if res.rows_affected() > 0 {
+            // Keep R-tree in sync — no UPDATE trigger on roads, so emulate
+            // via delete+insert (matches update_osm_road).
+            sqlx::query("DELETE FROM roads_rtree WHERE id = ?")
+                .bind(s.id)
+                .execute(&mut *tx)
+                .await
+                .map_err(|e| e.to_string())?;
+            sqlx::query(
+                "INSERT INTO roads_rtree(id, min_lat, max_lat, min_lng, max_lng)
+                 VALUES (?, ?, ?, ?, ?)",
+            )
+            .bind(s.id)
+            .bind(mn_lat)
+            .bind(mx_lat)
+            .bind(mn_lng)
+            .bind(mx_lng)
+            .execute(&mut *tx)
+            .await
+            .map_err(|e| e.to_string())?;
+            applied += 1;
+        }
+    }
+    tx.commit().await.map_err(|e| e.to_string())?;
+    Ok(applied)
+}
+
 #[tauri::command]
 pub async fn update_osm_road(
     id: i64,
@@ -4010,6 +4602,87 @@ fn parse_linestring(geojson: &str) -> Option<LineString<f64>> {
     Some(LineString(out))
 }
 
+/// Spatial grid over flattened road segments for the bulk snap path. Each
+/// segment is bucketed into every cell its bbox intersects; the per-asset
+/// query gathers segment indices from the cell containing the asset plus a
+/// 1-ring neighbourhood, so any segment within `max_d` of the asset is
+/// guaranteed to be in the candidate set. Cuts bulk snap from
+/// O(assets × all_segments) to O(assets × segments_per_cell).
+struct SnapIndex {
+    segments: Vec<(Coord<f64>, Coord<f64>, i32)>,
+    grid: std::collections::HashMap<(i64, i64), Vec<usize>>,
+    cell_deg: f64,
+}
+
+impl SnapIndex {
+    fn build(roads: &[(LineString<f64>, i32)], max_d: f64) -> Self {
+        // cell ≈ max_d in latitude — the 3×3 query then spans 3·max_d, which
+        // comfortably covers any segment within max_d of the asset.
+        let cell_deg = (max_d / 111_320.0).max(1e-7);
+        let mut segments: Vec<(Coord<f64>, Coord<f64>, i32)> = Vec::new();
+        let mut grid: std::collections::HashMap<(i64, i64), Vec<usize>> =
+            std::collections::HashMap::new();
+        for (line, ow) in roads {
+            for seg in line.lines() {
+                let idx = segments.len();
+                segments.push((seg.start, seg.end, *ow));
+                let mn_lat = seg.start.y.min(seg.end.y);
+                let mx_lat = seg.start.y.max(seg.end.y);
+                let mn_lng = seg.start.x.min(seg.end.x);
+                let mx_lng = seg.start.x.max(seg.end.x);
+                let gy0 = (mn_lat / cell_deg).floor() as i64;
+                let gy1 = (mx_lat / cell_deg).floor() as i64;
+                let gx0 = (mn_lng / cell_deg).floor() as i64;
+                let gx1 = (mx_lng / cell_deg).floor() as i64;
+                for gy in gy0..=gy1 {
+                    for gx in gx0..=gx1 {
+                        grid.entry((gx, gy)).or_default().push(idx);
+                    }
+                }
+            }
+        }
+        Self {
+            segments,
+            grid,
+            cell_deg,
+        }
+    }
+
+    fn candidates(
+        &self,
+        lng: f64,
+        lat: f64,
+    ) -> Vec<(Coord<f64>, Coord<f64>, i32)> {
+        let gx = (lng / self.cell_deg).floor() as i64;
+        let gy = (lat / self.cell_deg).floor() as i64;
+        // Cell is `cell_deg` wide in BOTH lat and lng degrees, but lng-degrees
+        // shrink in metres as |lat| → 90. The ring in lat is fine at 1
+        // (cell_deg ≈ max_d in metres). For lng, span one cell in metres is
+        // `cell_deg × 111_320 × cos(lat)` = `max_d × cos(lat)`, so we need
+        // ring_lng cells such that `ring_lng × max_d × cos(lat) ≥ max_d`,
+        // i.e. ring_lng ≥ 1/cos(lat). Floor at 1, clamp at a sane upper to
+        // avoid pathological lookups very close to the poles.
+        let cos_l = (lat * std::f64::consts::PI / 180.0)
+            .cos()
+            .abs()
+            .max(0.05);
+        let ring_lng = (1.0 / cos_l).ceil() as i64;
+        let ring_lng = ring_lng.max(1).min(20);
+        let ring_lat: i64 = 1;
+        let mut idxs: Vec<usize> = Vec::new();
+        for dy in -ring_lat..=ring_lat {
+            for dx in -ring_lng..=ring_lng {
+                if let Some(v) = self.grid.get(&(gx + dx, gy + dy)) {
+                    idxs.extend(v.iter().copied());
+                }
+            }
+        }
+        idxs.sort_unstable();
+        idxs.dedup();
+        idxs.into_iter().map(|i| self.segments[i]).collect()
+    }
+}
+
 /// Snap a single (lng, lat) to the closest segment in `candidates`, then
 /// apply a side-aware perpendicular offset. Returns Ok((new_lat, new_lng))
 /// when the closest road is within `max_d`. The sign convention:
@@ -4025,26 +4698,40 @@ fn snap_point_with_offset(
     offset: f64,
     max_d: f64,
 ) -> Result<(f64, f64), String> {
+    let segs = candidates.iter().flat_map(|(l, ow)| {
+        l.lines().map(move |s| (s.start, s.end, *ow))
+    });
+    snap_point_with_segments(segs, side, metadata_track, lng, lat, offset, max_d)
+}
+
+/// Generic segment-iterating core used by both `snap_point_with_offset`
+/// (single asset, R-tree pre-filtered) and the bulk snap path with a
+/// `SnapIndex` that pre-filters segments via a spatial grid. Avoids the
+/// O(assets × roads × segments) blow-up of the bulk snap by giving each
+/// asset only the segments in its 3×3 grid neighbourhood.
+fn snap_point_with_segments<I>(
+    segs: I,
+    side: Option<&str>,
+    metadata_track: Option<&[[f64; 2]]>,
+    lng: f64,
+    lat: f64,
+    offset: f64,
+    max_d: f64,
+) -> Result<(f64, f64), String>
+where
+    I: IntoIterator<Item = (Coord<f64>, Coord<f64>, i32)>,
+{
     let pt = Point::new(lng, lat);
-    // Track best snap, the segment endpoints, and the road's oneway tag.
     let mut best: Option<(f64, Point<f64>, (f64, f64), (f64, f64), i32)> = None;
-    for (line, ow) in candidates {
-        for seg in line.lines() {
-            let seg_ls = LineString(vec![seg.start, seg.end]);
-            let snapped = match seg_ls.closest_point(&pt) {
-                Closest::SinglePoint(p) | Closest::Intersection(p) => p,
-                _ => continue,
-            };
-            let d = Geodesic.distance(pt, snapped);
-            if best.as_ref().map(|b| d < b.0).unwrap_or(true) {
-                best = Some((
-                    d,
-                    snapped,
-                    (seg.start.x, seg.start.y),
-                    (seg.end.x, seg.end.y),
-                    *ow,
-                ));
-            }
+    for (start, end, ow) in segs {
+        let seg_ls = LineString(vec![start, end]);
+        let snapped = match seg_ls.closest_point(&pt) {
+            Closest::SinglePoint(p) | Closest::Intersection(p) => p,
+            _ => continue,
+        };
+        let d = Geodesic.distance(pt, snapped);
+        if best.as_ref().map(|b| d < b.0).unwrap_or(true) {
+            best = Some((d, snapped, (start.x, start.y), (end.x, end.y), ow));
         }
     }
     let (dist, sp, seg_start, seg_end, oneway) =
@@ -4191,7 +4878,8 @@ pub async fn snap_to_road(
     let candidate_rows: Vec<(i64, String, i64)> = sqlx::query_as(
         "SELECT r.id, r.geojson, COALESCE(r.oneway, 0)
          FROM roads r JOIN roads_rtree x ON x.id = r.id
-         WHERE x.max_lat >= ? AND x.min_lat <= ? AND x.max_lng >= ? AND x.min_lng <= ?",
+         WHERE x.max_lat >= ? AND x.min_lat <= ? AND x.max_lng >= ? AND x.min_lng <= ?
+           AND COALESCE(r.snap_ignored, 0) = 0",
     )
     .bind(bbox_min_lat - pad_lat)
     .bind(bbox_max_lat + pad_lat)
@@ -4344,18 +5032,23 @@ pub async fn snap_assets_in_bbox(
     let centerline: std::collections::HashSet<String> =
         centerline_names.unwrap_or_default().into_iter().collect();
 
-    let road_rows: Vec<(i64, String, i64)> =
-        sqlx::query_as("SELECT id, geojson, COALESCE(oneway, 0) FROM roads")
-            .fetch_all(&state.pool)
-            .await
-            .map_err(|e| e.to_string())?;
+    let road_rows: Vec<(i64, String, i64)> = sqlx::query_as(
+        "SELECT id, geojson, COALESCE(oneway, 0) FROM roads
+         WHERE COALESCE(snap_ignored, 0) = 0",
+    )
+    .fetch_all(&state.pool)
+    .await
+    .map_err(|e| e.to_string())?;
     if road_rows.is_empty() {
-        return Err("no roads loaded — import OSM first".into());
+        return Err("no snap-eligible roads loaded — import OSM first or unmute roads".into());
     }
     let roads: Vec<(LineString<f64>, i32)> = road_rows
         .into_iter()
         .filter_map(|(_, gj, ow)| parse_linestring(&gj).map(|l| (l, ow as i32)))
         .collect();
+    // Build the spatial index ONCE for the whole bulk operation. Each asset
+    // vertex then queries a 3×3 grid window instead of scanning every road.
+    let snap_index = SnapIndex::build(&roads, max_d);
 
     let assets: Vec<Asset> = if let Some(vname) = video_name.as_deref() {
         sqlx::query_as(
@@ -4439,8 +5132,9 @@ pub async fn snap_assets_in_bbox(
         let mut bail = false;
         let mut too_far = false;
         for (label, vlat, vlng) in &targets {
-            match snap_point_with_offset(
-                &roads,
+            let cands = snap_index.candidates(*vlng, *vlat);
+            match snap_point_with_segments(
+                cands,
                 side,
                 track,
                 *vlng,
@@ -4593,16 +5287,77 @@ pub async fn reset_database(state: State<'_, AppState>) -> Result<(), String> {
         .execute(&mut *tx)
         .await
         .map_err(|e| e.to_string())?;
+    sqlx::query("DELETE FROM video_metadata")
+        .execute(&mut *tx)
+        .await
+        .map_err(|e| e.to_string())?;
     tx.commit().await.map_err(|e| e.to_string())?;
     Ok(())
 }
 
+#[tauri::command]
+pub async fn save_video_metadata(
+    tracks: std::collections::HashMap<String, Vec<[f64; 2]>>,
+    state: State<'_, AppState>,
+) -> Result<usize, String> {
+    let mut tx = state.pool.begin().await.map_err(|e| e.to_string())?;
+    sqlx::query("DELETE FROM video_metadata")
+        .execute(&mut *tx)
+        .await
+        .map_err(|e| e.to_string())?;
+    let mut written = 0usize;
+    for (name, track) in &tracks {
+        let json = serde_json::to_string(track).map_err(|e| e.to_string())?;
+        sqlx::query("INSERT INTO video_metadata(video_name, track_json) VALUES (?, ?)")
+            .bind(name)
+            .bind(&json)
+            .execute(&mut *tx)
+            .await
+            .map_err(|e| e.to_string())?;
+        written += 1;
+    }
+    tx.commit().await.map_err(|e| e.to_string())?;
+    Ok(written)
+}
+
+#[tauri::command]
+pub async fn get_video_metadata(
+    state: State<'_, AppState>,
+) -> Result<std::collections::HashMap<String, Vec<[f64; 2]>>, String> {
+    let rows: Vec<(String, String)> =
+        sqlx::query_as("SELECT video_name, track_json FROM video_metadata")
+            .fetch_all(&state.pool)
+            .await
+            .map_err(|e| e.to_string())?;
+    let mut out: std::collections::HashMap<String, Vec<[f64; 2]>> =
+        std::collections::HashMap::with_capacity(rows.len());
+    for (name, json) in rows {
+        match serde_json::from_str::<Vec<[f64; 2]>>(&json) {
+            Ok(track) => {
+                out.insert(name, track);
+            }
+            Err(_) => continue,
+        }
+    }
+    Ok(out)
+}
+
+#[tauri::command]
+pub async fn clear_video_metadata(state: State<'_, AppState>) -> Result<usize, String> {
+    let res = sqlx::query("DELETE FROM video_metadata")
+        .execute(&state.pool)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(res.rows_affected() as usize)
+}
+
 #[derive(Debug, Serialize)]
 pub struct DataSourceCounts {
     pub fixed_assets: i64,
     pub range_assets: i64,
     pub osm_roads: i64,
     pub scope_features: i64,
+    pub video_metadata: i64,
 }
 
 #[tauri::command]
@@ -4627,11 +5382,16 @@ pub async fn data_source_counts(
         .fetch_one(&state.pool)
         .await
         .map_err(|e| e.to_string())?;
+    let (vmeta,): (i64,) = sqlx::query_as("SELECT COUNT(*) FROM video_metadata")
+        .fetch_one(&state.pool)
+        .await
+        .map_err(|e| e.to_string())?;
     Ok(DataSourceCounts {
         fixed_assets: fixed,
         range_assets: range,
         osm_roads: roads,
         scope_features: scope,
+        video_metadata: vmeta,
     })
 }
 
@@ -5096,6 +5856,53 @@ pub async fn redo_action(action_id: i64, state: State<'_, AppState>) -> Result<(
                 .map_err(|e| e.to_string())?;
             }
         }
+        "bulk_translate" => {
+            // Re-apply the post-translate state captured at action time.
+            let after_map: serde_json::Map<String, serde_json::Value> =
+                serde_json::from_str(row.after.as_deref().unwrap_or("{}"))
+                    .map_err(|e| e.to_string())?;
+            for (id_str, val) in after_map {
+                let id: i64 = id_str.parse().map_err(|_| "bad id".to_string())?;
+                let lat = val.get("lat").and_then(|v| v.as_f64());
+                let lng = val.get("lng").and_then(|v| v.as_f64());
+                let slat = val.get("start_lat").and_then(|v| v.as_f64());
+                let slng = val.get("start_lng").and_then(|v| v.as_f64());
+                let elat = val.get("end_lat").and_then(|v| v.as_f64());
+                let elng = val.get("end_lng").and_then(|v| v.as_f64());
+                let lats: Vec<f64> = [lat, slat, elat].into_iter().flatten().collect();
+                let lngs: Vec<f64> = [lng, slng, elng].into_iter().flatten().collect();
+                if lats.is_empty() || lngs.is_empty() {
+                    continue;
+                }
+                let mn_lat = lats.iter().cloned().fold(f64::INFINITY, f64::min);
+                let mx_lat = lats.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+                let mn_lng = lngs.iter().cloned().fold(f64::INFINITY, f64::min);
+                let mx_lng = lngs.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+                sqlx::query(
+                    "UPDATE assets SET
+                        lat = ?, lng = ?, start_lat = ?, start_lng = ?,
+                        end_lat = ?, end_lng = ?,
+                        min_lat = ?, max_lat = ?, min_lng = ?, max_lng = ?,
+                        modified = 1, modified_by = ?, modified_at = datetime('now')
+                     WHERE id = ?",
+                )
+                .bind(lat)
+                .bind(lng)
+                .bind(slat)
+                .bind(slng)
+                .bind(elat)
+                .bind(elng)
+                .bind(mn_lat)
+                .bind(mx_lat)
+                .bind(mn_lng)
+                .bind(mx_lng)
+                .bind(user_id())
+                .bind(id)
+                .execute(&mut *tx)
+                .await
+                .map_err(|e| e.to_string())?;
+            }
+        }
         other => return Err(format!("unknown action_type: {}", other)),
     }
     sqlx::query("UPDATE action_history SET undone = 0 WHERE id = ?")
@@ -5163,3 +5970,197 @@ pub async fn get_assets_in_bbox(
         .await
         .map_err(|e| e.to_string())
 }
+
+#[derive(Debug, Serialize, sqlx::FromRow)]
+pub struct AssetCoord {
+    pub id: i64,
+    pub lat: Option<f64>,
+    pub lng: Option<f64>,
+}
+
+#[tauri::command]
+pub async fn assets_coords_for_ids(
+    ids: Vec<i64>,
+    state: State<'_, AppState>,
+) -> Result<Vec<AssetCoord>, String> {
+    let mut out: Vec<AssetCoord> = Vec::with_capacity(ids.len());
+    for chunk in ids.chunks(500) {
+        let placeholders = vec!["?"; chunk.len()].join(",");
+        let sql = format!(
+            "SELECT id, lat, lng FROM assets WHERE id IN ({})",
+            placeholders
+        );
+        let mut q = sqlx::query_as::<_, AssetCoord>(&sql);
+        for id in chunk {
+            q = q.bind(id);
+        }
+        let part = q
+            .fetch_all(&state.pool)
+            .await
+            .map_err(|e| e.to_string())?;
+        out.extend(part);
+    }
+    Ok(out)
+}
+
+// ----------------------------------------------------------------------------
+// Quality report — surfaces the most common data-issue categories so users
+// can audit a dataset proactively instead of stumbling on problems while
+// reviewing. MVP: moved-far, impossible row_id jumps, missing side.
+// ----------------------------------------------------------------------------
+
+#[derive(Debug, Serialize)]
+pub struct QualityReport {
+    /// Modified rows whose current position is > moved_threshold_m from
+    /// the original (import-time) position.
+    pub moved_far: Vec<i64>,
+    /// Rows whose current position is > metadata_threshold_m from the
+    /// nearest segment of their video's metadata polyline. Only checked
+    /// for videos whose metadata has been loaded — otherwise skipped.
+    pub far_from_metadata: Vec<i64>,
+    /// Rows with `side IS NULL`.
+    pub missing_side: Vec<i64>,
+    pub moved_far_total: usize,
+    pub far_from_metadata_total: usize,
+    pub missing_side_total: usize,
+}
+
+// Cheap haversine in metres — fine at the thresholds we're checking.
+fn hav_m(a_lat: f64, a_lng: f64, b_lat: f64, b_lng: f64) -> f64 {
+    let r = 6_371_000.0_f64;
+    let p1 = a_lat.to_radians();
+    let p2 = b_lat.to_radians();
+    let dp = (b_lat - a_lat).to_radians();
+    let dl = (b_lng - a_lng).to_radians();
+    let s = (dp / 2.0).sin().powi(2)
+        + p1.cos() * p2.cos() * (dl / 2.0).sin().powi(2);
+    2.0 * r * s.sqrt().asin()
+}
+
+#[tauri::command]
+pub async fn quality_report(
+    moved_threshold_m: Option<f64>,
+    metadata_threshold_m: Option<f64>,
+    metadata: Option<std::collections::HashMap<String, Vec<[f64; 2]>>>,
+    cap: Option<usize>,
+    state: State<'_, AppState>,
+) -> Result<QualityReport, String> {
+    // Defaults — conservative so you only see real signal. The
+    // outlier-from-neighbours check was dropped: without a real reference
+    // (which the metadata polyline already provides) the only honest
+    // signal is far-from-metadata; gap- or chord-based heuristics produce
+    // thousands of false positives on multimodal / curved / cross-side
+    // data and aren't worth the noise.
+    let moved_t = moved_threshold_m.unwrap_or(50.0);
+    let metadata_t = metadata_threshold_m.unwrap_or(30.0);
+    let cap = cap.unwrap_or(500);
+    let metadata = metadata.unwrap_or_default();
+
+    // --- Moved far from import ---
+    // modified=1 means the user has touched this row. We compare current vs
+    // orig coords; rows without orig (pre-migration data) are skipped.
+    let moved_rows: Vec<(i64, Option<f64>, Option<f64>, Option<f64>, Option<f64>)> =
+        sqlx::query_as(
+            "SELECT id, lat, lng, orig_lat, orig_lng
+             FROM assets
+             WHERE deleted = 0 AND modified = 1
+                   AND lat IS NOT NULL AND lng IS NOT NULL
+                   AND orig_lat IS NOT NULL AND orig_lng IS NOT NULL",
+        )
+        .fetch_all(&state.pool)
+        .await
+        .map_err(|e| e.to_string())?;
+    let mut moved_far: Vec<i64> = Vec::new();
+    let mut moved_far_total: usize = 0;
+    for (id, lat, lng, ol, og) in moved_rows {
+        if let (Some(la), Some(ln), Some(ola), Some(olg)) = (lat, lng, ol, og) {
+            if hav_m(la, ln, ola, olg) >= moved_t {
+                moved_far_total += 1;
+                if moved_far.len() < cap {
+                    moved_far.push(id);
+                }
+            }
+        }
+    }
+
+    // --- Missing side ---
+    let missing_rows: Vec<(i64,)> = sqlx::query_as(
+        "SELECT id FROM assets WHERE deleted = 0 AND side IS NULL",
+    )
+    .fetch_all(&state.pool)
+    .await
+    .map_err(|e| e.to_string())?;
+    let missing_side_total = missing_rows.len();
+    let missing_side: Vec<i64> = missing_rows
+        .into_iter()
+        .take(cap)
+        .map(|(id,)| id)
+        .collect();
+
+    // --- Pull every live asset once for the next two checks. ---
+    let video_rows: Vec<(i64, String, String, Option<f64>, Option<f64>)> =
+        sqlx::query_as(
+            "SELECT id, video_name, row_id, lat, lng
+             FROM assets
+             WHERE deleted = 0
+                   AND lat IS NOT NULL AND lng IS NOT NULL",
+        )
+        .fetch_all(&state.pool)
+        .await
+        .map_err(|e| e.to_string())?;
+    use std::collections::HashMap;
+    let mut by_video: HashMap<String, Vec<(i64, String, f64, f64)>> =
+        HashMap::new();
+    for (id, video, row_id, lat, lng) in video_rows {
+        if let (Some(la), Some(ln)) = (lat, lng) {
+            by_video.entry(video).or_default().push((id, row_id, la, ln));
+        }
+    }
+
+    // --- Far from metadata polyline ---
+    // Per-asset min point-to-segment distance to the asset's video's
+    // metadata track. `metadata` arrives as `{video_name: [[lng, lat], ...]}`.
+    // Skipped silently when the asset's video has no metadata loaded.
+    let mut far_from_metadata: Vec<i64> = Vec::new();
+    let mut far_from_metadata_total: usize = 0;
+    for (video, rows) in &by_video {
+        let Some(track) = metadata.get(video) else {
+            continue;
+        };
+        if track.len() < 2 {
+            continue;
+        }
+        for (id, _row_id, lat, lng) in rows {
+            let mut min_d = f64::INFINITY;
+            for w in track.windows(2) {
+                let d = point_segment_distance_m(
+                    *lng, *lat, w[0][0], w[0][1], w[1][0], w[1][1],
+                );
+                if d < min_d {
+                    min_d = d;
+                    if min_d < 1.0 {
+                        break;
+                    }
+                }
+            }
+            if min_d.is_finite() && min_d >= metadata_t {
+                far_from_metadata_total += 1;
+                if far_from_metadata.len() < cap {
+                    far_from_metadata.push(*id);
+                }
+            }
+        }
+    }
+
+    // by_video was used only by the dropped outlier check; release it.
+    drop(by_video);
+
+    Ok(QualityReport {
+        moved_far,
+        far_from_metadata,
+        missing_side,
+        moved_far_total,
+        far_from_metadata_total,
+        missing_side_total,
+    })
+}
diff --git a/src-tauri/src/db.rs b/src-tauri/src/db.rs
index 18f6cfb..7de168c 100644
--- a/src-tauri/src/db.rs
+++ b/src-tauri/src/db.rs
@@ -104,6 +104,10 @@ async fn apply_schema(pool: &SqlitePool) -> Result<()> {
     let _ = sqlx::query("ALTER TABLE roads ADD COLUMN highway TEXT")
         .execute(pool)
         .await;
+    let _ =
+        sqlx::query("ALTER TABLE roads ADD COLUMN snap_ignored INTEGER NOT NULL DEFAULT 0")
+            .execute(pool)
+            .await;
     sqlx::query(
         "CREATE TABLE IF NOT EXISTS users (
             id            INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -181,15 +185,16 @@ async fn apply_schema(pool: &SqlitePool) -> Result<()> {
 
     sqlx::query(
         "CREATE TABLE IF NOT EXISTS roads (
-            id       INTEGER PRIMARY KEY AUTOINCREMENT,
-            name     TEXT,
-            geojson  TEXT NOT NULL,
-            min_lat  REAL NOT NULL,
-            max_lat  REAL NOT NULL,
-            min_lng  REAL NOT NULL,
-            max_lng  REAL NOT NULL,
-            oneway   INTEGER NOT NULL DEFAULT 0,
-            highway  TEXT
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            name         TEXT,
+            geojson      TEXT NOT NULL,
+            min_lat      REAL NOT NULL,
+            max_lat      REAL NOT NULL,
+            min_lng      REAL NOT NULL,
+            max_lng      REAL NOT NULL,
+            oneway       INTEGER NOT NULL DEFAULT 0,
+            highway      TEXT,
+            snap_ignored INTEGER NOT NULL DEFAULT 0
         )",
     )
     .execute(pool)
@@ -219,6 +224,18 @@ async fn apply_schema(pool: &SqlitePool) -> Result<()> {
     .execute(pool)
     .await?;
 
+    // Per-video metadata polylines persisted across sessions; survives app
+    // restarts, wiped only by reset_database or explicit clear.
+    sqlx::query(
+        "CREATE TABLE IF NOT EXISTS video_metadata (
+            video_name  TEXT PRIMARY KEY,
+            track_json  TEXT NOT NULL,
+            imported_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )",
+    )
+    .execute(pool)
+    .await?;
+
     sqlx::query(
         "CREATE TABLE IF NOT EXISTS action_history (
             id          INTEGER PRIMARY KEY AUTOINCREMENT,
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 9ac0e8e..b0c50b0 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -4,15 +4,18 @@ mod scope;
 
 use commands::{
     assets_bbox, delete_asset, delete_assets_by_video, get_assets_in_bbox, get_osm_roads,
-    get_scope_polygons, import_fixed_assets, import_kml_scope, import_osm_geojson,
+    get_scope_polygons, import_assets_auto, import_fixed_assets, import_kml_scope,
+    import_osm_geojson,
     import_range_assets, list_assets, read_video_polylines_json, list_recent_actions, merge_polylines, reset_assets_to_original,
     read_metadata_polyline, redo_action, reset_database, snap_assets_in_bbox,
     add_class, auto_link_in_polygon, bulk_translate, clear_assets_by_type,
     clear_osm_roads, clear_scope_polygons, data_source_counts, change_assets_side, clear_link, clear_manual_scope,
     create_osm_road, create_user, delete_road_vertices, set_link, simplify_road,
     delete_roads_by_highway, export_osm_roads, find_duplicate_clusters,
+    save_video_metadata, get_video_metadata, clear_video_metadata,
     flip_road_direction, generate_osm_for_bbox, generate_osm_near_assets,
-    list_road_classes, merge_roads_by_name,
+    set_road_snap_ignored, osm_road_snapshot, restore_road_state,
+    list_road_classes, merge_roads_by_name, merge_roads_by_ids, quality_report, assets_coords_for_ids,
     delete_assets_bulk, delete_osm_road, delete_user, export_assets,
     list_asset_names, list_classes, list_users, list_video_names,
     rename_assets, restore_assets, set_assets_by_video_in_scope,
@@ -45,6 +48,7 @@ pub fn run() {
         .invoke_handler(tauri::generate_handler![
             import_fixed_assets,
             import_range_assets,
+            import_assets_auto,
             list_assets,
             get_assets_in_bbox,
             update_asset_position,
@@ -87,11 +91,17 @@ pub fn run() {
             delete_roads_by_highway,
             list_road_classes,
             merge_roads_by_name,
+            merge_roads_by_ids,
             export_osm_roads,
             generate_osm_for_bbox,
             generate_osm_near_assets,
             assets_bbox,
+            quality_report,
+            assets_coords_for_ids,
             flip_road_direction,
+            set_road_snap_ignored,
+            osm_road_snapshot,
+            restore_road_state,
             change_assets_side,
             auto_link_in_polygon,
             bulk_translate,
@@ -99,6 +109,9 @@ pub fn run() {
             clear_osm_roads,
             clear_scope_polygons,
             data_source_counts,
+            save_video_metadata,
+            get_video_metadata,
+            clear_video_metadata,
             set_link,
             clear_link
         ])
diff --git a/src/App.tsx b/src/App.tsx
index 311496d..b2235bc 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -6,6 +6,7 @@ const IMAGE_FOLDER_KEY = "kml_map_tool.image_folder";
 const POPUP_SIZE_KEY = "kml_map_tool.popup_size";
 const POPUP_ENABLED_KEY = "kml_map_tool.popup_enabled";
 const POPUP_ASPECT_KEY = "kml_map_tool.popup_aspect";
+const QUALITY_OFF_TRACK_KEY = "kml_map_tool.quality_off_track_m";
 const PERF_MODE_KEY = "kml_map_tool.perf_mode";
 
 type PopupSize = "S" | "M" | "L" | "XL";
@@ -37,6 +38,7 @@ import {
   LayerVisibility,
   OsmRoadFC,
 } from "./MapView";
+import { LensView } from "./LensView";
 import { BASEMAPS, DEFAULT_BASEMAP_ID } from "./basemaps";
 import type { ActionRow, Asset, ScopePolygon } from "./types";
 import "./App.css";
@@ -249,6 +251,41 @@ function AppShell({
     range: true,
   });
   const [settingsOpen, setSettingsOpen] = useState<boolean>(false);
+  // Cursor-following magnifier. Toggle from the right-side panel; ESC exits.
+  // While active, the main map fires onCursorWorld and we render LensView at
+  // (cursorScreen.x + offset, cursorScreen.y + offset) showing the world at
+  // viewport.zoom + LENS_ZOOM_DELTA.
+  const [lensActive, setLensActive] = useState<boolean>(false);
+  const [cursorWorld, setCursorWorld] = useState<{
+    lng: number;
+    lat: number;
+  } | null>(null);
+  const [cursorScreen, setCursorScreen] = useState<{
+    x: number;
+    y: number;
+  } | null>(null);
+  // rAF throttle: mousemove fires up to 60+ Hz; coalescing to one React state
+  // commit per animation frame keeps the lens setCenter cheap and avoids the
+  // App tree thrashing on every pixel of pointer movement.
+  const lensPendingRef = useRef<{
+    lng: number;
+    lat: number;
+    x: number;
+    y: number;
+  } | null>(null);
+  const lensRafRef = useRef<number | null>(null);
+  useEffect(() => {
+    return () => {
+      if (lensRafRef.current !== null)
+        cancelAnimationFrame(lensRafRef.current);
+    };
+  }, []);
+  const [qualityOffTrackM, setQualityOffTrackM] = useState<number>(() => {
+    if (typeof window === "undefined") return 30;
+    const v = window.localStorage.getItem(QUALITY_OFF_TRACK_KEY);
+    const n = v ? parseFloat(v) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : 30;
+  });
   const [popupSize, setPopupSize] = useState<PopupSize>(() => {
     if (typeof window === "undefined") return "L";
     const v = window.localStorage.getItem(POPUP_SIZE_KEY) as PopupSize | null;
@@ -272,6 +309,37 @@ function AppShell({
     return window.localStorage.getItem(PERF_MODE_KEY) === "1";
   });
   const [osmFetchActive, setOsmFetchActive] = useState<boolean>(false);
+  // Data-quality dashboard. Counts + sample id lists per category. Refreshed
+  // on demand via the Quality panel (not auto-recomputed — too expensive at
+  // 50 k+ assets).
+  type QualityReport = {
+    moved_far: number[];
+    far_from_metadata: number[];
+    missing_side: number[];
+    moved_far_total: number;
+    far_from_metadata_total: number;
+    missing_side_total: number;
+  };
+  const [qualityReport, setQualityReport] = useState<QualityReport | null>(
+    null,
+  );
+  const [qualityLoading, setQualityLoading] = useState<boolean>(false);
+  const [qualityHighlight, setQualityHighlight] = useState<number[]>([]);
+  // Step-through state for the Quality View action: cycle one issue at a
+  // time, zoomed in tight, with Prev/Next buttons. The bbox-fit approach
+  // didn't work for issues 50 km apart — z=8 is unreadable.
+  const [qualityStep, setQualityStep] = useState<{
+    label: string;
+    coords: Array<{ id: number; lat: number; lng: number }>;
+    idx: number;
+  } | null>(null);
+  // Toast shown after a snap operation reporting whether the snap left
+  // the data clean. Total = sum of the three Quality categories.
+  const [snapQualityToast, setSnapQualityToast] = useState<{
+    label: string;
+    total: number;
+    breakdown: { moved: number; offTrack: number; missingSide: number };
+  } | null>(null);
   const [filters, setFilters] = useState<Filters>({
     videos: new Set(),
     sides: new Set(),
@@ -291,12 +359,93 @@ function AppShell({
   const [allAssetNames, setAllAssetNames] = useState<string[]>([]);
   const [osmEditMode, setOsmEditMode] = useState<boolean>(false);
   const [editingRoadId, setEditingRoadId] = useState<number | null>(null);
+  // Multi-select + temporary hide for the focused-video OSM workflow. Both
+  // sets are session-only: cleared when leaving OSM edit mode or switching
+  // the focused video.
+  const [selectedRoadIds, setSelectedRoadIds] = useState<Set<number>>(
+    new Set(),
+  );
+  const [hiddenRoadIds, setHiddenRoadIds] = useState<Set<number>>(new Set());
   // Reset the marked-vertex set whenever the user switches roads or leaves
   // OSM-edit mode. Indices are road-relative, so they're meaningless across
   // roads.
   useEffect(() => {
     setMarkedVertices(new Set());
   }, [editingRoadId, osmEditMode]);
+  useEffect(() => {
+    if (!osmEditMode) {
+      setSelectedRoadIds(new Set());
+      setHiddenRoadIds(new Set());
+      setOsmUndoStack([]);
+    }
+  }, [osmEditMode]);
+
+  // Per-session OSM edit undo: ring buffer (last 3) covering flip / simplify
+  // / vertex-delete / drag-vertex / snap-ignore toggle, plus client-only hide
+  // and restore. Cleared on exit OSM edit mode. Merges aren't undoable here
+  // (they delete source rows; this ring buffer doesn't recreate them).
+  type OsmRoadSnap = {
+    id: number;
+    name: string | null;
+    geojson: string;
+    oneway: number;
+    highway: string | null;
+    snap_ignored: number;
+  };
+  type OsmUndoEntry =
+    | { kind: "restore-roads"; snapshots: OsmRoadSnap[]; label: string }
+    | { kind: "unhide"; ids: number[]; label: string }
+    | { kind: "rehide"; ids: number[]; label: string };
+  const [osmUndoStack, setOsmUndoStack] = useState<OsmUndoEntry[]>([]);
+  const pushOsmUndo = (entry: OsmUndoEntry) => {
+    setOsmUndoStack((prev) => [...prev, entry].slice(-3));
+  };
+  async function snapshotRoadsForUndo(
+    ids: number[],
+    label: string,
+  ): Promise<void> {
+    if (!osmEditMode || ids.length === 0) return;
+    try {
+      const snapshots = await invoke<OsmRoadSnap[]>("osm_road_snapshot", {
+        ids,
+      });
+      if (snapshots.length > 0) {
+        pushOsmUndo({ kind: "restore-roads", snapshots, label });
+      }
+    } catch (e) {
+      console.warn("osm_road_snapshot failed", e);
+    }
+  }
+  async function performOsmUndo() {
+    if (osmUndoStack.length === 0) return;
+    const last = osmUndoStack[osmUndoStack.length - 1];
+    setOsmUndoStack((prev) => prev.slice(0, -1));
+    try {
+      if (last.kind === "restore-roads") {
+        const n = await invoke<number>("restore_road_state", {
+          snapshots: last.snapshots,
+        });
+        await refreshOsmRoads();
+        setStatus(`Undid ${last.label} (${n} road${n === 1 ? "" : "s"} restored).`);
+      } else if (last.kind === "unhide") {
+        setHiddenRoadIds((prev) => {
+          const next = new Set(prev);
+          for (const id of last.ids) next.delete(id);
+          return next;
+        });
+        setStatus(`Undid ${last.label} (${last.ids.length} road(s) restored from hidden).`);
+      } else {
+        setHiddenRoadIds((prev) => {
+          const next = new Set(prev);
+          for (const id of last.ids) next.add(id);
+          return next;
+        });
+        setStatus(`Undid ${last.label} (${last.ids.length} road(s) hidden again).`);
+      }
+    } catch (e) {
+      setStatus(`Undo failed: ${e}`);
+    }
+  }
   const [drawRoadMode, setDrawRoadMode] = useState<boolean>(false);
   const [drawRoadCoords, setDrawRoadCoords] = useState<
     Array<[number, number]>
@@ -413,9 +562,23 @@ function AppShell({
   useEffect(() => {
     window.localStorage.setItem(POPUP_ENABLED_KEY, popupEnabled ? "1" : "0");
   }, [popupEnabled]);
+  useEffect(() => {
+    window.localStorage.setItem(
+      QUALITY_OFF_TRACK_KEY,
+      String(qualityOffTrackM),
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [qualityOffTrackM]);
   useEffect(() => {
     window.localStorage.setItem(PERF_MODE_KEY, perfMode ? "1" : "0");
   }, [perfMode]);
+  // Auto-dismiss the post-snap quality toast after a few seconds. Fast
+  // enough not to linger; slow enough to read.
+  useEffect(() => {
+    if (!snapQualityToast) return;
+    const t = window.setTimeout(() => setSnapQualityToast(null), 8000);
+    return () => window.clearTimeout(t);
+  }, [snapQualityToast]);
 
   // Counts on the current bbox slice (live update as user pans/zooms).
   const counts = useMemo(() => {
@@ -526,6 +689,174 @@ function AppShell({
     return "video";
   }, [filteredAssets]);
 
+  // Video-focus filter: when the user picks a single video — either by tapping
+  // its metadata polyline on the map, or by leaving exactly one video checked
+  // in the sidebar filter — restrict the map to that video's track + OSM roads
+  // near it. Tap the line again (or pick more videos) to restore everything.
+  // Filter labels (collapsed via displayVideo — e.g. "Not available" → NA
+  // sentinel) → the raw `video_name` strings each label spans. Built from
+  // the DB-wide list of video_names (allVideoNames + metadataByVideo keys),
+  // not the viewport-bounded `assets`, so panning never drops focus. Used
+  // to resolve a user-picked filter label back to its single raw key for
+  // metadataByVideo lookup and any backend command that does
+  // `WHERE video_name = ?`. Returns null focus when the label spans more
+  // than one raw (ambiguous) or the chosen video isn't in either source.
+  const labelToRaws = useMemo(() => {
+    const m = new Map<string, string[]>();
+    const seen = new Set<string>();
+    const sources = [...allVideoNames, ...Object.keys(metadataByVideo)];
+    for (const raw of sources) {
+      if (seen.has(raw)) continue;
+      seen.add(raw);
+      const label = displayVideo(raw);
+      const arr = m.get(label);
+      if (arr) {
+        if (!arr.includes(raw)) arr.push(raw);
+      } else {
+        m.set(label, [raw]);
+      }
+    }
+    return m;
+  }, [allVideoNames, metadataByVideo]);
+  // Helper: resolve a user-supplied video string (could be a display label
+  // like the NA sentinel or a raw video_name) to a raw DB key. Returns the
+  // input unchanged if it already matches a raw; null when the resolution is
+  // ambiguous (label spans multiple raws). Centralised so every video-action
+  // call site routes through the same logic.
+  const resolveVideoToRaw = (s: string): { raw: string | null; ambiguous: boolean } => {
+    const t = s.trim();
+    if (!t) return { raw: null, ambiguous: false };
+    // Exact raw hit beats any label resolution — handles the case where a
+    // raw value happens to equal the NA sentinel string itself.
+    if (allVideoNames.includes(t) || metadataByVideo[t] !== undefined) {
+      return { raw: t, ambiguous: false };
+    }
+    const raws = labelToRaws.get(t);
+    if (!raws || raws.length === 0) return { raw: null, ambiguous: false };
+    if (raws.length === 1) return { raw: raws[0], ambiguous: false };
+    return { raw: null, ambiguous: true };
+  };
+  const focusedVideo = useMemo<string | null>(() => {
+    // selectedMetadataVideo arrives from the polyline-tap path with the raw
+    // key already (metadataByVideo is keyed raw), so pass through.
+    if (selectedMetadataVideo !== null) return selectedMetadataVideo;
+    if (filters.videos.size === 1) {
+      const label = filters.videos.values().next().value as string | undefined;
+      if (!label) return null;
+      const raws = labelToRaws.get(label);
+      if (raws && raws.length === 1) return raws[0];
+      // Multiple raw video_names collapse to the same display label
+      // (e.g. several NA-ish sentinels in one bucket) — focusing is
+      // ambiguous, so don't enter focus mode.
+      return null;
+    }
+    return null;
+  }, [selectedMetadataVideo, filters.videos, labelToRaws]);
+  const displayMetadataTracks = useMemo(() => {
+    if (focusedVideo === null) return metadataByVideo;
+    const t = metadataByVideo[focusedVideo];
+    return t ? { [focusedVideo]: t } : metadataByVideo;
+  }, [metadataByVideo, focusedVideo]);
+  const displayOsmRoads = useMemo<OsmRoadFC>(() => {
+    if (!osmRoads || osmRoads.features.length === 0) return osmRoads;
+    // Hidden roads: dropped from view in any mode. They're cleared on exit.
+    const dropHidden = (fc: OsmRoadFC): OsmRoadFC => {
+      if (hiddenRoadIds.size === 0) return fc;
+      return {
+        type: "FeatureCollection",
+        features: fc.features.filter((f) => !hiddenRoadIds.has(f.properties.id)),
+      };
+    };
+    if (focusedVideo === null) return dropHidden(osmRoads);
+    const track = metadataByVideo[focusedVideo];
+    if (!track || track.length < 2) return dropHidden(osmRoads);
+    // Coarse spatial hash: bucket the track into ~55m × 55m cells with one
+    // ring of neighbour padding, so a road vertex landing in any of those
+    // cells is within ~75m of some track point. This is far cheaper than
+    // O(roads × roadVerts × trackLen) point-to-point distance.
+    const cellDeg = 0.0005;
+    const cells = new Set<string>();
+    for (const [lng, lat] of track) {
+      if (!isFinite(lng) || !isFinite(lat)) continue;
+      const gx = Math.floor(lng / cellDeg);
+      const gy = Math.floor(lat / cellDeg);
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          cells.add(`${gx + dx},${gy + dy}`);
+        }
+      }
+    }
+    // Rasterize each road *segment* (not just the vertices) — a long sparse
+    // segment can pass through a track buffer cell without any vertex
+    // landing in one. We sample each segment at sub-cell intervals until any
+    // sample lands in a marked cell.
+    const features = osmRoads.features.filter((f) => {
+      if (hiddenRoadIds.has(f.properties.id)) return false;
+      const g = f.geometry as
+        | { type: string; coordinates: Array<[number, number]> }
+        | undefined;
+      if (!g || g.type !== "LineString" || !Array.isArray(g.coordinates))
+        return false;
+      const coords = g.coordinates;
+      // Quick check: any vertex inside?
+      for (const [lng, lat] of coords) {
+        if (!isFinite(lng) || !isFinite(lat)) continue;
+        const gx = Math.floor(lng / cellDeg);
+        const gy = Math.floor(lat / cellDeg);
+        if (cells.has(`${gx},${gy}`)) return true;
+      }
+      // Sub-sample each segment.
+      const stepDeg = cellDeg * 0.5;
+      for (let i = 1; i < coords.length; i++) {
+        const a = coords[i - 1];
+        const b = coords[i];
+        if (
+          !isFinite(a[0]) ||
+          !isFinite(a[1]) ||
+          !isFinite(b[0]) ||
+          !isFinite(b[1])
+        )
+          continue;
+        const dx = b[0] - a[0];
+        const dy = b[1] - a[1];
+        const len = Math.hypot(dx, dy);
+        const steps = Math.ceil(len / stepDeg);
+        if (steps <= 1) continue;
+        for (let s = 1; s < steps; s++) {
+          const t = s / steps;
+          const lng = a[0] + dx * t;
+          const lat = a[1] + dy * t;
+          const gx = Math.floor(lng / cellDeg);
+          const gy = Math.floor(lat / cellDeg);
+          if (cells.has(`${gx},${gy}`)) return true;
+        }
+      }
+      return false;
+    });
+    return { type: "FeatureCollection", features };
+  }, [osmRoads, metadataByVideo, focusedVideo, hiddenRoadIds]);
+
+  // Reset selection + hidden state whenever the focused video changes — sets
+  // are video-scoped, so they shouldn't leak across switches.
+  useEffect(() => {
+    setSelectedRoadIds(new Set());
+    setHiddenRoadIds(new Set());
+  }, [focusedVideo]);
+
+  // In focus mode, vertex-edit is implicit: it activates whenever exactly one
+  // road is multi-selected. The existing vertex-edit panel + simplify slider
+  // + flip/delete buttons all key off editingRoadId, so this single derivation
+  // gives the user inline access without a separate submode toggle.
+  useEffect(() => {
+    if (focusedVideo === null) return;
+    if (selectedRoadIds.size === 1) {
+      const id = selectedRoadIds.values().next().value as number;
+      setEditingRoadId(id);
+    } else {
+      setEditingRoadId(null);
+    }
+  }, [selectedRoadIds, focusedVideo]);
+
   function gotoAdjacent(dir: -1 | 1) {
     if (navigableAssets.length === 0) return;
     let idx = -1;
@@ -624,6 +955,10 @@ function AppShell({
   // ESC: deselect editing road (or cancel a draw-in-progress).
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
+      // Vertex delete wins over bulk-hide whenever the user has marked
+      // vertices on an actively-edited road. Without this order, Del in
+      // focus + vertex-edit submode would hide the whole road instead of
+      // dropping the marked vertices.
       if (
         (e.key === "Delete" || e.key === "Backspace") &&
         osmEditMode &&
@@ -638,15 +973,44 @@ function AppShell({
         e.preventDefault();
         const idx = Array.from(markedVertices);
         const roadId = editingRoadId;
-        invoke<number>("delete_road_vertices", { id: roadId, indices: idx })
-          .then((n) => {
-            setStatus(`Removed ${n} vertex(s) from road #${roadId}`);
+        snapshotRoadsForUndo([roadId], "delete vertices")
+          .then(() =>
+            invoke<number>("delete_road_vertices", { id: roadId, indices: idx }),
+          )
+          .then((nn) => {
+            setStatus(`Removed ${nn} vertex(s) from road #${roadId}`);
             setMarkedVertices(new Set());
             return refreshOsmRoads();
           })
           .catch((err) => setStatus(`Vertex delete failed: ${err}`));
         return;
       }
+      // Bulk hide: in focused-video OSM mode and not in vertex-edit submode,
+      // Del moves the multi-select set into the hidden bucket.
+      if (
+        (e.key === "Delete" || e.key === "Backspace") &&
+        osmEditMode &&
+        focusedVideo !== null &&
+        editingRoadId === null &&
+        selectedRoadIds.size > 0
+      ) {
+        const target = e.target as HTMLElement | null;
+        const tag = target?.tagName;
+        if (tag === "INPUT" || tag === "TEXTAREA" || target?.isContentEditable) {
+          return;
+        }
+        e.preventDefault();
+        const ids = Array.from(selectedRoadIds);
+        setHiddenRoadIds((prev) => {
+          const next = new Set(prev);
+          for (const id of ids) next.add(id);
+          return next;
+        });
+        setSelectedRoadIds(new Set());
+        pushOsmUndo({ kind: "unhide", ids, label: "hide selected" });
+        setStatus(`${ids.length} road(s) hidden.`);
+        return;
+      }
       if ((e.key === "Delete" || e.key === "Backspace") && selectedLink) {
         const target = e.target as HTMLElement | null;
         const tag = target?.tagName;
@@ -663,6 +1027,13 @@ function AppShell({
         return;
       }
       if (e.key !== "Escape") return;
+      if (lensActive) {
+        e.preventDefault();
+        setLensActive(false);
+        setCursorWorld(null);
+        setCursorScreen(null);
+        return;
+      }
       if (lassoMode) {
         e.preventDefault();
         setLassoMode(false);
@@ -701,7 +1072,7 @@ function AppShell({
     };
     window.addEventListener("keydown", handler);
     return () => window.removeEventListener("keydown", handler);
-  }, [drawRoadMode, editingRoadId, linkPickMode, rightClickFirstId, lassoMode, selectedLink, selectedMetadataVideo, gotoPin, osmEditMode, markedVertices]);
+  }, [drawRoadMode, editingRoadId, linkPickMode, rightClickFirstId, lassoMode, selectedLink, selectedMetadataVideo, gotoPin, osmEditMode, markedVertices, focusedVideo, selectedRoadIds, lensActive]);
 
   // Image prefetch: when an asset is selected, warm the browser cache for its
   // immediate neighbours so [/] navigation feels instant.
@@ -814,11 +1185,23 @@ function AppShell({
   }
 
   async function handleBulkDeleteByVideo() {
-    const name = bulkVideoName.trim();
-    if (!name) {
+    const typed = bulkVideoName.trim();
+    if (!typed) {
       setStatus("Enter a video name first.");
       return;
     }
+    const r = resolveVideoToRaw(typed);
+    if (r.ambiguous) {
+      setStatus(
+        `"${typed}" matches multiple raw video names — pick a specific one from the suggestions.`,
+      );
+      return;
+    }
+    if (!r.raw) {
+      setStatus(`No video matches "${typed}".`);
+      return;
+    }
+    const name = r.raw;
     try {
       const count = await invoke<number>("delete_assets_by_video", {
         videoName: name,
@@ -857,7 +1240,7 @@ function AppShell({
   async function handleResetDatabase() {
     if (busy) return;
     const ok = window.confirm(
-      "Wipe ALL assets, scope polygons, and action history?\n\nThis cannot be undone.",
+      "Wipe ALL assets, scope polygons, OSM roads, per-video metadata, and action history?\n\nThis cannot be undone.",
     );
     if (!ok) return;
     setBusy(true);
@@ -865,10 +1248,25 @@ function AppShell({
       await invoke("reset_database");
       setAssets([]);
       setScopePolygons([]);
+      setOsmRoads({ type: "FeatureCollection", features: [] });
+      setMetadataByVideo({});
+      setMetadataTrack([]);
+      setSelectedMetadataVideo(null);
       setRecentActions([]);
       setSelectedAssetId(null);
       setMergePrimary(null);
       setMergeSecondary(null);
+      setSelectedRoadIds(new Set());
+      setHiddenRoadIds(new Set());
+      setEditingRoadId(null);
+      setOsmUndoStack([]);
+      setQualityReport(null);
+      setSnapQualityToast(null);
+      await Promise.all([
+        refreshDataCounts().catch(() => {}),
+        refreshVideoNames().catch(() => {}),
+        refreshAssetNames().catch(() => {}),
+      ]);
       setStatus("Database reset.");
     } catch (e) {
       setStatus(`Reset failed: ${e}`);
@@ -978,7 +1376,7 @@ function AppShell({
 
   async function refreshOsmRoads() {
     const list = await invoke<
-      Array<{ id: number; name: string | null; geojson: string }>
+      Array<{ id: number; name: string | null; geojson: string; snap_ignored?: boolean }>
     >("get_osm_roads");
     let mnLat = Infinity;
     let mxLat = -Infinity;
@@ -1009,7 +1407,11 @@ function AppShell({
       return {
         type: "Feature" as const,
         geometry: geom,
-        properties: { id: r.id, name: r.name },
+        properties: {
+          id: r.id,
+          name: r.name,
+          snap_ignored: r.snap_ignored === true,
+        },
       };
     });
     setOsmRoads({ type: "FeatureCollection", features });
@@ -1199,6 +1601,18 @@ function AppShell({
     refreshVideoNames().catch(() => {});
     refreshClasses().catch(() => {});
     refreshDataCounts().catch(() => {});
+    // Per-video metadata persists in DB; load it so users don't have to
+    // re-pick the JSON every session.
+    invoke<Record<string, Array<[number, number]>>>("get_video_metadata")
+      .then((map) => {
+        const keys = Object.keys(map);
+        if (keys.length === 0) return;
+        setMetadataByVideo(map);
+        const flat: Array<[number, number]> = [];
+        for (const k of keys) flat.push(...map[k]);
+        setMetadataTrack(flat);
+      })
+      .catch(() => {});
     invoke<Asset[]>("list_assets")
       .then((list) => {
         if (list.length > 0) {
@@ -1304,6 +1718,7 @@ function AppShell({
     coords: Array<[number, number]>,
   ) {
     try {
+      await snapshotRoadsForUndo([id], "vertex drag");
       await invoke("update_osm_road", { id, coords });
       await refreshOsmRoads();
       setStatus(`Updated road #${id} (${coords.length} vertices).`);
@@ -1538,11 +1953,23 @@ function AppShell({
 
   async function handleSnapByVideo() {
     if (busy) return;
-    const name = bulkVideoName.trim();
-    if (!name) {
+    const typed = bulkVideoName.trim();
+    if (!typed) {
       setStatus("Pick a video name first (use the bulk-delete input).");
       return;
     }
+    const r = resolveVideoToRaw(typed);
+    if (r.ambiguous) {
+      setStatus(
+        `"${typed}" matches multiple raw video names — pick a specific one from the suggestions.`,
+      );
+      return;
+    }
+    if (!r.raw) {
+      setStatus(`No video matches "${typed}".`);
+      return;
+    }
+    const name = r.raw;
     const ok = window.confirm(
       `Snap every asset (fixed + range) from video "${name}" to the nearest OSM road?\n\n` +
         `Single undoable action.`,
@@ -1574,6 +2001,7 @@ function AppShell({
         `Snap by video: ${res.snapped} moved, ${res.skipped_far} too far, ${res.skipped_no_geom} skipped`,
       );
       await refreshAfterMutation();
+      await runPostSnapQualityCheck(`Snap by video (${name})`);
     } catch (e) {
       setStatus(`Snap by video failed: ${e}`);
     } finally {
@@ -1677,6 +2105,109 @@ function AppShell({
     return a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" });
   }
 
+  // Run a quality scan immediately after a snap and surface the result
+  // as a toast. Shared by all three snap entrypoints (single asset,
+  // visible bulk, by-video). The Quality state is also updated so the
+  // sidebar panel reflects the post-snap counts without the user needing
+  // to click Refresh.
+  async function runPostSnapQualityCheck(label: string) {
+    try {
+      const r = await invoke<QualityReport>("quality_report", {
+        movedThresholdM: 50,
+        metadataThresholdM: qualityOffTrackM,
+        metadata: metadataByVideo,
+        cap: 500,
+      });
+      setQualityReport(r);
+      const total =
+        r.moved_far_total + r.far_from_metadata_total + r.missing_side_total;
+      setSnapQualityToast({
+        label,
+        total,
+        breakdown: {
+          moved: r.moved_far_total,
+          offTrack: r.far_from_metadata_total,
+          missingSide: r.missing_side_total,
+        },
+      });
+    } catch {
+      // Swallow — the snap itself succeeded; the quality scan is a
+      // post-flight check and shouldn't surface an error toast on top of
+      // the snap's own status message.
+    }
+  }
+
+  async function refreshQuality() {
+    setQualityLoading(true);
+    try {
+      const r = await invoke<QualityReport>("quality_report", {
+        movedThresholdM: 50,
+        // User-configurable via Settings → Quality. Default 30 m. Note:
+        // tightening below ~25 m produces noise on curved/sparse metadata
+        // polylines where the chord cuts a corner the asset is on.
+        metadataThresholdM: qualityOffTrackM,
+        // Send the loaded per-video metadata so the backend can flag assets
+        // that drifted off the actual GPS track. Videos without metadata
+        // are silently skipped — the check just doesn't fire for them.
+        metadata: metadataByVideo,
+        cap: 500,
+      });
+      setQualityReport(r);
+    } catch (e) {
+      setStatus(`Quality report failed: ${e}`);
+    } finally {
+      setQualityLoading(false);
+    }
+  }
+
+  // Set up step-through over a list of issue ids. Loads their coords and
+  // zooms tight (z=18) to the first one — Prev/Next buttons in the panel
+  // walk through the rest.
+  async function viewQualityIssues(ids: number[], label: string) {
+    if (ids.length === 0) return;
+    try {
+      const coordsRaw = await invoke<
+        Array<{ id: number; lat: number | null; lng: number | null }>
+      >("assets_coords_for_ids", { ids });
+      const coords = coordsRaw
+        .filter(
+          (c): c is { id: number; lat: number; lng: number } =>
+            c.lat !== null && c.lng !== null,
+        )
+        .map((c) => ({ id: c.id, lat: c.lat, lng: c.lng }));
+      if (coords.length === 0) {
+        setStatus(`${label}: no coords found.`);
+        return;
+      }
+      setQualityHighlight(ids);
+      setQualityStep({ label, coords, idx: 0 });
+      setSelectedAssetId(coords[0].id);
+      setViewport({ center: [coords[0].lng, coords[0].lat], zoom: 18 });
+      setStatus(
+        coords.length === 1
+          ? `${label}: 1 issue (zoomed in).`
+          : `${label}: 1 of ${coords.length} (use Next to step through).`,
+      );
+    } catch (e) {
+      setStatus(`View failed: ${e}`);
+    }
+  }
+
+  function stepQualityBy(delta: number) {
+    setQualityStep((prev) => {
+      if (!prev || prev.coords.length === 0) return prev;
+      const next =
+        (prev.idx + delta + prev.coords.length) % prev.coords.length;
+      const c = prev.coords[next];
+      setSelectedAssetId(c.id);
+      setViewport({ center: [c.lng, c.lat], zoom: 18 });
+      setStatus(
+        `${prev.label}: ${next + 1} of ${prev.coords.length}`,
+      );
+      return { ...prev, idx: next };
+    });
+  }
+
   async function handleDistribute() {
     if (anchors.size === 0) return;
     // Snapshot anchor deltas from the current DB state vs the captured originals.
@@ -2119,6 +2650,7 @@ function AppShell({
         `Bulk snap: ${res.snapped} moved, ${res.skipped_far} too far, ${res.skipped_no_geom} skipped`,
       );
       await refreshAfterMutation();
+      await runPostSnapQualityCheck("Bulk snap (visible)");
     } catch (e) {
       setStatus(`Bulk snap failed: ${e}`);
     } finally {
@@ -2148,6 +2680,7 @@ function AppShell({
         `Snapped to road @ ${lat.toFixed(6)}, ${lng.toFixed(6)}`,
       );
       await refreshAfterMutation();
+      await runPostSnapQualityCheck("Snap to road");
     } catch (e) {
       setStatus(`Snap failed: ${e}`);
     } finally {
@@ -2202,6 +2735,12 @@ function AppShell({
         "read_video_polylines_json",
         { path: picked },
       );
+      // Persist so subsequent app starts auto-load without a re-pick.
+      try {
+        await invoke<number>("save_video_metadata", { tracks: map });
+      } catch (e) {
+        console.warn("save_video_metadata failed", e);
+      }
       setMetadataByVideo(map);
       const keys = Object.keys(map);
       // Concatenated fallback for callers that don't yet pass a video.
@@ -2235,6 +2774,53 @@ function AppShell({
     }
   }
 
+  // Auto-detect importer for combined fixed+range JSON. Accepts either a
+  // top-level array (rows can be mixed fixed and range) or the round-trip
+  // export shape `{ "fixed": [...], "range": [...] }`. Each row's shape is
+  // sniffed by the backend (presence of `start_coord_*` → range).
+  async function handleImportAuto() {
+    if (busy) return;
+    setBusy(true);
+    setStatus("Picking file…");
+    try {
+      const picked = await open({
+        multiple: false,
+        directory: false,
+        filters: [{ name: "JSON", extensions: ["json"] }],
+      });
+      if (typeof picked !== "string") {
+        setStatus("");
+        return;
+      }
+      setStatus("Importing (auto-detect)…");
+      const r = await invoke<{ fixed: number; range: number }>(
+        "import_assets_auto",
+        { path: picked },
+      );
+      setStatus(`Imported ${r.fixed} fixed + ${r.range} range = ${r.fixed + r.range} asset(s)`);
+      await Promise.all([
+        refreshVideoNames(),
+        refreshAssetNames(),
+        refreshClasses(),
+      ]);
+      if (boundsRef.current) {
+        await fetchBboxAssets(boundsRef.current);
+      }
+      const all = await invoke<Asset[]>("list_assets");
+      const first = all.find((a) => a.lat !== null && a.lng !== null);
+      if (first) {
+        setViewport({
+          center: [first.lng as number, first.lat as number],
+          zoom: 13,
+        });
+      }
+    } catch (e) {
+      setStatus(`Import failed: ${e}`);
+    } finally {
+      setBusy(false);
+    }
+  }
+
   async function handleImport(kind: "fixed" | "range") {
     if (busy) return;
     setBusy(true);
@@ -2287,6 +2873,103 @@ function AppShell({
     <div className="app">
       {perfMode && <FpsCounter />}
       {osmFetchActive && <OsmFetchIndicator />}
+      {snapQualityToast && (
+        <div
+          style={{
+            position: "fixed",
+            top: 12,
+            left: "50%",
+            transform: "translateX(-50%)",
+            zIndex: 9500,
+            background:
+              snapQualityToast.total === 0
+                ? "rgba(39, 174, 96, 0.95)"
+                : "rgba(192, 57, 43, 0.95)",
+            color: "#fff",
+            padding: "10px 16px",
+            borderRadius: 6,
+            boxShadow: "0 4px 14px rgba(0,0,0,0.4)",
+            fontSize: 13,
+            fontFamily: "system-ui, sans-serif",
+            display: "flex",
+            alignItems: "center",
+            gap: 12,
+            maxWidth: "90vw",
+          }}
+          role="status"
+        >
+          <strong>{snapQualityToast.label} complete.</strong>
+          <span>
+            {snapQualityToast.total === 0
+              ? "No quality issues."
+              : `${snapQualityToast.total} quality issue${snapQualityToast.total === 1 ? "" : "s"} found ` +
+                `(${snapQualityToast.breakdown.moved} moved · ` +
+                `${snapQualityToast.breakdown.offTrack} off track · ` +
+                `${snapQualityToast.breakdown.missingSide} no side)`}
+          </span>
+          <button
+            style={{
+              background: "rgba(255,255,255,0.2)",
+              border: 0,
+              color: "#fff",
+              padding: "2px 8px",
+              borderRadius: 3,
+              fontSize: 12,
+              cursor: "pointer",
+            }}
+            onClick={() => setSnapQualityToast(null)}
+            aria-label="Dismiss"
+          >
+            ×
+          </button>
+        </div>
+      )}
+      {lensActive && cursorWorld && cursorScreen && (() => {
+        // Place the lens cursor +24px / +24px by default; flip to the other
+        // side when that would clip the viewport edge. Clamp to a small
+        // margin so the lens never sits flush with the window edge.
+        const dia = 240;
+        const offset = 24;
+        const margin = 8;
+        const vw = typeof window !== "undefined" ? window.innerWidth : 1024;
+        const vh = typeof window !== "undefined" ? window.innerHeight : 768;
+        let left = cursorScreen.x + offset;
+        let top = cursorScreen.y + offset;
+        if (left + dia + margin > vw) {
+          left = cursorScreen.x - dia - offset;
+        }
+        if (top + dia + margin > vh) {
+          top = cursorScreen.y - dia - offset;
+        }
+        if (left < margin) left = margin;
+        if (top < margin) top = margin;
+        return (
+          <div
+            style={{
+              position: "fixed",
+              left,
+              top,
+              zIndex: 1000,
+              pointerEvents: "none",
+            }}
+          >
+            <LensView
+              basemapId={primaryId}
+              centerLng={cursorWorld.lng}
+              centerLat={cursorWorld.lat}
+              zoom={Math.min(22, viewport.zoom + 3)}
+              diameterPx={dia}
+              osmRoads={displayOsmRoads}
+              assets={filteredAssets}
+              metadataTrack={
+                focusedVideo !== null
+                  ? metadataByVideo[focusedVideo] ?? []
+                  : metadataTrack
+              }
+            />
+          </div>
+        );
+      })()}
       <div className="map-area">
         <MapView
           basemapId={primaryId}
@@ -2295,11 +2978,33 @@ function AppShell({
           onMoveEnd={({ bounds: b }) => setBounds(b)}
           assets={filteredAssets}
           scopePolygons={scopePolygons}
-          osmRoads={osmRoads}
-          metadataTrack={metadataTrack}
-          metadataTracks={metadataByVideo}
+          osmRoads={displayOsmRoads}
+          metadataTrack={focusedVideo === null ? metadataTrack : []}
+          metadataTracks={displayMetadataTracks}
           selectedMetadataVideo={selectedMetadataVideo}
           gotoPin={gotoPin}
+          onCursorWorld={(lng, lat, x, y) => {
+            if (!lensActive) return;
+            if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
+              lensPendingRef.current = null;
+              if (lensRafRef.current !== null) {
+                cancelAnimationFrame(lensRafRef.current);
+                lensRafRef.current = null;
+              }
+              setCursorWorld(null);
+              setCursorScreen(null);
+              return;
+            }
+            lensPendingRef.current = { lng, lat, x, y };
+            if (lensRafRef.current !== null) return;
+            lensRafRef.current = requestAnimationFrame(() => {
+              lensRafRef.current = null;
+              const p = lensPendingRef.current;
+              if (!p) return;
+              setCursorWorld({ lng: p.lng, lat: p.lat });
+              setCursorScreen({ x: p.x, y: p.y });
+            });
+          }}
           markedVertices={markedVertices}
           onVertexShiftClick={(idx) => {
             setMarkedVertices((prev) => {
@@ -2377,10 +3082,41 @@ function AppShell({
           colorBy={colorBy}
           osmEditMode={osmEditMode}
           editingRoadId={editingRoadId}
+          selectedRoadIds={selectedRoadIds}
+          multiSelectActive={focusedVideo !== null}
           onPickRoad={(id) => {
+            // In single-video focus, left-click always toggles multi-select.
+            // Vertex-edit tools appear automatically when the selection
+            // narrows to a single road (see auto-derive effect below).
+            if (focusedVideo !== null) {
+              setSelectedRoadIds((prev) => {
+                const next = new Set(prev);
+                if (next.has(id)) next.delete(id);
+                else next.add(id);
+                return next;
+              });
+              return;
+            }
             setEditingRoadId(id);
             setStatus(`Editing road #${id}. Drag the gold vertex dots.`);
           }}
+          onRoadRightClick={(id) => {
+            // Right-click hides immediately. Hide is session-only and clears
+            // when OSM edit mode exits or focused video changes.
+            setHiddenRoadIds((prev) => {
+              const next = new Set(prev);
+              next.add(id);
+              return next;
+            });
+            setSelectedRoadIds((prev) => {
+              if (!prev.has(id)) return prev;
+              const next = new Set(prev);
+              next.delete(id);
+              return next;
+            });
+            pushOsmUndo({ kind: "unhide", ids: [id], label: "hide road" });
+            setStatus(`Road #${id} hidden (session-only).`);
+          }}
           onUpdateRoad={handleUpdateRoad}
           roadOffsetMeters={roadOffsetMeters}
           drawRoadMode={drawRoadMode}
@@ -2394,7 +3130,9 @@ function AppShell({
               ? (dupClusters.find((c) => c.id === dupActive)?.members.map(
                   (m) => m.id,
                 ) ?? [])
-              : (lassoSelected?.ids ?? [])
+              : qualityHighlight.length > 0
+                ? qualityHighlight
+                : (lassoSelected?.ids ?? [])
           }
         />
         {compare && (
@@ -2405,9 +3143,9 @@ function AppShell({
             onMoveEnd={({ bounds: b }) => setBounds(b)}
             assets={filteredAssets}
             scopePolygons={scopePolygons}
-            osmRoads={osmRoads}
-            metadataTrack={metadataTrack}
-          metadataTracks={metadataByVideo}
+            osmRoads={displayOsmRoads}
+            metadataTrack={focusedVideo === null ? metadataTrack : []}
+          metadataTracks={displayMetadataTracks}
           selectedMetadataVideo={selectedMetadataVideo}
           gotoPin={gotoPin}
           markedVertices={markedVertices}
@@ -2873,6 +3611,18 @@ function AppShell({
               Pick what to import. Each opens a file dialog.
             </div>
             <div style={{ display: "flex", flexDirection: "column", gap: 6, marginTop: 8 }}>
+              <button
+                className="primary-btn"
+                style={{ background: "#16a085" }}
+                onClick={() => {
+                  setImportsOpen(false);
+                  handleImportAuto();
+                }}
+                disabled={busy}
+                title="Import a combined JSON file containing fixed and/or range rows. Rows are dispatched per-shape: any row with start_coord_* + end_coord_* is treated as range, others as fixed. Also accepts the round-trip export object {fixed: [...], range: [...]}."
+              >
+                Combined assets (auto-detect)…
+              </button>
               <button
                 className="primary-btn"
                 onClick={() => {
@@ -2880,6 +3630,7 @@ function AppShell({
                   handleImport("fixed");
                 }}
                 disabled={busy}
+                title="Import a JSON file where every row is a fixed asset."
               >
                 Fixed assets (JSON)…
               </button>
@@ -2890,6 +3641,7 @@ function AppShell({
                   handleImport("range");
                 }}
                 disabled={busy}
+                title="Import a JSON file where every row is a range asset (start/mid/end + 3 images)."
               >
                 Range assets (JSON)…
               </button>
@@ -3081,6 +3833,43 @@ function AppShell({
               Show image popup when an asset is selected
             </label>
 
+            <h4 style={{ marginTop: 12 }}>Quality thresholds</h4>
+            <label
+              style={{
+                display: "flex",
+                alignItems: "center",
+                gap: 8,
+                fontSize: 13,
+              }}
+              title="Off-track flag fires when an asset's perpendicular distance to its video's metadata polyline exceeds this. Lower = stricter; below ~25 m starts producing noise on curved/sparse polylines."
+            >
+              <span style={{ minWidth: 130 }}>Off-track distance:</span>
+              <input
+                type="number"
+                min={5}
+                max={200}
+                step={1}
+                value={qualityOffTrackM}
+                onChange={(e) => {
+                  const n = parseFloat(e.target.value);
+                  if (Number.isFinite(n) && n > 0) setQualityOffTrackM(n);
+                }}
+                style={{ width: 70 }}
+              />
+              <span>m</span>
+              <button
+                type="button"
+                onClick={() => setQualityOffTrackM(30)}
+                style={{
+                  marginLeft: "auto",
+                  fontSize: 11,
+                  padding: "2px 8px",
+                }}
+              >
+                Reset to 30 m
+              </button>
+            </label>
+
             <h4 style={{ marginTop: 12 }}>Diagnostics</h4>
             <label style={{ display: "flex", alignItems: "center", gap: 6 }}>
               <input
@@ -3394,11 +4183,17 @@ function AppShell({
               label: "Per-video metadata",
               count: Object.keys(metadataByVideo).length,
               onReplace: () => handleImportVideoMetadata(),
-              onClear: () => {
-                setMetadataByVideo({});
-                setMetadataTrack([]);
-                setSelectedMetadataVideo(null);
-                setStatus("Cleared per-video metadata");
+              onClear: async () => {
+                try {
+                  const n = await invoke<number>("clear_video_metadata");
+                  setMetadataByVideo({});
+                  setMetadataTrack([]);
+                  setSelectedMetadataVideo(null);
+                  await refreshDataCounts();
+                  setStatus(`Cleared per-video metadata (${n} video(s))`);
+                } catch (e) {
+                  setStatus(`Clear failed: ${e}`);
+                }
               },
             },
           ] as const).map((row) => (
@@ -3458,28 +4253,278 @@ function AppShell({
         >
           {osmEditMode ? "Exit OSM edit mode" : "Edit OSM roads"}
         </button>
+        <button
+          className="primary-btn"
+          style={{
+            marginTop: 6,
+            background: lensActive ? "#16a085" : "#34495e",
+          }}
+          onClick={() => {
+            setLensActive((v) => {
+              if (v) {
+                setCursorWorld(null);
+                setCursorScreen(null);
+              }
+              return !v;
+            });
+          }}
+          title="Magnifier: while on, hover the map to see a circular zoomed view around the cursor with OSM roads + assets + metadata polyline. Press ESC to exit."
+        >
+          {lensActive ? "Exit magnifier" : "🔍 Magnifier"}
+        </button>
+        {osmEditMode && (
+          <button
+            className="primary-btn"
+            style={{
+              marginTop: 6,
+              background: osmUndoStack.length > 0 ? "#8e44ad" : "#bdc3c7",
+            }}
+            onClick={performOsmUndo}
+            disabled={busy || osmUndoStack.length === 0}
+            title={
+              osmUndoStack.length === 0
+                ? "Nothing to undo. Last 3 OSM edits in this session are stored here."
+                : `Undo: ${osmUndoStack[osmUndoStack.length - 1].label} (${osmUndoStack.length}/3 in stack)`
+            }
+          >
+            ↶ Undo last edit
+            {osmUndoStack.length > 0 ? ` (${osmUndoStack.length})` : ""}
+          </button>
+        )}
+        {osmEditMode && focusedVideo !== null && (
+          <div
+            style={{
+              marginTop: 6,
+              padding: 8,
+              background: "#eef5ff",
+              border: "1px solid #b6d4f7",
+              borderRadius: 4,
+              fontSize: 11,
+            }}
+          >
+            <div style={{ fontWeight: 600, marginBottom: 4 }}>
+              Bulk road tools — focus: {focusedVideo}
+            </div>
+            <div style={{ marginBottom: 4, color: "#555" }}>
+              Click roads to multi-select · Right-click to hide one · Del to
+              hide selected. Select exactly one road to edit / simplify its
+              vertices. Hidden roads return when you exit OSM edit mode or
+              change focused video.
+            </div>
+            <div style={{ marginBottom: 6 }}>
+              Selected: <strong>{selectedRoadIds.size}</strong> · Hidden:{" "}
+              <strong>{hiddenRoadIds.size}</strong>
+            </div>
+            <div style={{ display: "flex", flexWrap: "wrap", gap: 4 }}>
+              <button
+                className="primary-btn"
+                style={{ background: "#c0392b", fontSize: 11 }}
+                disabled={busy || selectedRoadIds.size === 0}
+                onClick={() => {
+                  const ids = Array.from(selectedRoadIds);
+                  setHiddenRoadIds((prev) => {
+                    const next = new Set(prev);
+                    for (const id of ids) next.add(id);
+                    return next;
+                  });
+                  setSelectedRoadIds(new Set());
+                  pushOsmUndo({
+                    kind: "unhide",
+                    ids,
+                    label: "hide selected",
+                  });
+                  setStatus(`${ids.length} road(s) hidden.`);
+                }}
+                title="Hide all currently-selected roads"
+              >
+                Hide selected
+              </button>
+              <button
+                className="primary-btn"
+                style={{ background: "#7f8c8d", fontSize: 11 }}
+                disabled={busy || selectedRoadIds.size === 0}
+                onClick={() => {
+                  setSelectedRoadIds(new Set());
+                  setStatus("Selection cleared.");
+                }}
+              >
+                Clear selection
+              </button>
+              <button
+                className="primary-btn"
+                style={{ background: "#27ae60", fontSize: 11 }}
+                disabled={busy || hiddenRoadIds.size === 0}
+                onClick={() => {
+                  const ids = Array.from(hiddenRoadIds);
+                  setHiddenRoadIds(new Set());
+                  pushOsmUndo({
+                    kind: "rehide",
+                    ids,
+                    label: "restore hidden",
+                  });
+                  setStatus(`Restored ${ids.length} hidden road(s).`);
+                }}
+                title="Bring all hidden roads back into view"
+              >
+                Restore hidden
+              </button>
+              <button
+                className="primary-btn"
+                style={{ background: "#16a085", fontSize: 11 }}
+                disabled={busy || selectedRoadIds.size < 2}
+                onClick={async () => {
+                  const ids = Array.from(selectedRoadIds);
+                  // Same destructive + non-undoable warning as "Merge all
+                  // visible" — easy to misclick a 50-road selection and lose
+                  // the source rows.
+                  const ok = window.confirm(
+                    `Merge ${ids.length} selected road(s) into connected clusters?\n\n` +
+                      `This deletes the source rows and is NOT covered by the OSM Undo. ` +
+                      `Disconnected clusters stay separate.`,
+                  );
+                  if (!ok) return;
+                  setBusy(true);
+                  try {
+                    const r = await invoke<{
+                      ways_consumed: number;
+                      merged_into: number;
+                      skipped_branched: number;
+                    }>("merge_roads_by_ids", { ids });
+                    setStatus(
+                      `Merged ${r.ways_consumed} road(s) into ${r.merged_into}` +
+                        (r.skipped_branched > 0
+                          ? ` (skipped ${r.skipped_branched} branched cluster${
+                              r.skipped_branched === 1 ? "" : "s"
+                            })`
+                          : ""),
+                    );
+                    setSelectedRoadIds(new Set());
+                    await refreshOsmRoads();
+                  } catch (e) {
+                    setStatus(`Merge failed: ${e}`);
+                  } finally {
+                    setBusy(false);
+                  }
+                }}
+                title="Concatenate ≥2 selected roads into one (clusters are merged independently)"
+              >
+                Merge selected
+              </button>
+              <button
+                className="primary-btn"
+                style={{ background: "#2c3e50", fontSize: 11 }}
+                disabled={
+                  busy || (displayOsmRoads?.features.length ?? 0) < 2
+                }
+                onClick={async () => {
+                  const ids = (displayOsmRoads?.features ?? []).map(
+                    (f) => f.properties.id,
+                  );
+                  if (ids.length < 2) return;
+                  // Destructive + not undoable via the OSM ring buffer (merge
+                  // consumes source rows). Confirm loudly so the user can't
+                  // wipe a video's worth of road geometry by misclick.
+                  const ok = window.confirm(
+                    `Merge all ${ids.length} visible road(s) into connected clusters?\n\n` +
+                      `This deletes the source rows and is NOT covered by the OSM Undo. ` +
+                      `Hidden roads stay hidden. Disconnected clusters stay separate.`,
+                  );
+                  if (!ok) return;
+                  setBusy(true);
+                  try {
+                    const r = await invoke<{
+                      ways_consumed: number;
+                      merged_into: number;
+                      skipped_branched: number;
+                    }>("merge_roads_by_ids", { ids });
+                    setStatus(
+                      `Merged ${r.ways_consumed} road(s) into ${r.merged_into}` +
+                        (r.skipped_branched > 0
+                          ? ` (skipped ${r.skipped_branched} branched cluster${
+                              r.skipped_branched === 1 ? "" : "s"
+                            })`
+                          : ""),
+                    );
+                    setSelectedRoadIds(new Set());
+                    await refreshOsmRoads();
+                  } catch (e) {
+                    setStatus(`Merge failed: ${e}`);
+                  } finally {
+                    setBusy(false);
+                  }
+                }}
+                title="Merge all currently-visible roads (non-touching clusters stay separate)"
+              >
+                Merge all visible
+              </button>
+            </div>
+          </div>
+        )}
         {osmEditMode && editingRoadId !== null && (
           <>
             <button
               className="primary-btn"
               style={{ marginTop: 6, background: "#9b59b6" }}
-              onClick={() =>
-                invoke<number>("flip_road_direction", {
-                  id: editingRoadId,
-                })
-                  .then((next) => {
-                    const label =
-                      next === 1 ? "forward" : next === -1 ? "reverse" : "none";
-                    setStatus(`Flipped road #${editingRoadId} → ${label}`);
-                  })
-                  .then(refreshOsmRoads)
-                  .catch((e) => setStatus(`Flip failed: ${e}`))
-              }
+              onClick={async () => {
+                if (editingRoadId === null) return;
+                try {
+                  await snapshotRoadsForUndo([editingRoadId], "flip direction");
+                  const next = await invoke<number>("flip_road_direction", {
+                    id: editingRoadId,
+                  });
+                  const label =
+                    next === 1 ? "forward" : next === -1 ? "reverse" : "none";
+                  setStatus(`Flipped road #${editingRoadId} → ${label}`);
+                  await refreshOsmRoads();
+                } catch (e) {
+                  setStatus(`Flip failed: ${e}`);
+                }
+              }}
               disabled={busy}
               title="Toggle this road's oneway direction (forward ↔ reverse). Useful when OSM has the wrong direction."
             >
               Flip direction
             </button>
+            {(() => {
+              const cur = osmRoads.features.find(
+                (f) => f.properties.id === editingRoadId,
+              );
+              const ignored = cur?.properties.snap_ignored === true;
+              return (
+                <button
+                  className="primary-btn"
+                  style={{
+                    marginTop: 6,
+                    background: ignored ? "#7f8c8d" : "#34495e",
+                  }}
+                  onClick={async () => {
+                    if (editingRoadId === null) return;
+                    try {
+                      await snapshotRoadsForUndo(
+                        [editingRoadId],
+                        ignored ? "re-enable for snap" : "ignore for snap",
+                      );
+                      await invoke("set_road_snap_ignored", {
+                        id: editingRoadId,
+                        ignored: !ignored,
+                      });
+                      setStatus(
+                        ignored
+                          ? `Road #${editingRoadId} re-enabled for snapping.`
+                          : `Road #${editingRoadId} marked as ignored — snap will skip it.`,
+                      );
+                      await refreshOsmRoads();
+                    } catch (e) {
+                      setStatus(`Toggle failed: ${e}`);
+                    }
+                  }}
+                  disabled={busy}
+                  title="Excluded roads stay visible (greyed out) but won't be picked as snap targets."
+                >
+                  {ignored ? "Re-enable for snap" : "Ignore for snap"}
+                </button>
+              );
+            })()}
             <div
               style={{
                 marginTop: 6,
@@ -3555,6 +4600,10 @@ function AppShell({
                   if (editingRoadId === null) return;
                   setBusy(true);
                   try {
+                    await snapshotRoadsForUndo(
+                      [editingRoadId],
+                      "simplify road",
+                    );
                     const [before, after] = await invoke<[number, number]>(
                       "simplify_road",
                       { id: editingRoadId, toleranceM: simplifyTolM },
@@ -3575,16 +4624,18 @@ function AppShell({
                 Simplify this road
               </button>
             </div>
-            <button
-              className="primary-btn"
-              style={{ marginTop: 6, background: "#7f8c8d" }}
-              onClick={() => {
-                setEditingRoadId(null);
-                setStatus("Cleared road selection.");
-              }}
-            >
-              Deselect road
-            </button>
+            {focusedVideo === null && (
+              <button
+                className="primary-btn"
+                style={{ marginTop: 6, background: "#7f8c8d" }}
+                onClick={() => {
+                  setEditingRoadId(null);
+                  setStatus("Cleared road selection.");
+                }}
+              >
+                Deselect road
+              </button>
+            )}
             <button
               className="primary-btn"
               style={{ marginTop: 6, background: "#c0392b" }}
@@ -4495,23 +5546,44 @@ function AppShell({
           }}
         />
         <datalist id="video-name-options">
-          {Array.from(counts.byVideo.entries())
-            .sort((a, b) => b[1] - a[1])
-            .map(([v, n]) => (
-              <option key={v} value={v}>
-                {n} asset{n === 1 ? "" : "s"}
-              </option>
-            ))}
+          {/*
+            Source from the DB-wide raw video list so offscreen videos still
+            show up in suggestions. Empty raws are filtered (the input would
+            display blank and confuse the user). Displayed text shows the raw
+            with the displayVideo() label parenthesised when the two differ
+            (e.g. "Not available  (NA)") so the user can still recognise the
+            collapsed bucket; the picked value is always the raw key.
+          */}
+          {allVideoNames
+            .filter((v) => v.trim() !== "")
+            .map((raw) => {
+              const label = displayVideo(raw);
+              const text = label !== raw ? `${raw}  (${label})` : raw;
+              return (
+                <option key={raw} value={raw}>
+                  {text}
+                </option>
+              );
+            })}
         </datalist>
         <div style={{ display: "flex", gap: 4, flexWrap: "wrap" }}>
           <button
             className="primary-btn"
             style={{ background: "#27ae60", flex: 1, fontSize: 11 }}
             onClick={() => {
-              const name = bulkVideoName.trim();
-              if (!name) return;
+              const typed = bulkVideoName.trim();
+              if (!typed) return;
+              const r = resolveVideoToRaw(typed);
+              if (r.ambiguous) {
+                setStatus(`"${typed}" matches multiple raw video names — pick a specific one.`);
+                return;
+              }
+              if (!r.raw) {
+                setStatus(`No video matches "${typed}".`);
+                return;
+              }
               invoke<number>("set_assets_by_video_in_scope", {
-                videoName: name,
+                videoName: r.raw,
                 inScope: true,
               })
                 .then((n) => setStatus(`Marked ${n} in-scope`))
@@ -4526,10 +5598,19 @@ function AppShell({
             className="primary-btn"
             style={{ background: "#7f8c8d", flex: 1, fontSize: 11 }}
             onClick={() => {
-              const name = bulkVideoName.trim();
-              if (!name) return;
+              const typed = bulkVideoName.trim();
+              if (!typed) return;
+              const r = resolveVideoToRaw(typed);
+              if (r.ambiguous) {
+                setStatus(`"${typed}" matches multiple raw video names — pick a specific one.`);
+                return;
+              }
+              if (!r.raw) {
+                setStatus(`No video matches "${typed}".`);
+                return;
+              }
               invoke<number>("set_assets_by_video_in_scope", {
-                videoName: name,
+                videoName: r.raw,
                 inScope: false,
               })
                 .then((n) => setStatus(`Marked ${n} out-of-scope`))
@@ -4730,6 +5811,142 @@ function AppShell({
         )}
         </details>
 
+        <details style={{ marginTop: 16 }}>
+          <summary style={{ cursor: "pointer", fontSize: 16, fontWeight: 600 }}>
+            Quality{qualityReport
+              ? ` (${
+                  qualityReport.moved_far_total +
+                  qualityReport.far_from_metadata_total +
+                  qualityReport.missing_side_total
+                })`
+              : ""}
+          </summary>
+          <div style={{ display: "flex", gap: 4, flexWrap: "wrap", marginTop: 6 }}>
+            <button
+              className="primary-btn"
+              style={{ flex: 1, fontSize: 11 }}
+              onClick={refreshQuality}
+              disabled={qualityLoading}
+            >
+              {qualityLoading ? "Scanning…" : qualityReport ? "Refresh" : "Run scan"}
+            </button>
+            {qualityHighlight.length > 0 && (
+              <button
+                className="primary-btn"
+                style={{ flex: 1, fontSize: 11, background: "#bdc3c7" }}
+                onClick={() => {
+                  setQualityHighlight([]);
+                  setQualityStep(null);
+                }}
+              >
+                Clear
+              </button>
+            )}
+          </div>
+          {qualityStep && qualityStep.coords.length > 1 && (
+            <div
+              style={{
+                display: "flex",
+                gap: 4,
+                alignItems: "center",
+                marginTop: 6,
+                fontSize: 11,
+              }}
+            >
+              <button
+                className="primary-btn"
+                style={{ flex: 1, fontSize: 11 }}
+                onClick={() => stepQualityBy(-1)}
+              >
+                ‹ Prev
+              </button>
+              <span style={{ minWidth: 50, textAlign: "center" }}>
+                {qualityStep.idx + 1} / {qualityStep.coords.length}
+              </span>
+              <button
+                className="primary-btn"
+                style={{ flex: 1, fontSize: 11 }}
+                onClick={() => stepQualityBy(1)}
+              >
+                Next ›
+              </button>
+            </div>
+          )}
+          {qualityReport && (
+            <div style={{ marginTop: 8 }}>
+              {[
+                {
+                  key: "moved_far",
+                  label: "Moved > 50 m",
+                  count: qualityReport.moved_far_total,
+                  ids: qualityReport.moved_far,
+                },
+                {
+                  key: "far_from_metadata",
+                  label: "Off metadata track",
+                  count: qualityReport.far_from_metadata_total,
+                  ids: qualityReport.far_from_metadata,
+                  hint:
+                    Object.keys(metadataByVideo).length === 0
+                      ? "load metadata to enable"
+                      : null,
+                },
+                {
+                  key: "missing_side",
+                  label: "Missing side",
+                  count: qualityReport.missing_side_total,
+                  ids: qualityReport.missing_side,
+                },
+              ].map((r) => (
+                <div
+                  key={r.key}
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: 6,
+                    padding: "3px 0",
+                    fontSize: 12,
+                  }}
+                >
+                  <span style={{ flex: 1 }}>
+                    {r.label}
+                    {r.hint && (
+                      <span
+                        style={{ marginLeft: 6, color: "#888", fontSize: 10 }}
+                      >
+                        ({r.hint})
+                      </span>
+                    )}
+                  </span>
+                  <span
+                    style={{
+                      minWidth: 32,
+                      textAlign: "right",
+                      fontWeight: 600,
+                      color: r.count > 0 ? "#c0392b" : "#27ae60",
+                    }}
+                  >
+                    {r.count}
+                  </span>
+                  <button
+                    className="primary-btn"
+                    style={{ fontSize: 10, padding: "2px 8px" }}
+                    disabled={r.count === 0 || r.ids.length === 0}
+                    onClick={() => viewQualityIssues(r.ids, r.label)}
+                    title={
+                      r.count > r.ids.length
+                        ? `Showing first ${r.ids.length} of ${r.count}`
+                        : ""
+                    }
+                  >
+                    View
+                  </button>
+                </div>
+              ))}
+            </div>
+          )}
+        </details>
+
         <h3 style={{ marginTop: 16 }}>Recent actions</h3>
         {recentActions.length === 0 ? (
           <div className="status" style={{ marginTop: 0 }}>
diff --git a/src/LensView.tsx b/src/LensView.tsx
new file mode 100644
index 0000000..1e8fbdd
--- /dev/null
+++ b/src/LensView.tsx
@@ -0,0 +1,272 @@
+import { useEffect, useRef } from "react";
+import maplibregl, { Map as MapLibreMap } from "maplibre-gl";
+import "maplibre-gl/dist/maplibre-gl.css";
+import { basemapById } from "./basemaps";
+import type { Asset } from "./types";
+import type { OsmRoadFC } from "./MapView";
+
+type Props = {
+  basemapId: string;
+  centerLng: number;
+  centerLat: number;
+  zoom: number;
+  diameterPx: number;
+  osmRoads?: OsmRoadFC;
+  assets: Asset[];
+  metadataTrack?: Array<[number, number]>;
+};
+
+// Cursor-following magnifier: a circular MapLibre instance that re-projects
+// to whatever the user's cursor is hovering on the main map, at +3 zoom. No
+// deck.gl — assets and OSM roads render as native MapLibre layers from
+// GeoJSON sources so each cursor move is a cheap setCenter() call instead of
+// a full layer rebuild.
+export function LensView({
+  basemapId,
+  centerLng,
+  centerLat,
+  zoom,
+  diameterPx,
+  osmRoads,
+  assets,
+  metadataTrack = [],
+}: Props) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<MapLibreMap | null>(null);
+  const styleReadyRef = useRef<boolean>(false);
+
+  // Hold refs to current data so installLayers can push the live state right
+  // after creating the empty sources — without this, the lens mounts blank
+  // until one of the data deps below changes (which often never happens).
+  const osmRoadsRef = useRef(osmRoads);
+  osmRoadsRef.current = osmRoads;
+  const assetsRef = useRef(assets);
+  assetsRef.current = assets;
+  const metadataTrackRef = useRef(metadataTrack);
+  metadataTrackRef.current = metadataTrack;
+
+  useEffect(() => {
+    if (!containerRef.current) return;
+    const map = new maplibregl.Map({
+      container: containerRef.current,
+      style: basemapById(basemapId).style,
+      center: [centerLng, centerLat],
+      zoom,
+      interactive: false,
+      attributionControl: false,
+    });
+    mapRef.current = map;
+    map.on("load", () => {
+      styleReadyRef.current = true;
+      installLayers(map);
+      pushAllData(map);
+    });
+    return () => {
+      mapRef.current = null;
+      styleReadyRef.current = false;
+      map.remove();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Re-install layers when basemap changes (style swap drops sources/layers).
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map) return;
+    styleReadyRef.current = false;
+    map.setStyle(basemapById(basemapId).style);
+    map.once("styledata", () => {
+      styleReadyRef.current = true;
+      installLayers(map);
+      pushAllData(map);
+    });
+  }, [basemapId]);
+
+  function pushAllData(map: MapLibreMap) {
+    const osmSrc = map.getSource("lens-osm-roads") as
+      | maplibregl.GeoJSONSource
+      | undefined;
+    if (osmSrc && osmRoadsRef.current) {
+      osmSrc.setData(
+        osmRoadsRef.current as unknown as GeoJSON.FeatureCollection<GeoJSON.Geometry>,
+      );
+    }
+    const assetSrc = map.getSource("lens-assets") as
+      | maplibregl.GeoJSONSource
+      | undefined;
+    if (assetSrc) {
+      const features = assetsRef.current
+        .filter(
+          (a) => typeof a.lat === "number" && typeof a.lng === "number",
+        )
+        .map((a) => ({
+          type: "Feature" as const,
+          geometry: {
+            type: "Point" as const,
+            coordinates: [a.lng as number, a.lat as number],
+          },
+          properties: { id: a.id, side: a.side ?? "" },
+        }));
+      assetSrc.setData({ type: "FeatureCollection", features });
+    }
+    const trackSrc = map.getSource("lens-metadata") as
+      | maplibregl.GeoJSONSource
+      | undefined;
+    if (trackSrc) {
+      const t = metadataTrackRef.current;
+      if (t.length < 2) {
+        trackSrc.setData({ type: "FeatureCollection", features: [] });
+      } else {
+        trackSrc.setData({
+          type: "FeatureCollection",
+          features: [
+            {
+              type: "Feature" as const,
+              geometry: {
+                type: "LineString" as const,
+                coordinates: t.slice(),
+              },
+              properties: {},
+            },
+          ],
+        });
+      }
+    }
+  }
+
+  // Push live data into the GeoJSON sources whenever they change.
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !styleReadyRef.current) return;
+    const src = map.getSource("lens-osm-roads") as
+      | maplibregl.GeoJSONSource
+      | undefined;
+    if (src && osmRoads) {
+      src.setData(
+        osmRoads as unknown as GeoJSON.FeatureCollection<GeoJSON.Geometry>,
+      );
+    }
+  }, [osmRoads]);
+
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !styleReadyRef.current) return;
+    const src = map.getSource("lens-assets") as
+      | maplibregl.GeoJSONSource
+      | undefined;
+    if (!src) return;
+    const features = assets
+      .filter((a) => typeof a.lat === "number" && typeof a.lng === "number")
+      .map((a) => ({
+        type: "Feature" as const,
+        geometry: {
+          type: "Point" as const,
+          coordinates: [a.lng as number, a.lat as number],
+        },
+        properties: { id: a.id, side: a.side ?? "" },
+      }));
+    src.setData({ type: "FeatureCollection", features });
+  }, [assets]);
+
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !styleReadyRef.current) return;
+    const src = map.getSource("lens-metadata") as
+      | maplibregl.GeoJSONSource
+      | undefined;
+    if (!src) return;
+    if (metadataTrack.length < 2) {
+      src.setData({ type: "FeatureCollection", features: [] });
+      return;
+    }
+    src.setData({
+      type: "FeatureCollection",
+      features: [
+        {
+          type: "Feature" as const,
+          geometry: {
+            type: "LineString" as const,
+            coordinates: metadataTrack.slice(),
+          },
+          properties: {},
+        },
+      ],
+    });
+  }, [metadataTrack]);
+
+  // Track the cursor world coordinate via prop changes.
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map) return;
+    if (!Number.isFinite(centerLng) || !Number.isFinite(centerLat)) return;
+    map.jumpTo({ center: [centerLng, centerLat], zoom });
+  }, [centerLng, centerLat, zoom]);
+
+  function installLayers(map: MapLibreMap) {
+    if (!map.getSource("lens-osm-roads")) {
+      map.addSource("lens-osm-roads", {
+        type: "geojson",
+        data: { type: "FeatureCollection", features: [] },
+      });
+      map.addLayer({
+        id: "lens-osm-roads",
+        type: "line",
+        source: "lens-osm-roads",
+        paint: {
+          "line-color": "#00e5ff",
+          "line-width": 2,
+          "line-opacity": 0.85,
+        },
+      });
+    }
+    if (!map.getSource("lens-metadata")) {
+      map.addSource("lens-metadata", {
+        type: "geojson",
+        data: { type: "FeatureCollection", features: [] },
+      });
+      map.addLayer({
+        id: "lens-metadata",
+        type: "line",
+        source: "lens-metadata",
+        paint: {
+          "line-color": "#27ae60",
+          "line-width": 2,
+          "line-opacity": 0.9,
+          "line-dasharray": [2, 2],
+        },
+      });
+    }
+    if (!map.getSource("lens-assets")) {
+      map.addSource("lens-assets", {
+        type: "geojson",
+        data: { type: "FeatureCollection", features: [] },
+      });
+      map.addLayer({
+        id: "lens-assets",
+        type: "circle",
+        source: "lens-assets",
+        paint: {
+          "circle-radius": 5,
+          "circle-color": "#e74c3c",
+          "circle-stroke-color": "#ffffff",
+          "circle-stroke-width": 1,
+        },
+      });
+    }
+  }
+
+  return (
+    <div
+      ref={containerRef}
+      style={{
+        width: diameterPx,
+        height: diameterPx,
+        borderRadius: "50%",
+        overflow: "hidden",
+        boxShadow: "0 4px 16px rgba(0,0,0,0.45)",
+        border: "2px solid #fff",
+        background: "#000",
+      }}
+    />
+  );
+}
diff --git a/src/MapView.tsx b/src/MapView.tsx
index d3d97df..f631470 100644
--- a/src/MapView.tsx
+++ b/src/MapView.tsx
@@ -27,7 +27,7 @@ export type OsmRoadFC = {
   features: Array<{
     type: "Feature";
     geometry: unknown;
-    properties: { id: number; name: string | null };
+    properties: { id: number; name: string | null; snap_ignored?: boolean };
   }>;
 };
 
@@ -76,6 +76,9 @@ type Props = {
   osmEditMode?: boolean;
   editingRoadId?: number | null;
   onPickRoad?: (id: number) => void;
+  onRoadRightClick?: (id: number) => void;
+  selectedRoadIds?: Set<number>;
+  multiSelectActive?: boolean;
   onUpdateRoad?: (id: number, coords: Array<[number, number]>) => void;
   roadOffsetMeters?: number;
   drawRoadMode?: boolean;
@@ -89,6 +92,12 @@ type Props = {
   ) => void;
   highlightedIds?: number[];
   anchorIds?: number[];
+  onCursorWorld?: (
+    lng: number,
+    lat: number,
+    screenX: number,
+    screenY: number,
+  ) => void;
 };
 
 // Filled rightward-pointing arrow head, white stroke for legibility on any
@@ -138,6 +147,9 @@ export function MapView({
   osmEditMode = false,
   editingRoadId = null,
   onPickRoad,
+  onRoadRightClick,
+  selectedRoadIds,
+  multiSelectActive = false,
   onUpdateRoad,
   roadOffsetMeters = 4,
   drawRoadMode = false,
@@ -148,6 +160,7 @@ export function MapView({
   onLassoComplete,
   highlightedIds = [],
   anchorIds = [],
+  onCursorWorld,
 }: Props) {
   // Diagnostic counters — visible in DevTools console. Should stay flat
   // during pure pan/zoom; spikes on filter or import.
@@ -179,6 +192,10 @@ export function MapView({
   osmEditModeRef.current = osmEditMode;
   const onPickRoadRef = useRef(onPickRoad);
   onPickRoadRef.current = onPickRoad;
+  const onRoadRightClickRef = useRef(onRoadRightClick);
+  onRoadRightClickRef.current = onRoadRightClick;
+  const onCursorWorldRef = useRef(onCursorWorld);
+  onCursorWorldRef.current = onCursorWorld;
   const drawRoadModeRef = useRef(drawRoadMode);
   drawRoadModeRef.current = drawRoadMode;
   const onDrawRoadAddPointRef = useRef(onDrawRoadAddPoint);
@@ -208,20 +225,46 @@ export function MapView({
 
     map.on("contextmenu", (e) => {
       const overlay = overlayRef.current;
-      if (!overlay || !onAssetRightClickRef.current) return;
+      if (!overlay) return;
       const { x, y } = e.point;
       const info = overlay.pickObject({ x, y, radius: 8 }) as
-        | { object?: unknown; layer?: { id?: string } }
+        | {
+            object?: unknown;
+            layer?: { id?: string };
+            sourceLayer?: { id?: string };
+          }
         | null;
       if (!info || !info.object) return;
-      // An asset record carries `row_id` and `asset_type`; ignore picks that
-      // landed on roads/scopes/metadata.
+      // Road right-click takes priority when in OSM edit mode.
+      if (
+        osmEditModeRef.current &&
+        info.layer?.id === "osm-roads" &&
+        onRoadRightClickRef.current
+      ) {
+        const f = info.object as { properties?: { id?: number } };
+        const rid = f.properties?.id;
+        if (typeof rid === "number") {
+          e.preventDefault();
+          onRoadRightClickRef.current(rid);
+          return;
+        }
+      }
+      if (!onAssetRightClickRef.current) return;
       const obj = info.object as Partial<Asset>;
       if (typeof obj.row_id !== "string" || typeof obj.id !== "number") return;
       e.preventDefault();
       onAssetRightClickRef.current(obj as Asset);
     });
 
+    map.on("mousemove", (e) => {
+      const cb = onCursorWorldRef.current;
+      if (!cb) return;
+      cb(e.lngLat.lng, e.lngLat.lat, e.point.x, e.point.y);
+    });
+    map.on("mouseleave", () => {
+      onCursorWorldRef.current?.(NaN, NaN, NaN, NaN);
+    });
+
     map.on("moveend", () => {
       setIsInteracting(false);
       // Sync the React viewport mirror once per gesture so programmatic
@@ -448,8 +491,14 @@ export function MapView({
 
     const layers: unknown[] = [];
 
+    // Vertex-edit mode collapses to the single road being dragged so other
+    // roads don't clutter the editor. But when multi-select is active (focused
+    // video + bulk select / hide / merge workflow), keep all roads visible.
     const visibleOsm: OsmRoadFC | undefined =
-      osmEditMode && editingRoadId !== null && osmRoads
+      osmEditMode &&
+      editingRoadId !== null &&
+      !multiSelectActive &&
+      osmRoads
         ? {
             type: "FeatureCollection",
             features: osmRoads.features.filter(
@@ -480,10 +529,28 @@ export function MapView({
           data: visibleOsm,
           stroked: true,
           filled: false,
-          getLineColor: [0, 229, 255, 255],
-          getLineWidth: 3,
+          getLineColor: (f: unknown) => {
+            const p = (f as { properties?: { id?: number; snap_ignored?: boolean } })
+              .properties;
+            if (p && selectedRoadIds && typeof p.id === "number" && selectedRoadIds.has(p.id)) {
+              return [255, 196, 0, 255];
+            }
+            if (p?.snap_ignored) return [120, 120, 120, 180];
+            return [0, 229, 255, 255];
+          },
+          getLineWidth: (f: unknown) => {
+            const p = (f as { properties?: { id?: number } }).properties;
+            if (p && selectedRoadIds && typeof p.id === "number" && selectedRoadIds.has(p.id)) {
+              return 5;
+            }
+            return 3;
+          },
           lineWidthUnits: "pixels",
           pickable: osmEditMode,
+          updateTriggers: {
+            getLineColor: [selectedRoadIds],
+            getLineWidth: [selectedRoadIds],
+          },
         }),
       );
       if (osmEditMode && roadOffsetMeters > 0) {
@@ -1406,6 +1473,8 @@ export function MapView({
     zoomBand,
     isInteracting,
     perfMode,
+    selectedRoadIds,
+    multiSelectActive,
   ]);
 
   // Manage draggable HTML markers + per-vertex popup for the actively-edited asset.
@@ -1476,7 +1545,22 @@ export function MapView({
       }
       cap.appendChild(document.createElement("br"));
       const small = document.createElement("small");
-      small.textContent = selectedAsset.row_id;
+      // row_id  ·  video_name   on a single line so users can read both
+      // at a glance without the popup growing taller.
+      const rowSpan = document.createElement("span");
+      rowSpan.textContent = selectedAsset.row_id;
+      small.appendChild(rowSpan);
+      if (selectedAsset.video_name && selectedAsset.video_name !== "Not available") {
+        const sep = document.createElement("span");
+        sep.style.color = "#888";
+        sep.style.margin = "0 6px";
+        sep.textContent = "·";
+        small.appendChild(sep);
+        const vidSpan = document.createElement("span");
+        vidSpan.style.color = "#666";
+        vidSpan.textContent = selectedAsset.video_name;
+        small.appendChild(vidSpan);
+      }
       cap.appendChild(small);
       root.appendChild(cap);
 
diff --git a/src/tauriShim.ts b/src/tauriShim.ts
index 73bae60..0673213 100644
--- a/src/tauriShim.ts
+++ b/src/tauriShim.ts
@@ -132,9 +132,9 @@ const STUBS: Record<string, Stub> = {
   data_source_counts: () => ({
     fixed_assets: FAKE_ASSETS.length,
     range_assets: 0,
-    scope_polygons: 0,
     osm_roads: 0,
-    metadata_polylines: 0,
+    scope_features: 0,
+    video_metadata: 0,
   }),
   list_video_names: () =>
     Array.from(new Set(FAKE_ASSETS.map((a) => a.video_name))),
@@ -145,7 +145,15 @@ const STUBS: Record<string, Stub> = {
   get_scope_polygons: () => [],
   read_video_polylines_json: () => ({}),
   read_metadata_kml: () => [],
-  list_osm_roads: () => ({ type: "FeatureCollection", features: [] }),
+  // Backend rename — App invokes get_osm_roads; the legacy list_osm_roads
+  // alias is kept so older browser fixtures don't crash.
+  get_osm_roads: () => [],
+  list_osm_roads: () => [],
+  get_video_metadata: () => ({}),
+  save_video_metadata: () => 0,
+  clear_video_metadata: () => 0,
+  osm_road_snapshot: () => [],
+  restore_road_state: () => 0,
 };
 
 export function invoke<T = unknown>(