diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index e3176ad8c..17f736d0e 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -2241,12 +2241,13 @@ impl Compositor {
         // Calque ecran : mode 0 (rect droit, NV12 -> RGB) quand la rotation est
         // neutre, mode 8 (warp bilineaire inverse dans la bbox du quad projete)
         // sinon. Place par plan_frame (cover-fit + coins arrondis) ;
-        // `src = g.cut` (crop utilisateur + zoom en UV texture) dans les deux cas.
+        // `src = g.screen_src(g.cut)` (crop utilisateur + zoom en UV texture, bornes
+        // inversees pour un clip tourne) dans les deux cas.
         //
         // FLOU DE VELOCITE. Au mode 0, `src_prev`/`dst_prev` decrivent le MEME
         // calque a la frame precedente ; le shader remappe chaque pixel de sortie
         // par ce couple pour retrouver l'UV qu'il occupait alors, et floute le long
-        // du segment. `src_prev = g.cut` et non un `cut` d'avant : la coupe est
+        // du segment. `src_prev = g.screen_src(g.cut)` et non un `cut` d'avant : la coupe est
         // identique aux deux frames (`plan_frame` ne fait varier que le rect de
         // DESTINATION entre `s_dst` et `s_dst_prev`), ce que Windows documente
         // aussi. Le mouvement vient donc entierement de `dst_prev`.
@@ -2263,11 +2264,13 @@ impl Compositor {
         // Et la remontee du contour interieur du chrome au-dessus de l'ecran (`mb.z` au mode 0,
         // `color.z` au mode 8) : l'arrondi du haut se fait par le cadre. 0 sans fenetre.
         let top_lift = g.screen_top_lift_px([rw, rh]);
+        // The screen texture's source rect: a turned clip samples it with reversed bounds.
+        let src_uv = g.screen_src(g.cut);
         let screen_layer = match tilt.as_ref() {
             None => {
                 // Sous le masque d'un layout en bloc, rogne au slot (`mask_flat_screen`).
                 let (dst, src, quad_px, radius_px) =
-                    g.mask_flat_screen(g.s_dst, g.cut, s_px, g.s_radius, [rw, rh]);
+                    g.mask_flat_screen(g.s_dst, src_uv, s_px, g.s_radius, [rw, rh]);
                 LayerCB {
                     dst,
                     src,
@@ -2275,7 +2278,7 @@ impl Compositor {
                     radius_px,
                     mode: 0.0,
                     color: [1.0, 1.0, 1.0, 1.0],
-                    src_prev: g.cut,
+                    src_prev: src_uv,
                     dst_prev: g.s_dst_prev,
                     mb: [g.screen_pixel_taps([rw, rh]), g.mb_amount, top_lift, square_top],
                     ..Default::default()
@@ -2286,7 +2289,7 @@ impl Compositor {
                 quad,
                 s_px,
                 quad_center_px,
-                g.cut,
+                src_uv,
                 g.focus_plane,
                 g.s_radius,
                 top_lift,
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 07ea2dd7c..4280ef26b 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -2489,7 +2489,8 @@ impl Compositor {
         }
         let square_top = g.screen_square_top();
         let top_lift = g.screen_top_lift_px([rw, rh]);
-        let [su0, sv0, su1, sv1] = g.cut;
+        // The screen texture's source rect: a turned clip samples it with reversed bounds.
+        let [su0, sv0, su1, sv1] = g.screen_src(g.cut);
         // Sous le masque d'un layout en bloc, rogné au slot (`FrameGeometry::mask_flat_screen`).
         let (dst, src, quad_px, radius_px) =
             g.mask_flat_screen(g.s_dst, [su0, sv0, su1, sv1], s_px, g.s_radius, [rw, rh]);
@@ -2516,7 +2517,7 @@ impl Compositor {
                 quad,
                 s_px,
                 quad_center_px,
-                g.cut,
+                g.screen_src(g.cut),
                 g.focus_plane,
                 g.s_radius,
                 top_lift,
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index 26dc8f67b..17fb18055 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -2038,7 +2038,8 @@ impl Compositor {
         let mb_amount = g.mb_amount;
         let source_t = g.source_t;
         let _padding_scale = g.padding_scale;
-        let cut = g.cut;
+        // The screen texture's source rect: a turned clip samples it with reversed bounds.
+        let cut = g.screen_src(g.cut);
         let s_dst = g.s_dst;
         let s_dst_prev = g.s_dst_prev;
         let s_ann = g.s_ann;
@@ -2140,7 +2141,7 @@ impl Compositor {
                 self.draw_video(
                     &LayerCB {
                         dst: [-over, -over, 1.0 + 2.0 * over, 1.0 + 2.0 * over],
-                        src: [0.0, 0.0, u_max, v_max],
+                        src: g.screen_src([0.0, 0.0, u_max, v_max]),
                         quad_px: [self.rw(), self.rh()],
                         mode: 0.0,
                         color: [1.0, 1.0, 1.0, 1.0],
diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs
index d9c104a82..b1bac4fb2 100644
--- a/crates/compositor/src/cursor.rs
+++ b/crates/compositor/src/cursor.rs
@@ -164,6 +164,23 @@ impl CursorTrack {
         }
     }
 
+    /// The same track seen on a picture turned by 180°: every position mirrored, times,
+    /// clicks, visibility and cursor types unchanged. A turned clip is planned entirely in
+    /// what the viewer sees, so its telemetry is turned once here rather than at every reader.
+    pub fn turned(&self) -> CursorTrack {
+        let flip =
+            |v: &[(f32, f32, f32)]| v.iter().map(|&(t, x, y)| (t, 1.0 - x, 1.0 - y)).collect();
+        CursorTrack {
+            samples: flip(&self.samples),
+            follow_samples: flip(&self.follow_samples),
+            clicks: self.clicks.clone(),
+            click_points: self.click_points.iter().map(|&(x, y)| (1.0 - x, 1.0 - y)).collect(),
+            visibility: self.visibility.clone(),
+            types: self.types.clone(),
+            view_cache: Default::default(),
+        }
+    }
+
     /// Visibilité enregistrée au temps `t`. Les anciens sidecars qui n'ont pas ce champ sont
     /// visibles par défaut, comme les lecteurs TypeScript.
     pub fn visible_at(&self, t: f32) -> bool {
@@ -661,6 +678,26 @@ fn cursor_spring_config(smoothing_factor: f32) -> (f32, f32, f32) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn turned_track_mirrors_positions_and_keeps_times() {
+        let t = CursorTrack::new(
+            vec![(0.0, 0.2, 0.3), (1.0, 0.6, 0.9)],
+            vec![0.5],
+            vec![(0.0, "arrow".to_string())],
+        );
+        let r = t.turned();
+        let (x, y) = r.at(0.0).unwrap();
+        assert!((x - 0.8).abs() < 1e-6 && (y - 0.7).abs() < 1e-6, "({x}, {y})");
+        assert_eq!(r.clicks_between(0.0, 1.0), t.clicks_between(0.0, 1.0));
+        assert_eq!(r.type_at(0.0), t.type_at(0.0));
+        let (fx, fy) = r.follow_at(1.0).unwrap();
+        let (gx, gy) = t.follow_at(1.0).unwrap();
+        assert!((fx - (1.0 - gx)).abs() < 1e-5 && (fy - (1.0 - gy)).abs() < 1e-5);
+        // The click point turns with the picture: the click at 0.5 s was at (0.4, 0.6).
+        let (px, py) = r.click_points[0];
+        assert!((px - 0.6).abs() < 1e-6 && (py - 0.4).abs() < 1e-6, "({px}, {py})");
+    }
+
     /// Zone morte du suivi auto : un pointeur qui tremble au centre de la vue ne la bouge pas ;
     /// un pointeur qui part loin est rattrapé, jusqu'au bord de la zone et pas au-delà.
     /// Les vues d'une région sont rejouées une fois puis relues : même réponse dans n'importe quel
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 0decdb21f..0281e64bf 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -1972,6 +1972,11 @@ pub struct FrameGeometry {
     /// Layouts en bloc : le slot de l'écran, un conteneur qui le MASQUE (cf. `ScreenMask`).
     /// `None` ailleurs, et le rendu est celui d'avant, à l'octet.
     pub screen_mask: Option<ScreenMask>,
+    /// The clip being composed is turned by 180°. Everything above is planned in display
+    /// space; only the screen layer's texture sampling turns, through `screen_src`.
+    pub screen_turn: bool,
+    /// `[u_max, v_max]` of the screen texture: the valid area `screen_src` mirrors within.
+    pub screen_uv_max: [f32; 2],
 }
 
 /// Le conteneur d'un layout en bloc (côte à côte, haut/bas) : un masque fixe, overflow hidden.
@@ -2053,6 +2058,18 @@ pub fn annotation_dst_in(anchor: [f32; 4], x: f32, y: f32, w: f32, h: f32) -> [f
 }
 
 impl FrameGeometry {
+    /// The texture rect to sample for a display-space screen rect. Upright: unchanged.
+    /// Turned: mirrored inside the valid area, which reverses both bounds — the shaders
+    /// interpolate linearly from `src.xy` to `src.zw`, so that IS the half turn. `cut` and
+    /// everything planned from it stay in display space.
+    pub fn screen_src(&self, uv: [f32; 4]) -> [f32; 4] {
+        if !self.screen_turn {
+            return uv;
+        }
+        let [um, vm] = self.screen_uv_max;
+        [um - uv[0], vm - uv[1], um - uv[2], vm - uv[3]]
+    }
+
     /// Le quad de l'écran incliné pour une boîte de `s_px` px, `None` quand l'écran est droit.
     /// LE point de passage de l'écran, de son ombre, du curseur et du masque de flou : tous
     /// doivent porter la même séparation base / dynamique, sinon ils se décollent.
@@ -2222,7 +2239,8 @@ impl FrameGeometry {
         let s_px = [self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]];
         let flat = LayerCB {
             dst: [0.0, 0.0, 1.0, 1.0],
-            src: self.cut,
+            // Reread from the screen texture: a turned clip samples it with reversed bounds.
+            src: self.screen_src(self.cut),
             quad_px: s_px,
             radius_px: self.s_radius,
             mode: 18.0,
@@ -3068,9 +3086,19 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         // focus auto) : un plan ne bouge que sous un pointeur qu'on voit. Preview et export
         // chargent la piste dans tous les cas (le focus auto la suit), cette porte fait le reste.
         let parallax_track = cursor_for_zoom.filter(|_| scene.is_some_and(|s| s.cursor.show));
-        let active_crop = scene.and_then(|scene| {
-            scene.crop_by_clip.get(scene.active_clip_index).copied().flatten()
-        });
+        // A turned clip is planned in what the viewer sees: its crop (stored in source
+        // coordinates) is mirrored here, its cursor track is mirrored where it is loaded, and
+        // only the screen layer's sampling maps back to the texture (`screen_src`).
+        let screen_turn = scene.is_some_and(|s| s.screen_turned());
+        let active_crop = scene
+            .and_then(|scene| scene.crop_by_clip.get(scene.active_clip_index).copied().flatten())
+            .map(|c| {
+                if screen_turn {
+                    SceneCrop { x: 1.0 - c.x - c.width, y: 1.0 - c.y - c.height, ..c }
+                } else {
+                    c
+                }
+            });
         if !zoom_regions.is_empty() {
             // L'orbite en focus auto lit le curseur dans l'image SOURCE recadrée — pas dans la
             // coupe zoomée, qu'un focus auto recentre sur lui — et ignore ce qu'une coupe retire.
@@ -3562,6 +3590,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         shape_fade,
         window_frame,
         screen_mask,
+        screen_turn,
+        screen_uv_max: [u_max, v_max],
     }
 }
 
@@ -6502,6 +6532,124 @@ mod tests {
         }
     }
 
+    /// A single-clip scene at zoom 1 with the cursor shown, its clip `rotation` (0 or 180)
+    /// and its crop (`null` or a crop object, verbatim JSON).
+    fn turn_scene(rotation: u16, crop: &str) -> Scene {
+        let mut scene = Scene::from_json(&format!(
+            r##"{{
+            "clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
+            "layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
+                      "webcamReactiveZoom":false}},
+            "effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":0.02,"motionBlur":0}},
+            "background":{{"kind":"color","color":"#1e1e2e"}},
+            "zoomRegions":[],
+            "cursor":{{"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
+            "cropByClip":[{crop}],
+            "output":{{"width":1920,"height":1080,"fps":60}}
+        }}"##
+        ))
+        .expect("turn scene");
+        scene.rotation_by_clip = vec![rotation];
+        scene
+    }
+
+    #[test]
+    fn upright_clip_keeps_screen_src_identity() {
+        let g = framed_plan(&turn_scene(0, "null"));
+        assert!(!g.screen_turn);
+        assert_eq!(g.screen_src(g.cut), g.cut);
+        // An absent field is upright too.
+        let mut absent = turn_scene(0, "null");
+        absent.rotation_by_clip.clear();
+        let g = framed_plan(&absent);
+        assert!(!g.screen_turn);
+        assert_eq!(g.screen_src(g.cut), g.cut);
+    }
+
+    #[test]
+    fn turned_clip_reverses_the_source_bounds_inside_the_valid_area() {
+        let g = framed_plan(&turn_scene(180, "null"));
+        assert!(g.screen_turn);
+        assert_eq!(g.screen_uv_max, [1920.0 / 1920.0, 1080.0 / 1088.0]);
+        // The display-space cut is the upright one: only the sampling turns.
+        assert_eq!(g.cut, framed_plan(&turn_scene(0, "null")).cut);
+        let [a0, b0, a1, b1] = g.screen_src(g.cut);
+        assert!(a0 > a1 && b0 > b1, "bounds reversed: {:?}", [a0, b0, a1, b1]);
+        for v in [a0, a1] {
+            assert!((0.0..=g.screen_uv_max[0]).contains(&v), "u {v}");
+        }
+        for v in [b0, b1] {
+            assert!((0.0..=g.screen_uv_max[1]).contains(&v), "v {v}");
+        }
+        // Full frame: the whole valid area, corner to opposite corner.
+        assert!((a0 - 1.0).abs() < 1e-6 && a1.abs() < 1e-6, "u {a0}..{a1}");
+        assert!((b0 - 1080.0 / 1088.0).abs() < 1e-6 && b1.abs() < 1e-6, "v {b0}..{b1}");
+    }
+
+    #[test]
+    fn turned_crop_selects_the_same_source_pixels() {
+        let crop = r#"{"x":0.1,"y":0.2,"width":0.5,"height":0.3}"#;
+        let g = framed_plan(&turn_scene(180, crop));
+        // Planned in display space: the crop is mirrored, x 0.4..0.9, y 0.5..0.8.
+        let (um, vm) = (g.screen_uv_max[0], g.screen_uv_max[1]);
+        assert!((g.cut[0] / um - 0.4).abs() < 1e-5 && (g.cut[2] / um - 0.9).abs() < 1e-5, "cut {:?}", g.cut);
+        assert!((g.cut[1] / vm - 0.5).abs() < 1e-5 && (g.cut[3] / vm - 0.8).abs() < 1e-5, "cut {:?}", g.cut);
+        // ...and the texture rect sampled is exactly the stored crop, reversed.
+        let [a0, b0, a1, b1] = g.screen_src(g.cut);
+        assert!((a1 / um - 0.1).abs() < 1e-5 && (a0 / um - 0.6).abs() < 1e-5, "u {a0}..{a1}");
+        assert!((b1 / vm - 0.2).abs() < 1e-5 && (b0 / vm - 0.5).abs() < 1e-5, "v {b0}..{b1}");
+        // The screen box keeps the crop's shape either way.
+        assert_eq!(g.s_dst, framed_plan(&turn_scene(0, crop)).s_dst);
+    }
+
+    #[test]
+    fn screen_trail_rereads_a_turned_clip_turned() {
+        let g = framed_plan(&turn_scene(180, "null"));
+        assert_eq!(g.screen_trail_cb(RENDER, false).src, g.screen_src(g.cut));
+        let upright = framed_plan(&turn_scene(0, "null"));
+        assert_eq!(upright.screen_trail_cb(RENDER, false).src, upright.cut);
+    }
+
+    #[test]
+    fn cursor_of_a_turned_clip_lands_on_the_turned_content() {
+        let cfg = crate::config::all().pop().expect("au moins une config");
+        let center = |rotation: u16, track: &'static crate::cursor::CursorTrack| -> ([f32; 2], [f32; 4]) {
+            let scene = turn_scene(rotation, "null");
+            let g = framed_plan(&scene);
+            let mut live = live_params_from_scene(&scene);
+            live.cursor_model3d = false;
+            let plan = plan_cursor(
+                &g,
+                &CursorPlanInput {
+                    render_px: RENDER,
+                    u_max: 1.0,
+                    v_max: 1080.0 / 1088.0,
+                    cfg: &cfg,
+                    live,
+                    scene: Some(&scene),
+                    track,
+                    t: 1.5,
+                },
+            )
+            .expect("cursor in view");
+            match plan.placement {
+                CursorPlacement::Upright { center } => (center, g.s_dst),
+                _ => panic!("upright screen, flat sprite"),
+            }
+        };
+        let (x, y) = (0.2f32, 0.3f32);
+        // Upright: the cursor sits at (x, y) of the screen box.
+        let (c, d) = center(0, parked_track(x, y));
+        let want = [d[0] + x * d[2], d[1] + y * d[3]];
+        assert!((c[0] - want[0]).abs() < 1e-5 && (c[1] - want[1]).abs() < 1e-5, "{c:?} vs {want:?}");
+        // Turned: the track is turned where it is loaded, so the cursor sits where the turned
+        // picture shows that source point, (1 - x, 1 - y) of the screen box.
+        let turned: &'static crate::cursor::CursorTrack = Box::leak(Box::new(parked_track(x, y).turned()));
+        let (c, d) = center(180, turned);
+        let want = [d[0] + (1.0 - x) * d[2], d[1] + (1.0 - y) * d[3]];
+        assert!((c[0] - want[0]).abs() < 1e-5 && (c[1] - want[1]).abs() < 1e-5, "{c:?} vs {want:?}");
+    }
+
     /// Le curseur est sur le métrage : le slot le rogne aussi.
     #[test]
     fn the_cursor_is_clipped_to_the_slot() {
@@ -7793,6 +7941,8 @@ mod tests {
             shape_fade: 0.0,
             window_frame: None,
             screen_mask: None,
+            screen_turn: false,
+            screen_uv_max: [1.0, 1.0],
         }
     }
 
diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs
index 16c75bd9e..3229ff498 100644
--- a/crates/compositor/src/live.rs
+++ b/crates/compositor/src/live.rs
@@ -810,6 +810,61 @@ fn resolve_scene_clip_index(
     }
 }
 
+/// The cache key of a clip's cursor track. A turned clip uses the same telemetry file
+/// mirrored (`CursorTrack::turned`), so the two must never share a cache entry.
+pub(crate) fn cursor_key(screen_path: &str, turned: bool) -> String {
+    let path = format!("{screen_path}.cursor.json");
+    if turned { format!("{path}#turned") } else { path }
+}
+
+/// A clip's cursor track as the compositor reads it: mirrored for a turned clip, whose frame is
+/// planned in what the viewer sees.
+fn oriented_cursor(track: CursorTrack, turned: bool) -> CursorTrack {
+    if turned { track.turned() } else { track }
+}
+
+/// Rereads the active clip's cursor telemetry when its key changed (another file, or the same
+/// file turned the other way) and hands it to the compositor already smoothed, so a paused
+/// preview never shows one unsmoothed frame. Returns whether it reread.
+fn reload_cursor_if_changed(
+    comp: &Compositor,
+    raw_cursor: &mut Option<CursorTrack>,
+    loaded_cursor_path: &mut String,
+    screen_path: &str,
+    turned: bool,
+    smoothing: f32,
+) -> bool {
+    let key = cursor_key(screen_path, turned);
+    if key == *loaded_cursor_path {
+        return false;
+    }
+    let cursor_path = format!("{screen_path}.cursor.json");
+    *raw_cursor = CursorTrack::load(&cursor_path, 0.0, 24.0 * 3600.0)
+        .ok()
+        .map(|t| oriented_cursor(t, turned));
+    // Journalisé ICI seulement : sinon la ligne annonce « loaded=ok » à
+    // chaque changement de segment alors que rien n'a été relu, et le log
+    // laisse croire à un travail qui n'a plus lieu.
+    match raw_cursor {
+        Some(track) => eprintln!(
+            "[live] cursor: path={} turned={} loaded=ok samples={}",
+            cursor_path,
+            turned,
+            track.sample_count(),
+        ),
+        None => eprintln!("[live] cursor: path={} loaded=FAIL — clear_cursor()", cursor_path),
+    }
+    *loaded_cursor_path = key;
+    // Sans relecture, rien à reposer : un changement de taille garde le
+    // curseur (`Compositor::resized`), et le relisser parcourt tout
+    // l'enregistrement à chaque bascule d'un scrub.
+    match raw_cursor {
+        Some(track) => comp.set_cursor(track.smoothed(smoothing)),
+        None => comp.clear_cursor(),
+    }
+    true
+}
+
 fn scene_for_clip(scene: &Scene, clip_index: usize) -> Scene {
     match scene.clips.get(clip_index) {
         Some(clip) => scene.for_clip_window(
@@ -1428,20 +1483,24 @@ unsafe fn advance_to_next_scene_clip(
             *active_webcam_path = next_clip.webcam_path.clone();
             *active_webcam_offset_sec = next_clip.webcam_offset_sec;
             *active_clip_index = next_index;
-            comp.set_scene(Some(scene_for_clip(scene, *active_clip_index)));
+            let clip_scene = scene_for_clip(scene, *active_clip_index);
+            let turned = clip_scene.screen_turned();
+            comp.set_scene(Some(clip_scene));
             player.set_programme_clock(Some(scene), *active_clip_index);
             // Réutilise le curseur préchargé s'il est disponible (voir plus haut) — sinon
             // (préchargement pas encore prêt / raté) on retombe sur la lecture synchrone
-            // habituelle, comme avant cette optimisation.
+            // habituelle, comme avant cette optimisation. The prefetched track is the raw
+            // file: it is turned here, where the clip it belongs to is known.
             let cursor_path = format!("{}.cursor.json", active_screen_path);
             *raw_cursor = match prefetched_cursor {
                 Some(track) => track,
                 None => CursorTrack::load(&cursor_path, 0.0, 24.0 * 3600.0).ok(),
-            };
+            }
+            .map(|t| oriented_cursor(t, turned));
             // Le fichier est noté avec la piste. Sinon une requête de clip qui revient sur le
             // fichier d'avant le croit encore chargé, ne relit rien, et dessine sur ce clip la
             // télémétrie de celui qu'on vient de quitter.
-            *loaded_cursor_path = cursor_path;
+            *loaded_cursor_path = cursor_key(active_screen_path, turned);
             match raw_cursor {
                 Some(track) => comp.set_cursor(track.smoothed(0.0)),
                 None => comp.clear_cursor(),
@@ -1497,7 +1556,8 @@ unsafe fn render_thread(
     // fichier à chaque changement du slider "smoothing" (voir la boucle plus bas).
     let mut raw_cursor = CursorTrack::load(cursor_json, 0.0, 24.0 * 3600.0).ok();
     /// Chemin de la télémétrie curseur actuellement chargée dans `raw_cursor` — évite de
-    /// relire le même fichier à chaque changement de segment (voir plus bas).
+    /// relire le même fichier à chaque changement de segment (voir plus bas). Compared with
+    /// `cursor_key`: no scene has arrived yet, so this first track is upright.
     let mut loaded_cursor_path = cursor_json.to_string();
     if let Some(track) = &raw_cursor {
         comp.set_cursor(track.smoothed(0.0));
@@ -1623,6 +1683,7 @@ unsafe fn render_thread(
                     active_webcam_offset_sec = request.webcam_offset_sec;
                     let scene = shared.scene.lock().unwrap().clone();
                     full_scene = scene.clone();
+                    let mut turned = false;
                     if let Some(base_scene) = scene {
                         if let Some(index) = resolve_scene_clip_index(
                             &base_scene,
@@ -1638,7 +1699,9 @@ unsafe fn render_thread(
                                 active_screen_path, active_webcam_path
                             );
                         }
-                        comp.set_scene(Some(scene_for_clip(&base_scene, active_clip_index)));
+                        let clip_scene = scene_for_clip(&base_scene, active_clip_index);
+                        turned = clip_scene.screen_turned();
+                        comp.set_scene(Some(clip_scene));
                         scene_applied = true;
                     }
                     // Relire la télémétrie curseur seulement si le FICHIER change. Elle était
@@ -1646,32 +1709,16 @@ unsafe fn render_thread(
                     // compris quand seul le segment changeait, où le chemin est par
                     // construction identique. Mesuré : 66 bascules sur un scrub de deux clips,
                     // donc 66 relectures du même fichier.
-                    let cursor_path = format!("{}.cursor.json", active_screen_path);
-                    if cursor_path != loaded_cursor_path {
-                        loaded_cursor_path = cursor_path.clone();
-                        raw_cursor = CursorTrack::load(&cursor_path, 0.0, 24.0 * 3600.0).ok();
-                        // Journalisé ICI seulement : sinon la ligne annonce « loaded=ok » à
-                        // chaque changement de segment alors que rien n'a été relu, et le log
-                        // laisse croire à un travail qui n'a plus lieu.
-                        match &raw_cursor {
-                            Some(track) => eprintln!(
-                                "[live] cursor: path={} loaded=ok samples={}",
-                                cursor_path,
-                                track.sample_count(),
-                            ),
-                            None => eprintln!(
-                                "[live] cursor: path={} loaded=FAIL — clear_cursor()",
-                                cursor_path,
-                            ),
-                        }
-                        // Sans relecture, rien à reposer : un changement de taille garde le
-                        // curseur (`Compositor::resized`), et le relisser parcourt tout
-                        // l'enregistrement à chaque bascule d'un scrub.
-                        match &raw_cursor {
-                            Some(track) => comp.set_cursor(track.smoothed(0.0)),
-                            None => comp.clear_cursor(),
-                        }
-                        last_smoothing = -1.0;
+                    // The key also carries the clip's turn: the same file turned is another track.
+                    if reload_cursor_if_changed(
+                        &comp,
+                        &mut raw_cursor,
+                        &mut loaded_cursor_path,
+                        &active_screen_path,
+                        turned,
+                        ip.cursor_smoothing,
+                    ) {
+                        last_smoothing = ip.cursor_smoothing;
                     }
                     clip_changed = true;
                 }
@@ -1741,7 +1788,20 @@ unsafe fn render_thread(
                 }
                 scene_for_clip(&base_scene, active_clip_index)
             });
+            // Turning the active clip changes no file, only the scene: its track is reread
+            // here, mirrored the new way.
+            let turned = scene.as_ref().is_some_and(Scene::screen_turned);
             comp.set_scene(scene);
+            if reload_cursor_if_changed(
+                &comp,
+                &mut raw_cursor,
+                &mut loaded_cursor_path,
+                &active_screen_path,
+                turned,
+                ip.cursor_smoothing,
+            ) {
+                last_smoothing = ip.cursor_smoothing;
+            }
         }
         // Le temps programme dépend du clip actif ET de la scène entière (durées des clips
         // précédents) : à recalculer dès que l'un des deux change.
@@ -2255,9 +2315,15 @@ pub fn run_standalone(_screen: &str, _webcam: &str, _cursor_json: &str) -> anyho
 
 #[cfg(test)]
 mod tests {
-    use super::{open_settle_window, should_settle, SETTLE_STEP, SETTLE_WINDOW};
+    use super::{cursor_key, open_settle_window, should_settle, SETTLE_STEP, SETTLE_WINDOW};
     use std::time::Instant;
 
+    #[test]
+    fn cursor_key_tells_a_turned_clip_from_an_upright_one() {
+        assert_eq!(cursor_key("a.mp4", false), "a.mp4.cursor.json");
+        assert_ne!(cursor_key("a.mp4", false), cursor_key("a.mp4", true));
+    }
+
     /// Le bug d'origine : en pause, un seul recompose par changement, donc le masque de
     /// segmentation (asynchrone, 3 composes de latence) n'arrivait jamais avant un scrub.
     #[test]
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index 895fa6b2a..a8237c978 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -795,6 +795,11 @@ pub struct Scene {
     /// Crop écran par clip, dans le même ordre que `clips` (`cropByClip` côté TS).
     #[serde(default)]
     pub crop_by_clip: Vec<Option<SceneCrop>>,
+    /// Half turn of each clip's main picture, same order as `clips` (`rotationByClip` on
+    /// the TS side). Values are 0 or 180; any other u16 is treated as upright. Absent in every
+    /// scene written before it.
+    #[serde(default)]
+    pub rotation_by_clip: Vec<u16>,
     /// Effet d'arrière-plan de la webcam. Absent = aucun effet.
     #[serde(default)]
     pub webcam_effect: Option<SceneWebcamEffect>,
@@ -810,6 +815,11 @@ impl Scene {
         Ok(serde_json::from_str(json)?)
     }
 
+    /// Whether the clip being composed is turned by 180°.
+    pub fn screen_turned(&self) -> bool {
+        self.rotation_by_clip.get(self.active_clip_index) == Some(&180)
+    }
+
     /// Copie de scène limitée aux régions du clip actif. `clipIndex` est l'identité fiable
     /// lorsque plusieurs clips réutilisent les mêmes temps source ; son absence retombe sur le
     /// chevauchement avec la fenêtre source pour accepter les anciens payloads.
@@ -1212,6 +1222,25 @@ mod annotation_tests {
         );
     }
 
+    #[test]
+    fn rotation_by_clip_defaults_empty_and_reads_the_active_clip() {
+        let scene = Scene::from_json(&scene_json("[]")).expect("parse");
+        assert!(scene.rotation_by_clip.is_empty());
+        assert!(!scene.screen_turned());
+        let mut turned = scene.clone();
+        turned.rotation_by_clip = vec![0, 180];
+        assert!(!turned.for_clip_window(0, 0.0, 1.0).screen_turned());
+        assert!(turned.for_clip_window(1, 0.0, 1.0).screen_turned());
+        // Only a half turn counts; anything else stays upright.
+        turned.rotation_by_clip = vec![90];
+        assert!(!turned.for_clip_window(0, 0.0, 1.0).screen_turned());
+        // The field arrives from the app as `rotationByClip`.
+        let json = scene_json("[]").replace(r#""cropByClip":[]"#, r#""cropByClip":[],"rotationByClip":[180]"#);
+        let parsed = Scene::from_json(&json).expect("parse rotationByClip");
+        assert_eq!(parsed.rotation_by_clip, vec![180]);
+        assert!(parsed.screen_turned());
+    }
+
     #[test]
     fn for_clip_window_still_falls_back_to_window_overlap_without_a_clip_index() {
         // Vieux payload : rien ne dit à quel clip la région appartient, le chevauchement de
diff --git a/crates/compositor/src/timeline_walk.rs b/crates/compositor/src/timeline_walk.rs
index a16271c8b..d5dab6617 100644
--- a/crates/compositor/src/timeline_walk.rs
+++ b/crates/compositor/src/timeline_walk.rs
@@ -19,6 +19,7 @@ use crate::cursor::CursorTrack;
 use crate::d3d::Gpu;
 use crate::ffi::AVFrame;
 use crate::frame_geometry::webcam_is_real;
+use crate::live::cursor_key;
 use crate::pipeline::{ClipSource, Decoder};
 use crate::regions::{speed_segments_for_window, SpeedSegment};
 use crate::scene::Scene;
@@ -268,6 +269,8 @@ pub(crate) unsafe fn walk_composited_timeline(
             source_end_sec,
             out_fps as f64,
         );
+        // A turned clip is planned in what the viewer sees: its cursor track is the mirrored one.
+        let turned = clip_scene.as_ref().is_some_and(|s| s.screen_turned());
         if clip_scene.is_some() {
             comp.set_scene(clip_scene);
         }
@@ -285,18 +288,21 @@ pub(crate) unsafe fn walk_composited_timeline(
         }
 
         if cursor_enabled {
-            if !cursor_tracks.contains_key(&clip.screen) {
+            // Keyed by file AND turn: the same file turned is another track.
+            let key = cursor_key(&clip.screen, turned);
+            if !cursor_tracks.contains_key(&key) {
                 let path = format!("{}.cursor.json", clip.screen);
                 if let Ok(raw) = CursorTrack::load(&path, 0.0, 24.0 * 3600.0) {
-                    cursor_tracks.insert(clip.screen.clone(), raw.smoothed(cursor_smoothing));
+                    let raw = if turned { raw.turned() } else { raw };
+                    cursor_tracks.insert(key.clone(), raw.smoothed(cursor_smoothing));
                 }
                 // absente/illisible → pas d'entrée : ce clip s'exporte sans curseur (visible,
                 // pas masqué en un curseur fantôme d'un autre clip).
             }
-            if cursor_active_path.as_deref() != Some(clip.screen.as_str()) {
-                if let Some(track) = cursor_tracks.get(&clip.screen) {
+            if cursor_active_path.as_deref() != Some(key.as_str()) {
+                if let Some(track) = cursor_tracks.get(&key) {
                     comp.set_cursor(track.clone());
-                    cursor_active_path = Some(clip.screen.clone());
+                    cursor_active_path = Some(key);
                 } else {
                     comp.clear_cursor();
                     comp.set_cursor_time(None);
diff --git a/src/components/ai-edition/EditClipModal.test.tsx b/src/components/ai-edition/EditClipModal.test.tsx
index 9d5c5ad07..b687d9ba2 100644
--- a/src/components/ai-edition/EditClipModal.test.tsx
+++ b/src/components/ai-edition/EditClipModal.test.tsx
@@ -1,10 +1,10 @@
 // @vitest-environment jsdom
 import "@testing-library/jest-dom";
-import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { act, cleanup, fireEvent, render, screen, within } from "@testing-library/react";
 import type { ReactElement } from "react";
 import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import { I18nProvider } from "@/contexts/I18nContext";
-import type { AxcutClip } from "@/lib/ai-edition/schema";
+import { type AxcutClip, clipCropRegionSchema } from "@/lib/ai-edition/schema";
 import { EditClipModal } from "./Modals";
 
 function renderWithI18n(ui: ReactElement) {
@@ -232,6 +232,7 @@ describe("EditClipModal crop from the keyboard", () => {
 			20,
 			105,
 			expect.objectContaining({ x: 0.01, y: 0, width: 0.99 }),
+			undefined,
 		);
 	});
 });
@@ -357,3 +358,135 @@ describe("EditClipModal playhead for framing the crop", () => {
 		expect(onClose).toHaveBeenCalledTimes(1);
 	});
 });
+
+describe("EditClipModal rotation", () => {
+	// Stored in source coordinates; on the turned picture this crop sits at 40%, 50%.
+	const TURNED: AxcutClip = {
+		...CLIP,
+		cropRegion: { x: 0.1, y: 0.2, width: 0.5, height: 0.3 },
+		rotation: 180,
+	};
+
+	function renderTurned(clip: AxcutClip = TURNED) {
+		const onApply = vi.fn();
+		renderWithI18n(
+			<EditClipModal
+				open
+				onClose={vi.fn()}
+				clip={clip}
+				assetMeta={ASSET}
+				videoSources={[]}
+				onApply={onApply}
+			/>,
+		);
+		return { onApply };
+	}
+	const cropText = () =>
+		screen.getByRole("slider", { name: "Crop" }).getAttribute("aria-valuetext");
+	const rotationButton = (name: string) =>
+		within(screen.getByRole("group", { name: "Rotation" })).getByRole("button", { name });
+
+	it("shows a turned clip's crop mirrored, and opens with nothing to apply", () => {
+		renderTurned();
+
+		expect(cropText()).toBe("40%, 50%, 50% × 30%");
+		expect(rotationButton("180°")).toHaveAttribute("aria-pressed", "true");
+		expect(screen.getByRole("button", { name: "Apply" })).toBeDisabled();
+	});
+
+	it("keeps the stored crop when the rotation is toggled", () => {
+		const { onApply } = renderTurned();
+
+		fireEvent.click(rotationButton("0°"));
+		// The frame jumps with the picture: upright, the stored crop shows as stored.
+		expect(cropText()).toBe("10%, 20%, 50% × 30%");
+		fireEvent.click(screen.getByRole("button", { name: "Apply" }));
+
+		expect(onApply).toHaveBeenCalledWith(20, 105, undefined, 0);
+	});
+
+	it("turns an upright clip, keeping its crop", () => {
+		const { onApply } = renderTurned({ ...TURNED, rotation: undefined });
+
+		expect(cropText()).toBe("10%, 20%, 50% × 30%");
+		fireEvent.click(rotationButton("180°"));
+		expect(cropText()).toBe("40%, 50%, 50% × 30%");
+		fireEvent.click(screen.getByRole("button", { name: "Apply" }));
+
+		expect(onApply).toHaveBeenCalledWith(20, 105, undefined, 180);
+	});
+
+	it("Reset restores the stored rotation", () => {
+		renderTurned();
+
+		fireEvent.click(rotationButton("0°"));
+		expect(screen.getByRole("button", { name: "Reset" })).toBeEnabled();
+		fireEvent.click(screen.getByRole("button", { name: "Reset" }));
+
+		expect(rotationButton("180°")).toHaveAttribute("aria-pressed", "true");
+		expect(cropText()).toBe("40%, 50%, 50% × 30%");
+		expect(screen.getByRole("button", { name: "Reset" })).toBeDisabled();
+		expect(screen.getByRole("button", { name: "Apply" })).toBeDisabled();
+	});
+
+	it("Apply converts a crop moved on the turned picture back to source coordinates", () => {
+		const { onApply } = renderTurned();
+
+		// One step right and one down on the turned picture is one left and one up in the source.
+		const crop = screen.getByRole("slider", { name: "Crop" });
+		fireEvent.keyDown(crop, { key: "ArrowRight" });
+		fireEvent.keyDown(crop, { key: "ArrowDown" });
+		expect(cropText()).toBe("41%, 51%, 50% × 30%");
+		fireEvent.click(screen.getByRole("button", { name: "Apply" }));
+
+		expect(onApply).toHaveBeenCalledWith(
+			20,
+			105,
+			{
+				x: expect.closeTo(0.09, 9),
+				y: expect.closeTo(0.19, 9),
+				width: expect.closeTo(0.5, 9),
+				height: expect.closeTo(0.3, 9),
+			},
+			undefined,
+		);
+	});
+
+	it("saves a crop moved flush against the turned picture's edge", () => {
+		// 1 - 0.9 - 0.1 is -2.8e-17 in floating point, which the schema rejects as below 0.
+		const { onApply } = renderTurned({
+			...TURNED,
+			cropRegion: { x: 0.01, y: 0.01, width: 0.1, height: 0.1 },
+		});
+
+		const crop = screen.getByRole("slider", { name: "Crop" });
+		fireEvent.keyDown(crop, { key: "ArrowRight" });
+		fireEvent.keyDown(crop, { key: "ArrowDown" });
+		expect(cropText()).toBe("90%, 90%, 10% × 10%");
+		fireEvent.click(screen.getByRole("button", { name: "Apply" }));
+
+		const saved = onApply.mock.calls[0][2];
+		expect(saved.x).toBeGreaterThanOrEqual(0);
+		expect(saved.y).toBeGreaterThanOrEqual(0);
+		expect(clipCropRegionSchema.safeParse(saved).success).toBe(true);
+	});
+
+	it("turns the crop preview's picture, not the frame drawn over it", () => {
+		renderWithI18n(
+			<EditClipModal
+				open
+				onClose={vi.fn()}
+				clip={TURNED}
+				assetMeta={ASSET}
+				videoSources={[{ id: "asset_1", src: "file:///rec.mp4", label: "rec" }]}
+				onApply={vi.fn()}
+			/>,
+		);
+		const video = document.querySelector("video");
+		if (!video) throw new Error("no preview video rendered");
+		expect(video.style.transform).toBe("rotate(180deg)");
+
+		fireEvent.click(rotationButton("0°"));
+		expect(video.style.transform).toBe("");
+	});
+});
diff --git a/src/components/ai-edition/Modals.tsx b/src/components/ai-edition/Modals.tsx
index f2b7bb7a8..6cef1f098 100644
--- a/src/components/ai-edition/Modals.tsx
+++ b/src/components/ai-edition/Modals.tsx
@@ -9,6 +9,7 @@ import {
 } from "react";
 import type { CropRegion } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
+import { type ClipRotation, clipRotation, turnCropRegion } from "@/lib/ai-edition/clipRotation";
 import type { AxcutClip } from "@/lib/ai-edition/schema";
 import { formatSeconds } from "@/lib/ai-edition/timeline/format";
 import { cropDraftFromRegion, cropDraftToPct, previewBoxStyle } from "./cropDraft";
@@ -644,14 +645,26 @@ export interface AssetMeta {
 
 const IDENTITY_CROP: CropRegion = { x: 0, y: 0, width: 1, height: 1 };
 
+// The clip's stored crop as the dialog shows it: on the turned picture for a turned clip.
+function shownCropRegion(clip: AxcutClip): CropRegion {
+	const region = clip.cropRegion ?? IDENTITY_CROP;
+	return clipRotation(clip) === 180 ? turnCropRegion(region) : region;
+}
+
 interface EditClipModalProps extends BaseModalProps {
 	clip: AxcutClip | null;
 	assetMeta: AssetMeta | null;
 	videoSources: VideoSource[];
 	/** `cropRegion` is `undefined` when the crop section wasn't touched (Reset
 	 * back to the clip's stored value) — the caller can skip the write in that
-	 * case — and `null` when the user explicitly reset it to "no crop". */
-	onApply: (sourceStartSec: number, sourceEndSec: number, cropRegion?: CropRegion | null) => void;
+	 * case — and `null` when the user explicitly reset it to "no crop". `rotation` is
+	 * `undefined` when it was left as stored. */
+	onApply: (
+		sourceStartSec: number,
+		sourceEndSec: number,
+		cropRegion?: CropRegion | null,
+		rotation?: ClipRotation,
+	) => void;
 }
 
 // Mirrors Axcut's ClipEditDialog: an embedded preview of just this clip plus
@@ -685,6 +698,8 @@ export function EditClipModal({
 	const [cropHPct, setCropHPct] = useState(100);
 	const [cropRatio, setCropRatio] = useState("free");
 	const [cropTouched, setCropTouched] = useState(false);
+	// The crop draft is kept as the dialog shows it: on the turned picture when this is 180.
+	const [draftRotation, setDraftRotation] = useState<ClipRotation>(0);
 	// Source video's real pixel aspect ratio (width/height) — needed to convert
 	// between a preset's visual ratio (e.g. 16/9) and the crop region's
 	// fraction-of-frame width/height. 16/9 is just a placeholder until the
@@ -704,8 +719,8 @@ export function EditClipModal({
 		setDraftEnd(clip.sourceEndSec ?? clip.sourceStartSec);
 		setActiveEdge(null);
 		setPlayheadSec(clip.sourceStartSec);
-		const region = clip.cropRegion ?? IDENTITY_CROP;
-		const pct = cropDraftToPct(cropDraftFromRegion(region));
+		setDraftRotation(clipRotation(clip));
+		const pct = cropDraftToPct(cropDraftFromRegion(shownCropRegion(clip)));
 		setCropXPct(pct.x);
 		setCropYPct(pct.y);
 		setCropWPct(pct.w);
@@ -785,7 +800,7 @@ export function EditClipModal({
 	const hasTrimChanges =
 		Math.abs(draftStart - clip.sourceStartSec) > 0.001 ||
 		Math.abs(draftEnd - (clip.sourceEndSec ?? 0)) > 0.001;
-	const hasChanges = hasTrimChanges || cropTouched;
+	const hasChanges = hasTrimChanges || cropTouched || draftRotation !== clipRotation(clip);
 	const clipSources = videoSources.filter((s) => s.id === clip.assetId);
 	const cropPreviewSource = clipSources[0] ?? null;
 
@@ -861,6 +876,15 @@ export function EditClipModal({
 		setCropHPct(fit.h);
 	};
 
+	// Turning the picture keeps the stored crop, so the frame jumps with the picture. That is
+	// not a crop edit: `cropTouched` stays as it was.
+	const handleRotationChange = (next: ClipRotation) => {
+		if (next === draftRotation) return;
+		setDraftRotation(next);
+		setCropXPct(100 - cropXPct - cropWPct);
+		setCropYPct(100 - cropYPct - cropHPct);
+	};
+
 	// Fraction-space width/height ratio the crop is locked to while a preset is
 	// active (null for "Free"). The resize handles honor it, so the user can
 	// move/scale the crop but never change its aspect ratio.
@@ -951,8 +975,9 @@ export function EditClipModal({
 		setDraftStart(clip.sourceStartSec);
 		setDraftEnd(end);
 		setPlayheadSec((p) => Math.min(Math.max(p, clip.sourceStartSec), end));
+		setDraftRotation(clipRotation(clip));
 		const region = clip.cropRegion ?? IDENTITY_CROP;
-		const pct = cropDraftToPct(cropDraftFromRegion(region));
+		const pct = cropDraftToPct(cropDraftFromRegion(shownCropRegion(clip)));
 		setCropXPct(pct.x);
 		setCropYPct(pct.y);
 		setCropWPct(pct.w);
@@ -961,15 +986,25 @@ export function EditClipModal({
 		setCropTouched(false);
 	};
 	const handleApply = () => {
-		const nextCrop: CropRegion = {
-			x: Math.max(0, Math.min(1, cropXPct / 100)),
-			y: Math.max(0, Math.min(1, cropYPct / 100)),
-			width: Math.max(0.01, Math.min(1, cropWPct / 100)),
-			height: Math.max(0.01, Math.min(1, cropHPct / 100)),
+		const width = Math.max(0.01, Math.min(1, cropWPct / 100));
+		const height = Math.max(0.01, Math.min(1, cropHPct / 100));
+		// Kept inside the frame, so turning it never yields a negative x/y.
+		const shownCrop: CropRegion = {
+			x: Math.max(0, Math.min(1 - width, cropXPct / 100)),
+			y: Math.max(0, Math.min(1 - height, cropYPct / 100)),
+			width,
+			height,
 		};
+		// Stored in source coordinates, whatever the dialog showed it on.
+		const nextCrop = draftRotation === 180 ? turnCropRegion(shownCrop) : shownCrop;
 		const isIdentity =
 			nextCrop.x === 0 && nextCrop.y === 0 && nextCrop.width === 1 && nextCrop.height === 1;
-		onApply(draftStart, draftEnd, cropTouched ? (isIdentity ? null : nextCrop) : undefined);
+		onApply(
+			draftStart,
+			draftEnd,
+			cropTouched ? (isIdentity ? null : nextCrop) : undefined,
+			draftRotation !== clipRotation(clip) ? draftRotation : undefined,
+		);
 		onClose();
 	};
 
@@ -1034,6 +1069,7 @@ export function EditClipModal({
 							height: "100%",
 							objectFit: "contain",
 							background: "#000",
+							transform: draftRotation === 180 ? "rotate(180deg)" : undefined,
 						}}
 					/>
 				) : null}
@@ -1195,6 +1231,26 @@ export function EditClipModal({
 							onChange={handleCropRatioChange}
 						/>
 					</div>
+					<span className={styles.fieldLabel}>{t("editClipDialog.rotation")}</span>
+					<div style={{ flexShrink: 0 }}>
+						<ChoiceRow<ClipRotation>
+							label={t("editClipDialog.rotation")}
+							options={[
+								{
+									value: 0,
+									label: t("editClipDialog.rotationUpright"),
+									title: t("editClipDialog.rotationTip"),
+								},
+								{
+									value: 180,
+									label: t("editClipDialog.rotationTurned"),
+									title: t("editClipDialog.rotationTip"),
+								},
+							]}
+							value={draftRotation}
+							onChange={handleRotationChange}
+						/>
+					</div>
 				</div>
 			</div>
 		</ModalShell>
diff --git a/src/components/ai-edition/NewEditorShell.tsx b/src/components/ai-edition/NewEditorShell.tsx
index 08b52f21e..5fafc485c 100644
--- a/src/components/ai-edition/NewEditorShell.tsx
+++ b/src/components/ai-edition/NewEditorShell.tsx
@@ -1709,7 +1709,7 @@ export function NewEditorShell() {
 						: null
 				}
 				videoSources={videoSources}
-				onApply={(sStart, sEnd, cropRegion) => {
+				onApply={(sStart, sEnd, cropRegion, rotation) => {
 					if (!editClipTarget) return;
 					const clipId = editClipTarget.id;
 					// One user action, one document, one save. This used to be two calls —
@@ -1718,7 +1718,9 @@ export function NewEditorShell() {
 					// first and one of the two edits vanished silently (#355). It goes on the
 					// shared write queue for the same reason every other timeline edit does:
 					// so it can't clobber, or be clobbered by, a save already in flight.
-					void enqueueTimelineWrite(() => tl.applyClipEdit(clipId, sStart, sEnd, cropRegion));
+					void enqueueTimelineWrite(() =>
+						tl.applyClipEdit(clipId, sStart, sEnd, cropRegion, rotation),
+					);
 					setEditClipTarget(null);
 				}}
 			/>
diff --git a/src/components/ai-edition/PreviewCanvas.tsx b/src/components/ai-edition/PreviewCanvas.tsx
index c817fde3c..59bf4030b 100644
--- a/src/components/ai-edition/PreviewCanvas.tsx
+++ b/src/components/ai-edition/PreviewCanvas.tsx
@@ -33,6 +33,7 @@ import {
 	type ZoomFocus,
 } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
+import { clipRotation } from "@/lib/ai-edition/clipRotation";
 import {
 	isFormatFillActive,
 	resolveAspectRatioValue,
@@ -228,6 +229,7 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 		[props.clips, props.currentTimeSec],
 	);
 	const cropRegion: CropRegion = activeClip?.cropRegion ?? DEFAULT_CROP_REGION;
+	const rotation = activeClip ? clipRotation(activeClip) : 0;
 
 	// P4 — the layout preset is global (one panel for the whole timeline) but the camera
 	// is per clip, so the layout has to be resolved against the clip under the playhead.
@@ -378,6 +380,7 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 		onVideoElement: relayIsPlaying,
 		onLoadedMetadata: relayLoadedMetadata,
 		cropRegion,
+		rotation,
 	};
 
 	const handleWebcamPointerDown = (event: ReactPointerEvent<HTMLDivElement>) => {
diff --git a/src/components/ai-edition/VirtualPreview.rotation.test.tsx b/src/components/ai-edition/VirtualPreview.rotation.test.tsx
new file mode 100644
index 000000000..7a0a38e1d
--- /dev/null
+++ b/src/components/ai-edition/VirtualPreview.rotation.test.tsx
@@ -0,0 +1,66 @@
+// @vitest-environment jsdom
+import { cleanup, render } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { CropRegion } from "@/components/video-editor/types";
+import type { ClipRotation } from "@/lib/ai-edition/clipRotation";
+import { VirtualPreview } from "./VirtualPreview";
+
+beforeEach(() => {
+	// No playback here: the frames are never run.
+	vi.stubGlobal("requestAnimationFrame", () => 0);
+	vi.stubGlobal("cancelAnimationFrame", () => undefined);
+});
+
+afterEach(() => {
+	cleanup();
+	vi.unstubAllGlobals();
+});
+
+function videoStyle(cropRegion: CropRegion | null, rotation?: ClipRotation) {
+	const view = render(
+		<VirtualPreview
+			videoSources={[{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" }]}
+			clips={[
+				{
+					id: "clip_1",
+					assetId: "a1",
+					sourceStartSec: 0,
+					sourceEndSec: 10,
+					timelineStartSec: 0,
+					timelineEndSec: 10,
+					wordRefs: [],
+					origin: "user",
+					reason: "",
+				},
+			]}
+			onTimeChange={vi.fn()}
+			cropRegion={cropRegion}
+			rotation={rotation}
+		/>,
+	);
+	const video = view.container.querySelector("video");
+	if (!video) throw new Error("no <video> rendered");
+	return video.style;
+}
+
+describe("VirtualPreview rotation", () => {
+	const CROP = { x: 0.125, y: 0.25, width: 0.5, height: 0.25 };
+
+	it("positions an upright clip by its crop, unturned", () => {
+		const style = videoStyle(CROP);
+		expect([style.left, style.top, style.transform]).toEqual(["-25%", "-100%", ""]);
+	});
+
+	it("positions a turned clip by the mirrored crop and turns it", () => {
+		// Mirrored crop: x 0.375, y 0.5. Turned about its centre, the element then shows the
+		// stored crop.
+		const style = videoStyle(CROP, 180);
+		expect([style.width, style.height]).toEqual(["200%", "400%"]);
+		expect([style.left, style.top, style.transform]).toEqual(["-75%", "-200%", "rotate(180deg)"]);
+	});
+
+	it("only turns an uncropped clip", () => {
+		const style = videoStyle(null, 180);
+		expect([style.position, style.left, style.transform]).toEqual(["", "", "rotate(180deg)"]);
+	});
+});
diff --git a/src/components/ai-edition/VirtualPreview.tsx b/src/components/ai-edition/VirtualPreview.tsx
index 4e4ec9e55..cd857186f 100644
--- a/src/components/ai-edition/VirtualPreview.tsx
+++ b/src/components/ai-edition/VirtualPreview.tsx
@@ -10,6 +10,7 @@ import {
 	resetClickPlayhead,
 	takeCrossedClickHits,
 } from "@/lib/ai-edition/clickSound";
+import { type ClipRotation, turnCropRegion } from "@/lib/ai-edition/clipRotation";
 import {
 	collapseTracksToPills,
 	resolveFadeSecs,
@@ -482,6 +483,8 @@ interface VirtualPreviewProps {
 	 * identity ({x:0,y:0,width:1,height:1}) renders the full frame, unchanged
 	 * from before crop support existed. */
 	cropRegion?: CropRegion | null;
+	/** The active clip's rotation; 180 turns the picture, `cropRegion` staying in source coordinates. */
+	rotation?: ClipRotation;
 }
 
 export function VirtualPreview({
@@ -501,6 +504,7 @@ export function VirtualPreview({
 	onVideoRecovered,
 	retryToken,
 	cropRegion,
+	rotation = 0,
 }: VirtualPreviewProps) {
 	const { settings } = useEditorSettings();
 	// ponytail: an oversized, offset video inside .videoFrame's overflow:hidden
@@ -511,17 +515,22 @@ export function VirtualPreview({
 	// PreviewCanvas's screenSize) box, so this stays correct at any size
 	// without measuring pixels. Identity crop reduces to 100%/100%/0/0 — the
 	// exact same box the video rendered in before crop support existed.
-	const region = cropRegion ?? DEFAULT_CROP_REGION;
+	// A turned clip: the element is turned about its own centre, so positioning it by the
+	// mirrored crop puts exactly the stored crop inside the frame.
+	const storedRegion = cropRegion ?? DEFAULT_CROP_REGION;
+	const region = rotation === 180 ? turnCropRegion(storedRegion) : storedRegion;
+	const turnStyle: React.CSSProperties = rotation === 180 ? { transform: "rotate(180deg)" } : {};
 	const isIdentityCrop =
 		region.x === 0 && region.y === 0 && region.width === 1 && region.height === 1;
 	const cropVideoStyle: React.CSSProperties = isIdentityCrop
-		? {}
+		? turnStyle
 		: {
 				position: "absolute",
 				width: `${100 / region.width}%`,
 				height: `${100 / region.height}%`,
 				left: `${(-region.x * 100) / region.width}%`,
 				top: `${(-region.y * 100) / region.height}%`,
+				...turnStyle,
 			};
 	const videoRef = useRef<HTMLVideoElement | null>(null);
 	const primaryAudioRef = useRef<HTMLAudioElement | null>(null);
diff --git a/src/i18n/__tests__/tooltipCopy.test.ts b/src/i18n/__tests__/tooltipCopy.test.ts
index 4b503cf50..ec5882018 100644
--- a/src/i18n/__tests__/tooltipCopy.test.ts
+++ b/src/i18n/__tests__/tooltipCopy.test.ts
@@ -98,7 +98,7 @@ const LONG_TAIL_KEYS: Record<string, string[]> = {
 		"transcript.correctedWord",
 	],
 	launch: ["tooltips.notesToolbar.mirrorTip"],
-	editor: ["preview.webcamPreview"],
+	editor: ["preview.webcamPreview", "editClipDialog.rotationTip"],
 };
 const longTailEntries = Object.entries(LONG_TAIL_KEYS).flatMap(([namespace, keys]) =>
 	keys.map((key) => [namespace, key] as const),
diff --git a/src/i18n/locales/ar/editor.json b/src/i18n/locales/ar/editor.json
index d85724650..c032e0aee 100644
--- a/src/i18n/locales/ar/editor.json
+++ b/src/i18n/locales/ar/editor.json
@@ -335,6 +335,10 @@
 		"duration": "المدة النهائية",
 		"reset": "إعادة التعيين",
 		"apply": "تطبيق",
+		"rotation": "التدوير",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "اقلب الصورة رأسًا على عقب، مثلًا لكاميرا مثبتة بشكل مقلوب",
 		"pickClipTitle": "اختر مقطعًا لتعديله",
 		"clipLabel": "المقطع {{index}}"
 	},
diff --git a/src/i18n/locales/cs/editor.json b/src/i18n/locales/cs/editor.json
index 8424b0985..641c12260 100644
--- a/src/i18n/locales/cs/editor.json
+++ b/src/i18n/locales/cs/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Výsledná délka",
 		"reset": "Obnovit",
 		"apply": "Použít",
+		"rotation": "Otočení",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Otočit obraz vzhůru nohama, např. u kamery namontované obráceně",
 		"pickClipTitle": "Vyberte klip k úpravě",
 		"clipLabel": "Klip {{index}}"
 	},
diff --git a/src/i18n/locales/de/editor.json b/src/i18n/locales/de/editor.json
index 24d35321d..a1d71e39f 100644
--- a/src/i18n/locales/de/editor.json
+++ b/src/i18n/locales/de/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Endgültige Dauer",
 		"reset": "Zurücksetzen",
 		"apply": "Anwenden",
+		"rotation": "Drehung",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Bild auf den Kopf stellen, z. B. für eine über Kopf montierte Kamera",
 		"pickClipTitle": "Wähle einen Clip zum Bearbeiten",
 		"clipLabel": "Clip {{index}}"
 	},
diff --git a/src/i18n/locales/en/editor.json b/src/i18n/locales/en/editor.json
index 44e256d2e..78a9c128b 100644
--- a/src/i18n/locales/en/editor.json
+++ b/src/i18n/locales/en/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Final duration",
 		"reset": "Reset",
 		"apply": "Apply",
+		"rotation": "Rotation",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Turn the picture upside down, e.g. for a camera mounted overhead",
 		"pickClipTitle": "Choose a clip to edit",
 		"clipLabel": "Clip {{index}}"
 	},
diff --git a/src/i18n/locales/es/editor.json b/src/i18n/locales/es/editor.json
index dd3ea0821..d1a6fe5f1 100644
--- a/src/i18n/locales/es/editor.json
+++ b/src/i18n/locales/es/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Duración final",
 		"reset": "Restablecer",
 		"apply": "Aplicar",
+		"rotation": "Rotación",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Poner la imagen del revés, p. ej. para una cámara montada al revés",
 		"pickClipTitle": "Elige un clip para editar",
 		"clipLabel": "Clip {{index}}"
 	},
diff --git a/src/i18n/locales/fr/editor.json b/src/i18n/locales/fr/editor.json
index 7344c6c40..455a50df7 100644
--- a/src/i18n/locales/fr/editor.json
+++ b/src/i18n/locales/fr/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Durée finale",
 		"reset": "Réinitialiser",
 		"apply": "Appliquer",
+		"rotation": "Rotation",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Retourner l'image, par ex. pour une caméra montée à l'envers",
 		"pickClipTitle": "Choisissez un clip à modifier",
 		"clipLabel": "Clip {{index}}"
 	},
diff --git a/src/i18n/locales/it/editor.json b/src/i18n/locales/it/editor.json
index e648dc9aa..4309e1776 100644
--- a/src/i18n/locales/it/editor.json
+++ b/src/i18n/locales/it/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Durata finale",
 		"reset": "Reimposta",
 		"apply": "Applica",
+		"rotation": "Rotazione",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Capovolgi l'immagine, ad es. per una videocamera montata al contrario",
 		"pickClipTitle": "Scegli una clip da modificare",
 		"clipLabel": "Clip {{index}}"
 	},
diff --git a/src/i18n/locales/ja-JP/editor.json b/src/i18n/locales/ja-JP/editor.json
index e55e90cec..cad39a066 100644
--- a/src/i18n/locales/ja-JP/editor.json
+++ b/src/i18n/locales/ja-JP/editor.json
@@ -335,6 +335,10 @@
 		"duration": "最終の長さ",
 		"reset": "リセット",
 		"apply": "適用",
+		"rotation": "回転",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "映像を上下逆さまにします（逆さに取り付けたカメラなど）",
 		"pickClipTitle": "編集するクリップを選択",
 		"clipLabel": "クリップ {{index}}"
 	},
diff --git a/src/i18n/locales/ko-KR/editor.json b/src/i18n/locales/ko-KR/editor.json
index 7865a0e7b..7e43af4cc 100644
--- a/src/i18n/locales/ko-KR/editor.json
+++ b/src/i18n/locales/ko-KR/editor.json
@@ -335,6 +335,10 @@
 		"duration": "최종 길이",
 		"reset": "재설정",
 		"apply": "적용",
+		"rotation": "회전",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "화면을 거꾸로 뒤집습니다(예: 거꾸로 장착한 카메라)",
 		"pickClipTitle": "편집할 클립 선택",
 		"clipLabel": "클립 {{index}}"
 	},
diff --git a/src/i18n/locales/pt-BR/editor.json b/src/i18n/locales/pt-BR/editor.json
index 3724a1aa3..a262858ec 100644
--- a/src/i18n/locales/pt-BR/editor.json
+++ b/src/i18n/locales/pt-BR/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Duração final",
 		"reset": "Redefinir",
 		"apply": "Aplicar",
+		"rotation": "Rotação",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Virar a imagem de cabeça para baixo, ex.: para uma câmera montada invertida",
 		"pickClipTitle": "Escolha um clipe para editar",
 		"clipLabel": "Clipe {{index}}"
 	},
diff --git a/src/i18n/locales/ru/editor.json b/src/i18n/locales/ru/editor.json
index 6fac2c415..df88d1d8a 100644
--- a/src/i18n/locales/ru/editor.json
+++ b/src/i18n/locales/ru/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Итоговая длительность",
 		"reset": "Сбросить",
 		"apply": "Применить",
+		"rotation": "Поворот",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Перевернуть изображение, например для камеры, закреплённой вверх ногами",
 		"pickClipTitle": "Выберите клип для редактирования",
 		"clipLabel": "Клип {{index}}"
 	},
diff --git a/src/i18n/locales/tr/editor.json b/src/i18n/locales/tr/editor.json
index 74e5db229..feb41196f 100644
--- a/src/i18n/locales/tr/editor.json
+++ b/src/i18n/locales/tr/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Son süre",
 		"reset": "Sıfırla",
 		"apply": "Uygula",
+		"rotation": "Döndürme",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Görüntüyü baş aşağı çevir, ör. ters monte edilmiş bir kamera için",
 		"pickClipTitle": "Düzenlenecek klibi seçin",
 		"clipLabel": "Klip {{index}}"
 	},
diff --git a/src/i18n/locales/vi/editor.json b/src/i18n/locales/vi/editor.json
index 340886e6f..4c87ce014 100644
--- a/src/i18n/locales/vi/editor.json
+++ b/src/i18n/locales/vi/editor.json
@@ -335,6 +335,10 @@
 		"duration": "Thời lượng cuối",
 		"reset": "Đặt lại",
 		"apply": "Áp dụng",
+		"rotation": "Xoay",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "Lật ngược hình ảnh, ví dụ cho camera gắn ngược",
 		"pickClipTitle": "Chọn clip để chỉnh sửa",
 		"clipLabel": "Clip {{index}}"
 	},
diff --git a/src/i18n/locales/zh-CN/editor.json b/src/i18n/locales/zh-CN/editor.json
index 9e7be62fd..edbbd88e2 100644
--- a/src/i18n/locales/zh-CN/editor.json
+++ b/src/i18n/locales/zh-CN/editor.json
@@ -335,6 +335,10 @@
 		"duration": "最终时长",
 		"reset": "重置",
 		"apply": "应用",
+		"rotation": "旋转",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "将画面上下颠倒，例如用于倒装的摄像头",
 		"pickClipTitle": "选择要编辑的片段",
 		"clipLabel": "片段 {{index}}"
 	},
diff --git a/src/i18n/locales/zh-TW/editor.json b/src/i18n/locales/zh-TW/editor.json
index e9c482d04..28a3744e4 100644
--- a/src/i18n/locales/zh-TW/editor.json
+++ b/src/i18n/locales/zh-TW/editor.json
@@ -335,6 +335,10 @@
 		"duration": "最終時長",
 		"reset": "重設",
 		"apply": "套用",
+		"rotation": "旋轉",
+		"rotationUpright": "0°",
+		"rotationTurned": "180°",
+		"rotationTip": "將畫面上下顛倒，例如用於倒裝的攝影機",
 		"pickClipTitle": "選擇要編輯的片段",
 		"clipLabel": "片段 {{index}}"
 	},
diff --git a/src/lib/ai-edition/clipRotation.test.ts b/src/lib/ai-edition/clipRotation.test.ts
new file mode 100644
index 000000000..06f5e1d4a
--- /dev/null
+++ b/src/lib/ai-edition/clipRotation.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { clipRotation, turnCropRegion } from "./clipRotation";
+
+describe("clipRotation", () => {
+	it("reads an absent field as 0", () => {
+		expect(clipRotation({})).toBe(0);
+		expect(clipRotation({ rotation: 180 })).toBe(180);
+	});
+});
+
+describe("turnCropRegion", () => {
+	it("mirrors the rectangle inside the frame", () => {
+		expect(turnCropRegion({ x: 0.1, y: 0.2, width: 0.5, height: 0.3 })).toEqual({
+			x: 0.4,
+			y: 0.5,
+			width: 0.5,
+			height: 0.3,
+		});
+	});
+	it("never yields a negative x/y for a rectangle flush against the far edge", () => {
+		// 1 - 0.9 - 0.1 is -2.8e-17 in floating point; a crop below 0 fails the schema.
+		const turned = turnCropRegion({ x: 0.9, y: 0.9, width: 0.1, height: 0.1 });
+		expect(turned.x).toBe(0);
+		expect(turned.y).toBe(0);
+	});
+	it("is its own inverse", () => {
+		const r = { x: 0.13, y: 0.07, width: 0.61, height: 0.42 };
+		const back = turnCropRegion(turnCropRegion(r));
+		expect(back.x).toBeCloseTo(r.x, 12);
+		expect(back.y).toBeCloseTo(r.y, 12);
+	});
+});
diff --git a/src/lib/ai-edition/clipRotation.ts b/src/lib/ai-edition/clipRotation.ts
new file mode 100644
index 000000000..ff6274961
--- /dev/null
+++ b/src/lib/ai-edition/clipRotation.ts
@@ -0,0 +1,16 @@
+// A clip's main picture can be turned by 180° (a desk camera mounted upside down, an
+// imported video filmed the wrong way up). Absent means upright; 0 is never stored.
+export type ClipRotation = 0 | 180;
+
+export function clipRotation(clip: { rotation?: 180 }): ClipRotation {
+	return clip.rotation === 180 ? 180 : 0;
+}
+
+// The same rectangle seen on the turned picture. Crops are stored in source coordinates;
+// anything that shows or edits them on the turned picture goes through this, both ways.
+// Clamped at 0: a rectangle flush against the far edge would otherwise turn to -2.8e-17.
+export function turnCropRegion<T extends { x: number; y: number; width: number; height: number }>(
+	r: T,
+): T {
+	return { ...r, x: Math.max(0, 1 - r.x - r.width), y: Math.max(0, 1 - r.y - r.height) };
+}
diff --git a/src/lib/ai-edition/document/timeline.test.ts b/src/lib/ai-edition/document/timeline.test.ts
index a33f1c6e7..50ebc3914 100644
--- a/src/lib/ai-edition/document/timeline.test.ts
+++ b/src/lib/ai-edition/document/timeline.test.ts
@@ -1914,6 +1914,24 @@ describe("removeRegion — the one shared region-delete mutator", () => {
 	});
 });
 
+describe("withClipsChanged — rotation", () => {
+	it("does not join two media-contiguous clips that differ in rotation", () => {
+		const left = makeClip({ id: "clip_l", sourceStartSec: 0, sourceEndSec: 5 });
+		const right = makeClip({
+			id: "clip_r",
+			sourceStartSec: 5,
+			sourceEndSec: 10,
+			timelineStartSec: 5,
+			timelineEndSec: 10,
+		});
+		const doc = makeDoc();
+		const next = withClipsChanged(doc, [left, { ...right, rotation: 180 }]);
+		expect(next.timeline.clips).toHaveLength(2);
+		// Control: without the rotation they DO join.
+		expect(withClipsChanged(doc, [left, right]).timeline.clips).toHaveLength(1);
+	});
+});
+
 describe("removeClip — delete a clip, close the gap, drop its pills", () => {
 	const doc = () =>
 		makeDoc({
diff --git a/src/lib/ai-edition/document/timeline.ts b/src/lib/ai-edition/document/timeline.ts
index ba256fd3b..0170364c8 100644
--- a/src/lib/ai-edition/document/timeline.ts
+++ b/src/lib/ai-edition/document/timeline.ts
@@ -1231,8 +1231,8 @@ export function withClipsChanged(document: AxcutDocument, clips: AxcutClip[]): A
 	return laid.length === 0 ? next : rederiveRegionMs(next, laid);
 }
 
-/** Fold every run of same-media, same-crop, media-contiguous clips into one, reporting the
- *  ids that went away and the clip that now carries their content. */
+/** Fold every run of same-media, same-crop-and-rotation, media-contiguous clips into one,
+ *  reporting the ids that went away and the clip that now carries their content. */
 function joinContiguous(clips: AxcutClip[]): {
 	clips: AxcutClip[];
 	absorbed: Map<string, string>;
@@ -1259,15 +1259,16 @@ function joinContiguous(clips: AxcutClip[]): {
 	return { clips: out, absorbed };
 }
 
-/** Same media, media timecodes that meet, same framing. Crop is the only property a clip
- *  carries that two otherwise-identical neighbours could legitimately disagree on, so it is
- *  the whole of the guard. */
+/** Same media, media timecodes that meet, same framing. Crop and rotation are the only
+ *  properties a clip carries that two otherwise-identical neighbours could legitimately
+ *  disagree on, so they are the whole of the guard. */
 function joinable(left: AxcutClip, right: AxcutClip): boolean {
 	return (
 		left.assetId === right.assetId &&
 		left.sourceEndSec !== undefined &&
 		Math.abs(left.sourceEndSec - right.sourceStartSec) < 1e-6 &&
-		JSON.stringify(left.cropRegion ?? null) === JSON.stringify(right.cropRegion ?? null)
+		JSON.stringify(left.cropRegion ?? null) === JSON.stringify(right.cropRegion ?? null) &&
+		(left.rotation ?? 0) === (right.rotation ?? 0)
 	);
 }
 
diff --git a/src/lib/ai-edition/schema/index.test.ts b/src/lib/ai-edition/schema/index.test.ts
index 38aabd870..88764a1ba 100644
--- a/src/lib/ai-edition/schema/index.test.ts
+++ b/src/lib/ai-edition/schema/index.test.ts
@@ -360,6 +360,21 @@ describe("axcut-schema v8", () => {
 			).toThrow();
 		});
 
+		it("clipSchema accepts rotation 180 and an absent rotation, rejects 90", () => {
+			const base = {
+				id: "c1",
+				assetId: "a1",
+				sourceStartSec: 0,
+				sourceEndSec: 5,
+				timelineStartSec: 0,
+				timelineEndSec: 5,
+				origin: "user" as const,
+			};
+			expect(clipSchema.safeParse({ ...base, rotation: 180 }).success).toBe(true);
+			expect(clipSchema.safeParse(base).success).toBe(true);
+			expect(clipSchema.safeParse({ ...base, rotation: 90 }).success).toBe(false);
+		});
+
 		it("clipSchema rejects timelineEndSec < timelineStartSec or sourceEndSec < sourceStartSec", () => {
 			const validBase = {
 				id: "c1",
diff --git a/src/lib/ai-edition/schema/index.ts b/src/lib/ai-edition/schema/index.ts
index 4d8caf600..22297b167 100644
--- a/src/lib/ai-edition/schema/index.ts
+++ b/src/lib/ai-edition/schema/index.ts
@@ -224,6 +224,9 @@ export const clipSchema = z
 		// that as the identity region {x:0,y:0,width:1,height:1} rather than
 		// storing the identity explicitly, so untouched clips stay lean.
 		cropRegion: clipCropRegionSchema.optional(),
+		// Absent means upright. Only a half turn exists; 0 is never stored, so untouched
+		// clips stay lean (same rule as cropRegion).
+		rotation: z.literal(180).optional(),
 	})
 	.refine((data) => data.timelineEndSec >= data.timelineStartSec, {
 		message: "timelineEndSec must be greater than or equal to timelineStartSec",
diff --git a/src/lib/ai-edition/store/useTimeline.test.ts b/src/lib/ai-edition/store/useTimeline.test.ts
index 917188529..ea9dca0c1 100644
--- a/src/lib/ai-edition/store/useTimeline.test.ts
+++ b/src/lib/ai-edition/store/useTimeline.test.ts
@@ -612,6 +612,199 @@ describe("useTimeline.applyClipEdit (Edit-clip modal)", () => {
 		});
 		expect(useProjectStore.getState().document?.timeline.clips[0].cropRegion).toBeUndefined();
 	});
+
+	it("sets, keeps and removes the rotation in one save each", async () => {
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 6, undefined, 180);
+		});
+		expect(useProjectStore.getState().document?.timeline.clips[0].rotation).toBe(180);
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 6);
+		});
+		expect(useProjectStore.getState().document?.timeline.clips[0].rotation).toBe(180);
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 6, undefined, 0);
+		});
+		expect(useProjectStore.getState().document?.timeline.clips[0]).not.toHaveProperty("rotation");
+	});
+
+	// A stored zoom focus is where the viewer sees it: turning the clip moves that content to
+	// the mirrored point, so the clip's own zooms must follow it.
+	it("mirrors the focus of the turned clip's zooms in the same save, and only those", async () => {
+		// Not contiguous in the source with clip_a, or the two would merge into one clip.
+		const clipB = {
+			...sampleDoc.timeline.clips[0],
+			id: "clip_b",
+			sourceStartSec: 15,
+			sourceEndSec: 25,
+			timelineStartSec: 10,
+			timelineEndSec: 20,
+		};
+		const zoomA = { ...anchoredZoom("z_a", 2, 3), focus: { cx: 0.2, cy: 0.75 } };
+		const zoomB = {
+			...anchoredZoom("z_b", 17, 18),
+			startMs: 12000,
+			endMs: 13000,
+			clipId: "clip_b",
+			focus: { cx: 0.2, cy: 0.75 },
+		};
+		useProjectStore.setState({
+			document: {
+				...sampleDoc,
+				timeline: { ...sampleDoc.timeline, clips: [sampleDoc.timeline.clips[0], clipB] },
+				zoomRanges: [zoomA, zoomB],
+			},
+		});
+		const focusOf = (id: string) =>
+			useProjectStore.getState().document?.zoomRanges.find((z) => z.id === id)?.focus;
+		const { result } = renderTimeline();
+
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 180);
+		});
+		expect(focusOf("z_a")?.cx).toBeCloseTo(0.8, 9);
+		expect(focusOf("z_a")?.cy).toBeCloseTo(0.25, 9);
+		expect(focusOf("z_b")).toEqual({ cx: 0.2, cy: 0.75 });
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+
+		// Unchanged rotation: no mirroring.
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 180);
+		});
+		expect(focusOf("z_a")?.cx).toBeCloseTo(0.8, 9);
+
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 0);
+		});
+		expect(focusOf("z_a")?.cx).toBeCloseTo(0.2, 9);
+		expect(focusOf("z_a")?.cy).toBeCloseTo(0.75, 9);
+		expect(focusOf("z_b")).toEqual({ cx: 0.2, cy: 0.75 });
+	});
+
+	// A footage-space privacy blur must stay on what it hides: turning the clip moves that
+	// content to the mirrored box. Frame-space annotations and other types do not turn.
+	it("mirrors the turned clip's footage-space blurs in the same save, and only those", async () => {
+		const clipB = {
+			...sampleDoc.timeline.clips[0],
+			id: "clip_b",
+			sourceStartSec: 15,
+			sourceEndSec: 25,
+			timelineStartSec: 10,
+			timelineEndSec: 20,
+		};
+		const annotation = (
+			id: string,
+			clipId: string,
+			type: "blur" | "text",
+			space?: "frame",
+		): AxcutDocument["annotations"][number] => ({
+			id,
+			startMs: clipId === "clip_a" ? 2000 : 12000,
+			endMs: clipId === "clip_a" ? 3000 : 13000,
+			clipId,
+			sourceStartSec: clipId === "clip_a" ? 2 : 17,
+			sourceEndSec: clipId === "clip_a" ? 3 : 18,
+			type,
+			content: "",
+			...(space ? { space } : {}),
+			position: { x: 10, y: 20 },
+			size: { width: 30, height: 15 },
+			style: {
+				color: "#ffffff",
+				backgroundColor: "transparent",
+				fontSize: 32,
+				fontFamily: "Inter",
+				fontWeight: "bold",
+				fontStyle: "normal",
+				textDecoration: "none",
+				textAlign: "center",
+				textAnimation: "none",
+			},
+			zIndex: 1,
+		});
+		useProjectStore.setState({
+			document: {
+				...sampleDoc,
+				timeline: { ...sampleDoc.timeline, clips: [sampleDoc.timeline.clips[0], clipB] },
+				zoomRanges: [],
+				annotations: [
+					annotation("blur_a", "clip_a", "blur"),
+					annotation("blur_frame", "clip_a", "blur", "frame"),
+					annotation("text_a", "clip_a", "text"),
+					annotation("blur_b", "clip_b", "blur"),
+				],
+			},
+		});
+		const boxOf = (id: string) => {
+			const a = useProjectStore.getState().document?.annotations.find((r) => r.id === id);
+			return { position: a?.position, size: a?.size };
+		};
+		const untouched = { position: { x: 10, y: 20 }, size: { width: 30, height: 15 } };
+		const { result } = renderTimeline();
+
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 180);
+		});
+		expect(boxOf("blur_a").position?.x).toBeCloseTo(60, 9);
+		expect(boxOf("blur_a").position?.y).toBeCloseTo(65, 9);
+		expect(boxOf("blur_a").size).toEqual({ width: 30, height: 15 });
+		expect(boxOf("blur_frame")).toEqual(untouched);
+		expect(boxOf("text_a")).toEqual(untouched);
+		expect(boxOf("blur_b")).toEqual(untouched);
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+
+		// Unchanged rotation: no mirroring.
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 180);
+		});
+		expect(boxOf("blur_a").position?.x).toBeCloseTo(60, 9);
+
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 0);
+		});
+		expect(boxOf("blur_a").position?.x).toBeCloseTo(10, 9);
+		expect(boxOf("blur_a").position?.y).toBeCloseTo(20, 9);
+		expect(boxOf("blur_b")).toEqual(untouched);
+	});
+
+	it("keeps a blur flush against the far edge at 0 when the clip turns", async () => {
+		// 100 - 89.9 - 10.1 is -5.3e-15 in floating point; a blur below 0 fails the schema.
+		const doc = useProjectStore.getState().document as AxcutDocument;
+		const blur: AxcutDocument["annotations"][number] = {
+			id: "blur_edge",
+			startMs: 2000,
+			endMs: 3000,
+			clipId: "clip_a",
+			sourceStartSec: 2,
+			sourceEndSec: 3,
+			type: "blur",
+			content: "",
+			position: { x: 89.9, y: 89.9 },
+			size: { width: 10.1, height: 10.1 },
+			style: {
+				color: "#ffffff",
+				backgroundColor: "transparent",
+				fontSize: 32,
+				fontFamily: "Inter",
+				fontWeight: "bold",
+				fontStyle: "normal",
+				textDecoration: "none",
+				textAlign: "center",
+				textAnimation: "none",
+			},
+			zIndex: 1,
+		};
+		useProjectStore.setState({ document: { ...doc, annotations: [blur] } });
+		const { result } = renderTimeline();
+
+		await act(async () => {
+			await result.current.applyClipEdit("clip_a", 0, 10, undefined, 180);
+		});
+		const saved = useProjectStore.getState().document?.annotations[0];
+		expect(saved?.position).toEqual({ x: 0, y: 0 });
+	});
 });
 
 // #353. The toolbar button and the `C` shortcut both used to write a region on a
diff --git a/src/lib/ai-edition/store/useTimeline.ts b/src/lib/ai-edition/store/useTimeline.ts
index b8a867f77..e9007bbc1 100644
--- a/src/lib/ai-edition/store/useTimeline.ts
+++ b/src/lib/ai-edition/store/useTimeline.ts
@@ -14,6 +14,7 @@ import type {
 import { useScopedT } from "@/contexts/I18nContext";
 import { DEFAULT_TEXT_PLATE } from "../annotations/background";
 import { fitTextBox } from "../annotations/placement";
+import { type ClipRotation, clipRotation } from "../clipRotation";
 import {
 	collapseTracksToPills,
 	patchAudioTrack,
@@ -1210,6 +1211,9 @@ export function useTimeline() {
 	// section was never touched (leave the stored value alone); `null` clears it back to
 	// "no crop" (full frame) rather than storing the identity region explicitly.
 	//
+	// Rotation follows the same rule: `undefined` leaves the stored value, `0` removes the
+	// field, `180` sets it.
+	//
 	// The document is read from the store, not off the render closure, so this composes
 	// with `useSequentialTimelineOps`: queued behind another timeline write, it still sees
 	// what that write committed. Same reason as `setTrimEntries` / `insertClipAt`.
@@ -1219,11 +1223,12 @@ export function useTimeline() {
 			sourceStartSec: number,
 			sourceEndSec: number,
 			cropRegion?: AxcutClipCropRegion | null,
+			rotation?: ClipRotation,
 		) => {
 			const doc = useProjectStore.getState().document;
 			if (!doc) return;
 			const ranged = setClipSourceRange(doc, clipId, sourceStartSec, sourceEndSec);
-			const next: AxcutDocument =
+			const cropped: AxcutDocument =
 				cropRegion === undefined
 					? ranged
 					: {
@@ -1235,6 +1240,47 @@ export function useTimeline() {
 								),
 							},
 						};
+			const current = doc.timeline.clips.find((c) => c.id === clipId);
+			const turning = rotation !== undefined && !!current && clipRotation(current) !== rotation;
+			const next: AxcutDocument =
+				rotation === undefined
+					? cropped
+					: {
+							...cropped,
+							timeline: {
+								...cropped.timeline,
+								clips: cropped.timeline.clips.map((c) => {
+									if (c.id !== clipId) return c;
+									const { rotation: _old, ...rest } = c;
+									return rotation === 180 ? { ...rest, rotation: 180 as const } : rest;
+								}),
+							},
+							// A stored zoom focus is where the viewer sees it; turning the clip moves that
+							// content to the mirrored point, so the clip's own zooms follow it.
+							zoomRanges: turning
+								? cropped.zoomRanges.map((z) =>
+										z.clipId === clipId
+											? { ...z, focus: { ...z.focus, cx: 1 - z.focus.cx, cy: 1 - z.focus.cy } }
+											: z,
+									)
+								: cropped.zoomRanges,
+							// A footage-space privacy blur must stay on what it hides, so it moves with
+							// that content. Frame-space annotations, text and figures do not turn. Clamped
+							// at 0 like `turnCropRegion`: a box flush against the far edge would turn to -5e-15.
+							annotations: turning
+								? cropped.annotations.map((a) =>
+										a.clipId === clipId && a.type === "blur" && a.space !== "frame"
+											? {
+													...a,
+													position: {
+														x: Math.max(0, 100 - a.position.x - a.size.width),
+														y: Math.max(0, 100 - a.position.y - a.size.height),
+													},
+												}
+											: a,
+									)
+								: cropped.annotations,
+						};
 			await saveDocument(next, { history: true });
 		},
 		[saveDocument],
diff --git a/src/lib/ai-edition/timeline/apply-auto-zooms.test.ts b/src/lib/ai-edition/timeline/apply-auto-zooms.test.ts
index 32de4396b..7e382de10 100644
--- a/src/lib/ai-edition/timeline/apply-auto-zooms.test.ts
+++ b/src/lib/ai-edition/timeline/apply-auto-zooms.test.ts
@@ -145,6 +145,25 @@ describe("appendAutoZoomSuggestions", () => {
 			clipId: "clip_1",
 		});
 	});
+
+	it.each([
+		["an upright clip keeps", undefined, { cx: 0.4, cy: 0.7 }],
+		["a turned clip mirrors", 180 as const, { cx: 0.6, cy: 0.3 }],
+	])("%s the cursor's focus", (_, rotation, focus) => {
+		const document = documentWithClip();
+		const turned: AxcutDocument = {
+			...document,
+			timeline: {
+				...document.timeline,
+				clips: document.timeline.clips.map((clip) => ({ ...clip, rotation })),
+			},
+		};
+		const next = appendAutoZoomSuggestions(turned, [
+			{ span: { start: 3000, end: 5000 }, focus: { cx: 0.4, cy: 0.7 }, depth: 2 },
+		]);
+		expect(next.zoomRanges[0].focus.cx).toBeCloseTo(focus.cx, 9);
+		expect(next.zoomRanges[0].focus.cy).toBeCloseTo(focus.cy, 9);
+	});
 });
 
 describe("collectAutoZoomSuggestionsForLatestDocument", () => {
diff --git a/src/lib/ai-edition/timeline/apply-auto-zooms.ts b/src/lib/ai-edition/timeline/apply-auto-zooms.ts
index bc9d02196..0b2be54ed 100644
--- a/src/lib/ai-edition/timeline/apply-auto-zooms.ts
+++ b/src/lib/ai-edition/timeline/apply-auto-zooms.ts
@@ -3,6 +3,7 @@
 // this file only collects per-asset telemetry and appends the resulting regions.
 
 import type { CursorTelemetryPoint } from "@/components/video-editor/types";
+import { clipRotation } from "../clipRotation";
 import { createId } from "../document/ids";
 import type { AxcutAsset, AxcutDocument } from "../schema";
 import { anchorRegionsWithDerivedMs } from "./timelineMap";
@@ -102,6 +103,7 @@ export function appendAutoZoomSuggestions(
 	makeId: (prefix: string) => string = createId,
 ): AxcutDocument {
 	if (suggestions.length === 0) return document;
+	const clipsById = new Map(document.timeline.clips.map((clip) => [clip.id, clip]));
 	const anchored = suggestions.flatMap((suggestion) =>
 		anchorRegionsWithDerivedMs(
 			[
@@ -116,7 +118,13 @@ export function appendAutoZoomSuggestions(
 			],
 			document.timeline.clips,
 			() => makeId("zoom"),
-		),
+		).map((region) => {
+			// The focus comes from cursor telemetry, in source coordinates; a stored focus is
+			// where the viewer sees it, which on a turned clip is the mirrored point.
+			const clip = "clipId" in region ? clipsById.get(region.clipId) : undefined;
+			if (!clip || clipRotation(clip) !== 180) return region;
+			return { ...region, focus: { cx: 1 - region.focus.cx, cy: 1 - region.focus.cy } };
+		}),
 	);
 	return {
 		...document,
diff --git a/src/native/sceneDescription.test.ts b/src/native/sceneDescription.test.ts
index 0d84461b5..82d6ccbba 100644
--- a/src/native/sceneDescription.test.ts
+++ b/src/native/sceneDescription.test.ts
@@ -2949,3 +2949,45 @@ describe("buildSceneDescription.audioTracks", () => {
 		expect(buildSceneDescription(doc).audioTracks).toEqual([]);
 	});
 });
+
+// --- rotationByClip ----------------------------------------------------------
+
+describe("buildSceneDescription.rotationByClip", () => {
+	it("emits rotationByClip parallel to cropByClip", () => {
+		const asset = makeAsset({ id: "a", originalPath: "/a.mp4" });
+		const upright = makeClip({
+			id: "c1",
+			assetId: "a",
+			sourceStartSec: 0,
+			sourceEndSec: 4,
+			timelineStartSec: 0,
+			timelineEndSec: 4,
+		});
+		const turned = makeClip({
+			id: "c2",
+			assetId: "a",
+			sourceStartSec: 4,
+			sourceEndSec: 8,
+			timelineStartSec: 4,
+			timelineEndSec: 8,
+			rotation: 180,
+		});
+		const scene = buildSceneDescription(makeDoc({ assets: [asset], clips: [upright, turned] }));
+		expect(scene.rotationByClip).toEqual([0, 180]);
+		expect(scene.rotationByClip).toHaveLength(scene.cropByClip.length);
+	});
+
+	it("emits all zeros when no clip is turned", () => {
+		const asset = makeAsset({ id: "a", originalPath: "/a.mp4" });
+		const clip = makeClip({
+			id: "c1",
+			assetId: "a",
+			sourceStartSec: 0,
+			sourceEndSec: 4,
+			timelineStartSec: 0,
+			timelineEndSec: 4,
+		});
+		const scene = buildSceneDescription(makeDoc({ assets: [asset], clips: [clip] }));
+		expect(scene.rotationByClip).toEqual([0]);
+	});
+});
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 5cf2a8e5d..b963c8ad9 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -31,6 +31,7 @@ import {
 	getCaptionTranslations,
 } from "@/lib/ai-edition/captions";
 import { clickSoundForDocument } from "@/lib/ai-edition/clickSound";
+import { clipRotation } from "@/lib/ai-edition/clipRotation";
 import { collapseTracksToPills, trackGroupId } from "@/lib/ai-edition/document/audioTracks";
 import { createId } from "@/lib/ai-edition/document/ids";
 import { isFormatFillActive, pickOutputDims } from "@/lib/ai-edition/document/outputFormat";
@@ -563,6 +564,11 @@ export interface SceneDescription {
 	 * `crop` field, which lost per-clip crops on multi-clip documents.
 	 */
 	cropByClip: Array<{ x: number; y: number; width: number; height: number } | null>;
+	/**
+	 * Half turn of each clip's main picture, same order as `clips`. 0 = upright. The
+	 * compositor turns the screen layer; crop, cursor and zoom stay in their own spaces.
+	 */
+	rotationByClip: Array<0 | 180>;
 	/** Output frame. `fps` null = use the first clip's source fps. */
 	output: { width: number; height: number; fps: number | null };
 	/** Webcam background effect. Omitted when the mode is "none". */
@@ -1004,6 +1010,7 @@ export function buildSceneDescription(
 			};
 		},
 	);
+	const rotationByClip = visibleClips.map((clip) => clipRotation(clip));
 
 	// Zoom + Full Camera + speed regions are authored in RAW virtual (timeline) ms
 	// in the document — the ruler where trims still occupy their space — but the
@@ -1470,6 +1477,7 @@ export function buildSceneDescription(
 				clipIndex: region.clipIndex,
 			})),
 		cropByClip,
+		rotationByClip,
 		output: { ...pickOutputDims(document, settings.aspectRatio), fps: null },
 		// Omitted rather than sent as `{mode:"none"}`: the Rust side defaults the field, and
 		// every project without a webcam effect would otherwise carry it for nothing.
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 521cd4359..9c7c000f9 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -858,3 +858,4 @@ On macOS 15.2+ it opens at launch, until it has been closed once, while one of i
 | 2026-10-03 | installed `v2.0.0-rc.15` (build run 37124242835, tag `ccd8b449`, NSIS sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.15` (`win32 x64 · nsis`, Electron 41.2.1, Chromium 146.0.7680.188, Node 24.14.1). `v2.0.0` was promoted from this candidate during the pass and differs from it only by the version bump (`eff86dcb`), so the results hold for the stable code | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Ryzen 5 7520U / Radeon iGPU, built-in USB2.0 HD UVC WebCam (best mode 1280×720@30), Microphone Array (AMD) | Partial — 6 defects | **Whole-file pass on Windows.** Real OS mouse and keyboard input throughout. Computer-use screenshots came back grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP, and every picture and sound claim below was measured on the file with ffprobe/ffmpeg. **Defects:** (1) #1004, HUD drag at 125 %: the HUD window grows about 1.5 px per drag step (1180×882 → 1232×935 over ~43 steps) and the bar jumps by half the growth on release; after a long drag down the bar sat partly under the taskbar (centre y 1042, work area ends at 1032). (2) #1005, *Edit clip*: Reset, Cancel and Apply sit inside the scrolling body. In a 1240×1000 window (794 css px tall) the card is clipped above Apply, and a click where Apply should be lands on the backdrop, closing the dialog and discarding the edit. It fits when the window is maximized. (3) #1006, the rail's "Choose a clip to edit" menu renders under the timeline toolbar: Clip 2 and Clip 3 are covered (`elementFromPoint` returns `_tlToolbar`) and clicks on them do nothing. (4) #1007, a clip duplicated with Ctrl+C / Ctrl+V does not carry its anchored zoom or Full Camera region: `duplicateClip` in `src/lib/ai-edition/document/timeline.ts` copies only `trimRanges`. (5) #1008, zoom repel across a clip boundary: a zoom dragged into a neighbour that ends at its clip's end jumps past it into the next clip, shrinking from 12.97 to 8.23 s and leaving a zero-length fragment on the first clip. Ctrl+Z restores it. (6) #1009, the wordmark menu does not close on a click on the bare top bar. The header is a `-webkit-app-region: drag` area, which never delivers the document `mousedown` that `AppMenu` listens for. It does close on the preview, on a top-bar button and on the wordmark. **Passed: HUD and capture.** One HUD, `[content-protection] OFF` logged; horizontal ↔ vertical layout; every tooltip, idle and recording, beside or above the bar and unclipped; language menu (15 locales); camera and microphone toggles in one click; device settings: three inputs, level meter, live camera preview, camera quality row (1080p persisted across a relaunch; hand-edited 720p and an absent key both read 4K). Hide bar, then the tray overflow icon brings the HUD back; Quit leaves 0 processes; a second launch exits 0. With no source the record tooltip reads "Choose a screen or window to record" and one click opens the picker, then starts. While recording: source button disabled, toggles `aria-disabled`, gear inert, tray tooltip "Recording: Tout l'écran". Pause freezes the timer and resume advances it; restart starts a new helper and deletes the first file; cancel deletes the file and opens no editor. Stop opens the editor with "Recording added to a new project". Screen H.264 High bt709 1920×1080; AAC 48 kHz; webcam 1280×720 ~30 fps at 8 Mbit/s, the camera's best mode, not upscaled, matching `webcamFormat`. Microphone-only, system-audio-only and all-off takes behave; window source 1270×668, non-black; an odd 1001×601 window gives an even 992×596 file; a context menu inside the window is recorded and cut at its edge. Without the flag the HUD and an open Notes window are absent from the take. Record mode: rows, live camera preview, microphone meter, device switch, source modal with badge, *Start recording* hands over to the HUD; auto-zoom on gives one merged zoom over three clicks, off gives none, and the setting persists; editable cursor off hides the auto-zoom row and the Cursor facet; *Hide desktop icons* shows a bare wallpaper and restores the icons after. **Passed: editor.** Rename, Saved dot, tabs, chat panel toggle, tooltips with key chips, dividers; play, pause, seek playing and paused, ±1 frame arrows, stop at end; ruler click and drag, navigator narrow and pan, labels without collision, playhead within 0.5 px; Ctrl+S toast with a stable top bar. Clips: media card drag and *Add to timeline*, reorder, Edit clip grips, 1:1 crop held through a corner drag, Free, Cancel, pencil, delete. Trim, zoom (levels, custom, out-of-range message, focus drag, 3D modes), speed (presets, custom, 16× cap message, playback at 16×), annotation (text, sizes, plates, palette, Typewriter, image, arrow, blur mosaic and smooth, oval, clamped, dragged into padding); Ctrl+D, Ctrl+Z, Ctrl+Shift+Z. Modifiers inside a trim fire on the parked frame. Copy and paste of zoom, annotation and trim with their toasts and properties; an empty copy is a no-op; deleting a clip removes its modifiers; Edit clip clamps them; a Full Camera region across a junction splits and merges as clips move. Imported music: fragments across a junction with `offsetMs`, −18 dB and 1 s fades, gain, *Reset audio*; voiceover lands at the playhead. Transcript: clip order, silences, monotonic word seeks, live cue, Backspace skip and restore, silence trim; captions in four styles and six anchors; French translation with a *Display* row, and deleting it leaves the words untouched; typing in the packaged gate does nothing; a double-click correction survives *Regenerate as English* (model reused); 101 languages, detected language on the card. Composition: colour, gradient and one-colour gradient, wallpaper, animations move during playback only (21–23 distinct frames in 3 s, None 1), blur, 9:16 with Whole and Follow cursor, Auto padding with even borders, shadows, four frame styles in both themes. Camera layout: four presets, mirror, square, size (default 40, max 60), roundness, positions; background Cutout, Blur with an intensity slider, Custom image and colour, and the custom-colour mask reaches a 720p export; webcam crop corner zoom (124 %) and frame move. Audio facet: +6.5 dB raises the export from −17.2 to −12.7 LUFS with the peak held at −1.3 dBFS; reset returns 0 dB. Cursor facet: hide, style, size (to 5.8 of 6) and 3D cursor all show in the preview. Depth of field appears once a zoom has a 3D preset and changes the preview. Wordmark menu: rows as listed, About row version, arrows wrap both ways; Keyboard Shortcuts as one dialog: Z → Q changes the lane hint, Q adds a zoom, Z does nothing, reset restores Z; Ctrl+O; AI settings as one dialog; light and dark themes, dialogs included; French UI with one-line menu rows (#969), back to English; About lists the versions and channel, and Copy puts the same block on the clipboard; the HUD panel's version row and Check for Updates ("Checking…", disabled, the same dialog as the menu, re-enabled after). AI chat (deepseek): "add one zoom at 2x from 5 s to 8 s" lands as 5–8 s at 2.20× with the reason given, is undone by one Ctrl+Z and redone. Closing the editor quits the app and writes `editor-window.json` (`maximized: false`); after a relaunch the last project's settings and the main project's two clips, crop, regions, music, voiceover and captions are as left, and a paste before any copy changes nothing. A schema-4 project from July opens, migrates to schema 8, and keeps its clip, seven zooms and annotation. **Export:** MP4 1080p30 of the two-clip project, 10288 frames, audio and video within one frame, −16.0 LUFS and −1.4 dBTP, annotation upright, caption plate at x = 108 for a 10 % inset, Full Camera where mapped, music ducked about 10 dB under speech with fades at the track's own edges, muted track absent, voiceover not stretched by a 2× region. GIF 25 fps: cancel removes the partial file and leaves the existing destination untouched; the full render (~127 s, #952) gives 434 frames, infinite loop, consistent in ffmpeg and GDI+. **Also seen:** a take with a ~4 s pause had audio 1.09 s past its video, against 0.02–0.17 s without a pause; three dedicated paused takes gave 0.40, 0.15 and 0.03 s. The export ends each clip at its last video frame (10288 frames against the 10320 the progress counted), so the timeline and the export disagree by that tail. The editor reopens 4 px taller than it closed at 125 %. **Not run:** the A/V offset across a pause measured directly (the flash-and-beep rig never painted on the captured desktop), the HUD with no camera (needs the camera disabled in Windows), tray right-click menus (Update Settings, Stop Recording, Save Diagnostics: Explorer is granted click-only), the Alt Help menu (an Alt tap showed nothing, inconclusive), Ctrl/Shift+wheel on the timeline, cursor auto-hide, smoothing, motion blur and click effects, annotation animations other than Typewriter, Depth of field in an export, chat rewind, history and Smart cuts, a software-encoder take, the crackle and hole scan, multiple displays, 4K and 1440p cameras, 150 % DPI, macOS and Linux. |
 | 2026-10-03 | `main` @ `0624c148` (sources identical to `v2.0.0-rc.13` in `crates/`, `src/`, `electron/`), packaged locally (`electron-builder --mac dir --arm64`, ad hoc signed), `compositor_view.node` SHA256 `7c1d38d664d29fa78615c386aa86e53456f1e662289ad53a2a128d588b99d560`; baseline the installed `v2.0.0-rc.12` DMG (Developer ID) | macOS 26.5 (25F71), Mac mini M1, 1920×1080 @ 2× | Partial, no defect | **Shader split, corner fast path, background cache and trail scissor (#982, #983, #984) on Metal. Not a computer-use pass:** `request_access` was refused with nobody at the machine, so the editor was driven over CDP (synthesised clicks on the inspector, preview pixels read from the canvas). `cargo test -p openscreen-compositor --lib --tests`: 407 passed, 0 failed, `every_shader_entry_point_compiles` (with the `LAYER_MODELS` library) and the macOS device-frame and 3D-cursor tests included; the `tests/` render binaries are Windows/Linux only and ran 0. **Export** (`openscreen export`, MP4 1080p60): bench project plus four variants (laptop + 3D cursor + click impact + blur, phone dark + Prism Glow + Aurora gradient, monitor + click impact + colour, window + full blur), frames extracted with ffmpeg: device frames with their shadows, 3D cursor with its shadow, click impact, trail, rounded corners and backgrounds all present. Same projects exported losslessly (`ffv1` candidate added locally, measurement only) with the rc.12 and main addons in one bundle: luma differs by 1/255 on anti-aliased edges, and by up to 20/255 on at most 159 px of a few frames along the 3D models' silhouettes (Metal fast math, models now in their own library); nothing missing. **Preview:** wallpaper image → gradient → colour → back, blur 50 % → 0 %, aspect 1:1 → Auto each return the exact starting frame; a static background holds still over 1 s of playback, *Aurora* animates; laptop and phone frames draw their shadows. **Perf** (screen-recorder-benchmark `commons-upload`): rc.12 1.134× floor, main 1.066×, figures in `rendering-performance.md`. **Not covered:** real recording, HUD, tray, computer-use input, the GUI export dialog, Escape, a 1.11.0-rc.1 run in the same session (discarded: a Parsec session went live mid-run), Windows (the D3D11 port is still unrun on a real GPU) and Linux. |
 | 2026-10-11 | dev helper from `fix/os920-resample-continuity` @ `aa27e6fdf` (audio fix commits `50a433168` cross-packet continuity + `e29119445` starvation-resume restart; helper and test exe built from the committed tree with `npm run build:native:win`; test-exe sha256 `bb6921d0…`); historical evidence archived under former fork staging PR `My-Denia/openscreen#23` for study issue #920 §24; current submission: upstream PR [getopenscreen/openscreen#1113](https://github.com/getopenscreen/openscreen/pull/1113), open, with CI green on the head under review | Windows 11 build 26340.9616; **both audio endpoints fixed 48 kHz shared mode** (measured: single-valued 480-frame/10 ms packets, 0 non-aligned) | Partial — no defect found; two paths not real-machine testable on this host | **Audio resampling continuity slice (#920 item 24), helper-level + real-machine hybrid.** The defect: `convertAudioWithGain`'s non-integer branch held no cross-packet state, so identical input produced different output depending on packet boundaries (48k→44.1k, 100-frame packets: 14700→14720 frames, drifting positions). The fix adds cumulative integer-rational output accounting (K(N)/C(N)), absolute-position interpolation with the legacy arithmetic preserved, bounded retention, and a `finalizeAudioConversion` tail used only by the stateless test-facing overload; a second commit restarts the interpolation stream at mixer starvation-resume (automated-review P2: the new state could otherwise complete ≤⌈T/S+½⌉ deferred frames across a real-time gap using pre-gap samples — a blend the pre-fix stateless converter never made; integer decimation and same-rate paths keep their pre-existing cross-gap behavior, pinned by controls). **Evidence:** assertion-based old-FAIL on the pristine pinned base (9 named failures) → new-PASS; full native suite **176/176** and focused 54/54 on that base; starvation fix proven behaviorally old-FAIL (`50a433168`: 1 failing mixer-path test — resumed queue 368 bytes vs cold 364, first frame −12594 = pre-gap/post-gap blend vs cold +16384) → PASS after `e29119445`. **Submitted-tree native validation, separately attributed:** pre-chain validation of the candidate tree that became `5764aa2b6e` completed `npm run build:native:win` with 0 errors, full native suite **177/177**, and focused suite **55/55**, including `os920-finalize-appends-after-whole-frames` PASS. These are separate submitted-tree results, not a re-run or replacement of the historical pinned-base pass above. **Real machine (matched-rate only):** 6×60 s 48 kHz/48 kHz recordings (3 pre-fix/3 fixed helpers interleaved) + pause/resume takes — all valid, marker spacing 3.0000–3.001 s, old/new within each other's repeat envelope, zero clipping; captured real callback streams replayed through old/new converters **6/6 byte-identical**; no regression observed. **Mismatched-rate real capture (second pass, same day, owner-enabled):** the default render endpoint (JM6PRO) was switched to 16-bit/44100 Hz and the encoder target forced to 48000 via the production `OPENSCREEN_WGC_FORCE_AAC_SOURCE_RATE` surface (the video-rate-alignment path); five 35 s takes ran old×2 / fixed×2 / instrumented-fixed with the same marker harness. Every real loopback packet was exactly 441 frames (3496/3496 — this hardware produces perfectly aligned 10 ms geometry, so the packet-boundary defect class is not reachable on it and stays covered by the deterministic suites); decoded old vs fixed output is time-aligned at zero offset with 97.4 % byte-identical frames and residual maxdiff 170 (AAC block-boundary quantization from the one-frame first-packet emission difference — no drift, no regression); each build repeated byte-identically; the mixer's startup starvation-padding path ran on real hardware (~70 ms). Starvation/underrun beyond startup was **not** reproduced on real hardware — covered by the deterministic real-`AudioMixer`-path tests above; no full capture-to-export GUI cycle, editor/export/transcript sections, webcam, GIF or non-audio checks for this slice; macOS/Linux N/A (WGC-only code). Fork CI did not run at pass time (GitHub-side Actions suspension on the repo — settings and workflow states reported enabled/active while every dispatch returned 422; full evidence in the run); Actions was restored later the same day and CI has since run green on each exact head under review (runs 38119381114, 38121492689, and 38125479601 recorded for their respective exact heads — run evidence in the project archive). This CI has no native C++ job — the native evidence is the local MSVC build and suites above. Upstream PR #1113 is open, with CI green on the head under review; awaiting maintainer review. |
+| 2026-10-12 | dev `feat/clip-rotation` at `1588e6c6`; `npm run build-vite`; `compositor_view.node` (ARM64) built from this tree by `npm run build:native:compositor` and loaded via `OPENSCREEN_COMPOSITOR_VIEW_NODE` | Windows 11 on ARM64 (Snapdragon X Elite), driven by Playwright (`_electron`), no computer-use | **Partial — clip rotation 180° passed in preview and export (8/8 scripted checks)** | Playwright script on a copy of a real one-clip recording with cursor telemetry and a webcam (copy removed afterwards): Edit clip → Rotation 180° → Apply stored `rotation: 180` on the clip; the preview frame at 10 s matches the upright frame turned (mean centre difference 3.0 against 14.9 to the upright frame); the cursor stays on the same content; webcam PiP and wallpaper stay upright; Ctrl+Z removed the field and the preview is upright again (0.0), Ctrl+Shift+Z restored it; no console errors. CLI export (`electron . export … --quality medium`) of the turned and of an upright twin project: centre of the turned frame vs the upright frame turned 1.9, vs upright 15.2; the screen picture's edge rows match, no stripe from the decoder padding. The Edit-clip dialog's own `<video>` shows block artefacts at the clip's first frame — the same with and without rotation, not from this change. Not covered: Linux and macOS (fork CI only), the browser fallback preview (`VirtualPreview`) in the running app, a crop together with the rotation in the running app, a 3D/tilt preset on a turned clip, zoom regions set by hand before turning, a desk camera recording. |