@@ -1158,7 +1158,7 @@ pub fn cursor_sprite_cb(
                 src_prev: [br0, br1, bl0, bl1],
                 // Le clip vit ici et NON dans `fx` (mode 7) : `fx` porte les coins.
                 dst_prev: clip,
-                // `mb.x` : 1 = warp projectif (tout écran incliné, cf. `screen_tilt`).
+                // `mb.x` : 1 = warp projectif (caméra réelle ou appareil, cf. `screen_tilt`).
                 mb: [quad.warp_flag(), 0.0, 0.0, 0.0],
                 ..Default::default()
             }
@@ -1908,16 +1908,16 @@ impl FrameGeometry {
                 self.zoom_rotation,
                 self.zoom_rotation_dyn,
             );
-            // Un angle fixe se dessine au warp PROJECTIF, comme la caméra réelle. Les quatre coins
-            // sont ceux de la projection exacte, donc l'homographie qu'ils définissent EST cette
-            // projection, partout et pas seulement aux coins. Le warp bilinéaire s'en écartait de
-            // ~8 % de la largeur au milieu des bords (mesuré par
-            // `the_device_screen_face_lands_on_the_footage_plane`), et surtout il PENCHAIT le
-            // contenu : la verticale du milieu de l'écran, droite sous une caméra sans roulis,
-            // tombait de 2,9° sous `iso` et de 0,8° sous `left`/`right`, et ce roulis-là entrait
-            // avec le zoom. Le mode 17 (appareil) en dépend aussi : il lance ses rayons dans la
-            // perspective exacte.
-            quad.projective = true;
+            // Un angle fixe se dessine au warp BILINÉAIRE de ses coins : le rendu des angles fixes
+            // de la v1.13.0, à l'octet. Sous un cadre d'APPAREIL seulement, l'écran passe au warp
+            // PROJECTIF : le mode 17 lance ses rayons dans la perspective exacte, et le warp
+            // bilinéaire s'en écarte de ~8 % de la largeur au milieu des bords (mesuré par
+            // `the_device_screen_face_lands_on_the_footage_plane`), soit une lunette à cent pixels
+            // du bord de l'image. Les quatre coins sont les mêmes des deux côtés, donc
+            // l'homographie qu'ils définissent EST cette projection exacte.
+            if self.window_frame.as_ref().is_some_and(|f| f.kind.is_device()) {
+                quad.projective = true;
+            }
             quad
         })
     }
@@ -4663,10 +4663,10 @@ mod tests {
             assert_eq!(cb.dst_prev[3], 1.0, "{name}: l'écran est resté au warp bilinéaire");
             assert_eq!(cb.color, [0.0; 4], "{name}: la lampe de la caméra s'est allumée");
         }
-        // Sans appareil, l'angle fixe a le même warp exact (`screen_tilt`) et toujours pas de
-        // lampe ; la caméra réelle, elle, a les deux.
+        // Sans appareil, l'angle fixe garde son warp bilinéaire ET son absence de lampe ; la
+        // caméra réelle, elle, garde les deux.
         let plain = flat_cb(&framed_plan(&framed_scene("", r#""iso""#, 1.0, false)));
-        assert_eq!((plain.dst_prev[3], plain.color), (1.0, [0.0; 4]));
+        assert_eq!((plain.dst_prev[3], plain.color), (0.0, [0.0; 4]));
         let orbit = flat_cb(&framed_plan(&framed_scene("", r#""follow-cursor""#, 1.0, false)));
         assert_eq!(orbit.dst_prev[3], 1.0);
         assert!(orbit.color[0] != 0.0 || orbit.color[1] != 0.0, "la caméra réelle n'éclaire plus");
@@ -5961,7 +5961,7 @@ mod tests {
     /// reporté dans le slot d'un layout en bloc ; sans elle, rien de ce qu'il portait ne change.
     #[test]
     fn the_tilted_screen_cb_carries_its_trail_in_its_own_frame() {
-        let quad = crate::regions::rotated_quad_corners_px(800.0, 450.0, [-23.0, -25.0, 0.0], [0.0; 3]);
+        let quad = crate::regions::rotated_quad_corners_px(800.0, 450.0, [-12.0, -18.0, -2.0], [0.0; 3]);
         let moved = TiltTrail { corners: quad.corners.map(|(x, y)| (x * 0.9 + 3.0, y * 0.9 - 2.0)), mb: [6.0, 0.35] };
         let mask = ScreenMask { rect: [0.1, 0.1, 0.6, 0.6], radius_px: 8.0 };
         let cb = |mask, trail| {
@@ -7011,8 +7011,8 @@ mod tests {
         .expect("plan cursor")
     }
 
-    const ISO: [f32; 3] = [-23.0, -25.0, 0.0];
-    const LEFT: [f32; 3] = [-23.0, -25.0, 0.0];
+    const LEFT: [f32; 3] = [-12.0, -18.0, -2.0];
+    const RIGHT: [f32; 3] = [-12.0, 18.0, 2.0];
 
     /// Le `LayerCB` du sprite incliné est, octet pour octet, celui que chaque backend construisait
     /// avant de le partager. La référence est le corps d'origine de `draw_cursor_sprite`.
@@ -7070,7 +7070,7 @@ mod tests {
             let len = std::mem::size_of::<LayerCB>();
             unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, len) }.to_vec()
         };
-        for rot in [ISO, LEFT, [-23.0, 25.0, 0.0]] {
+        for rot in [LEFT, RIGHT] {
             let plan = plan_with(rot);
             let clip = [0.1, 0.2, 0.7, 0.6];
             let got = cursor_sprite_cb(
@@ -7327,7 +7327,7 @@ mod tests {
         let scene = model_scene();
         for key in MODEL_STATES {
             let (sdf, shape) = sprite_model(key);
-            for rot in [[0.0; 3], [-23.0, -25.0, 0.0]] {
+            for rot in [[0.0; 3], LEFT] {
                 let track = still_track_as(Some(key), vec![0.5]);
                 for (t, want) in [(0.3, MODEL_HOVER), (0.5 + CONTACT_S, 0.0)] {
                     let plan = model_plan(rot, &scene, &track, t, true).expect("plan");
@@ -7451,9 +7451,6 @@ mod tests {
         assert!(model_plan([0.0; 3], &bare, &track, 0.3, true).expect("plan").model.is_none());
     }
 
-    const LEFT_ROT: [f32; 3] = [-23.0, -25.0, 0.0];
-    const ISO_ROT: [f32; 3] = [-23.0, -25.0, 0.0];
-
     /// Les poses d'essai, pour chaque état de `MODEL_STATES` : au repos, posé, tourné.
     fn model_cases() -> Vec<(String, CursorPlan, SpriteShape, crate::cursor_sdf::CursorSdf)> {
         let scene = model_scene();
@@ -7465,7 +7462,7 @@ mod tests {
                 vec![],
                 vec![(0.0, key.to_string())],
             );
-            for (name, rot) in [("flat", [0.0; 3]), ("iso", ISO_ROT), ("left", LEFT_ROT), ("right", [-23.0, 25.0, 0.0])] {
+            for (name, rot) in [("flat", [0.0; 3]), ("left", LEFT), ("right", RIGHT)] {
                 for (pose, track, t) in [("hover", &clicked, 0.3), ("touch", &clicked, 0.5 + CONTACT_S), ("yaw", &moving, 1.0)] {
                     let plan = model_plan(rot, &scene, track, t, true).expect("plan");
                     let (sdf, shape) = sprite_model(key);
 
@@ -602,25 +602,17 @@ fn ease_connected_pan(t: f32) -> f32 {
 /// alors que le plan était rendu en entier — mesuré au pixel sur un export 1920×1080 : bord droit
 /// à 1539, coin calculé à 1540, arrondis présents aux quatre coins.
 ///
-/// Aucune arête ne s'approche donc d'un axe à moins de 2° (cf.
-/// `no_preset_has_an_axis_aligned_edge`), et AUCUN préset ne roule : Z vaut 0. Le tilt entre avec
-/// le zoom, et une caméra qui bouge ne roule jamais le métrage — le roulis de −2°/±1° qui tenait
-/// la règle jusqu'ici penchait l'image pendant chaque zoom, et balayait 2° entre left et right.
+/// Chaque préset a donc ses trois composantes, choisies pour qu'aucune arête ne s'approche d'un
+/// axe à moins de 2° (cf. `no_preset_has_an_axis_aligned_edge`).
 ///
-/// Sans roulis, la règle ne laisse que deux bandes de tangage (X). Une rotation Y pure garde les
-/// verticales verticales, donc chaque préset tangue ; et entre 10° et 14° de tangage, le bord haut
-/// d'un écran tourné ressort à plat (la remontée du rotateX annulée par la perspective), à tout
-/// lacet. Les deux présets prennent donc la bande haute, le regard de l'ancien `iso` : tourné et
-/// vu d'en haut franchement, arêtes à 4,8° au plus près. Ils sortent de la bande des 2° pendant
-/// leur ease-in à 0,82 de force, avant que la parallaxe ne s'ouvre (`PARALLAX_GATE_START`), et
-/// laissent au budget dynamique ses ±1,9° / ±3° d'origine (`DYNAMIC_TILT_BUDGET`).
-///
-/// `iso` n'est plus proposé : c'était déjà ce regard-là, tourné à gauche. Un projet qui le porte
-/// encore se lit donc comme `left` (côté app : `readRotation3DPreset`, et ici par sécurité).
+/// `left` EST l'`iso` de la v1.13.0, à la valeur près : tourné vers la gauche et vu d'en haut, avec
+/// son léger roulis. `right` en est le miroir (lacet et roulis inversés). `iso` n'est plus proposé
+/// et se lit comme `left` (côté app : `readRotation3DPreset`, et ici par sécurité), donc un projet
+/// qui le porte rend exactement comme avant.
 fn rotation3d_for(rotation: &Option<String>) -> [f32; 3] {
     match rotation.as_deref() {
-        Some("left" | "iso") => [-23.0, -25.0, 0.0],
-        Some("right") => [-23.0, 25.0, 0.0],
+        Some("left" | "iso") => [-12.0, -18.0, -2.0],
+        Some("right") => [-12.0, 18.0, 2.0],
         _ => [0.0, 0.0, 0.0],
     }
 }
@@ -1149,11 +1141,11 @@ pub(crate) const PERSPECTIVE_FACTOR: f32 = 1.6;
 /// profondeur rapporté à la distance de fuite (`|z − z_focus| / P`).
 ///
 /// Réglé une fois, en unités de P : cet écart ne dépend ni de la résolution ni du zoom (la
-/// perspective se déduit de la taille du plan lui-même). Sur iso en 16:9, focus au centre, le
-/// coin lointain est à ~0.25 P, soit un flou de ~5.9 texels, au plafond du shader
-/// (`DOF_MAX_LOD`, niveau 1.5 de la pyramide demi-résolution, soit ~5.7 texels) ; focus sur le
-/// coin proche, l'écart double. Un flou exprimé en texels suit le CONTENU : la même zone est aussi
-/// floue quel que soit le zoom qui l'affiche.
+/// perspective se déduit de la taille du plan lui-même). Sur `left` en 16:9, focus au centre, le
+/// coin lointain est à ~0.19 P, soit un flou de ~4.6 texels ; focus sur le coin proche, l'écart
+/// double et le shader plafonne (`DOF_MAX_LOD`, niveau 1.5 de la pyramide demi-résolution, soit
+/// ~5.7 texels). Un flou exprimé en texels suit le CONTENU : la même zone est aussi floue quel
+/// que soit le zoom qui l'affiche.
 pub const DOF_COC_PER_DEPTH: f32 = 24.0;
 
 /// Les 4 coins d'un quad `width`×`height` réduit de `scale`, projetés. `None` si un coin part
@@ -1208,10 +1200,9 @@ pub struct TiltedQuad {
     /// Où tombe le centre du plan à l'image, en px relatifs au centre du rect d'origine.
     pub offset: [f32; 2],
     /// `true` : le plan se dessine par l'homographie EXACTE de ses coins ; `false` : par le warp
-    /// bilinéaire, qui penche le contenu d'un plan tourné ET tangué (sa verticale du milieu
-    /// suit les milieux des bords, pas la projection). Tout écran incliné passe au projectif
-    /// (`FrameGeometry::screen_tilt`) ; `rotated_quad_corners_px` rend `false`, la géométrie
-    /// seule.
+    /// bilinéaire des angles fixes, le rendu de la v1.13.0. La caméra réelle l'exige, et un cadre
+    /// d'appareil aussi (le mode 17 lance ses rayons dans la perspective exacte,
+    /// `FrameGeometry::screen_tilt`).
     pub projective: bool,
     /// `true` : une lampe posée sur la caméra éclaire un peu plus le côté proche du plan
     /// (`CAMERA_LIGHT_GAIN`, cf. `tilted_screen_cb`). Elle appartient à la caméra RÉELLE, pas au
@@ -1332,9 +1323,10 @@ fn contain_scale(
 /// puis la somme est bornée par `clamp_dynamic_tilt`.
 ///
 /// - Z : 0. Jamais de roulis : une caméra qui bouge ne roule pas le métrage.
-/// - X : ±1,9°, Y : ±3°. Ensemble, à 1,15 fois ces valeurs, `left` sort d'une des deux règles
-///   (arête à moins de 2° d'un axe, ou débordement de sa boîte) ; seul, Y y arrive vers 3,3°, X
-///   laisse plus de marge (`the_budget_is_close_to_what_left_allows`).
+/// - X : ±1,9°, Y : ±3°. Les valeurs de la v1.13.0, au ras de son `left` [−8, −16, −1] : le
+///   `left` d'aujourd'hui, son `iso`, garde ainsi sa parallaxe et son impact à l'identique. Il ne
+///   sortirait d'une des deux règles (arête à moins de 2° d'un axe, ou débordement de sa boîte)
+///   qu'à 1,46 fois ce balayage.
 ///
 /// Reproduits par `the_budget_sweep_keeps_every_edge_off_axis`,
 /// `the_budget_sweep_stays_inside_the_original_rect` et
@@ -1353,10 +1345,10 @@ pub fn clamp_dynamic_tilt(rot: [f32; 3]) -> [f32; 3] {
 }
 
 /// Force du préset sous laquelle la part dynamique est nulle ; elle s'installe en smoothstep
-/// jusqu'à 1. La spec disait 0,5 ; les maths de ce crate disent autrement : en montant,
-/// `left`/`right` traversent le tangage où leur bord haut ressort à plat, et ne sortent de la
-/// bande des 2° qu'à 0,82 de force : la porte doit s'ouvrir après, et raide. Cf.
-/// `the_budget_sweep_keeps_every_edge_off_axis`.
+/// jusqu'à 1. La spec disait 0,5 ; les maths de ce crate disent autrement : l'ease-in part de
+/// l'écran droit, dont les arêtes longent les axes, et `left`/`right` ne sortent de la bande des
+/// 2° qu'à 0,48 de force. 0,85 est la porte de la v1.13.0, réglée pour son `left` plus serré
+/// (sorti de la bande à 0,635 seulement). Cf. `the_budget_sweep_keeps_every_edge_off_axis`.
 const PARALLAX_GATE_START: f32 = 0.85;
 /// Degrés de parallaxe par unité de vitesse (largeurs — ou hauteurs — de coupe par seconde),
 /// avant saturation. Un balayage d'une demi-largeur par seconde penche d'environ 2° en Y, une
@@ -2232,13 +2224,14 @@ mod tilt_tests {
         }
     }
 
-    /// `iso` n'est plus proposé : il se lit comme `left`, qui a gardé son regard, et `right` en est
-    /// le miroir exact.
+    /// `left` est l'`iso` de la v1.13.0 à la valeur près, `iso` se lit comme lui, et `right` en est
+    /// le miroir exact : lacet et roulis inversés.
     #[test]
     fn iso_reads_as_left_and_right_mirrors_it() {
         let left = rotation3d_for(&Some("left".into()));
+        assert_eq!(left, [-12.0, -18.0, -2.0], "l'iso de la v1.13.0");
         assert_eq!(rotation3d_for(&Some("iso".into())), left);
-        assert_eq!(rotation3d_for(&Some("right".into())), [left[0], -left[1], 0.0]);
+        assert_eq!(rotation3d_for(&Some("right".into())), [left[0], -left[1], -left[2]]);
     }
 
     /// Aucune arête d'un préset ne doit longer un axe de l'image. C'est LE critère qui distingue
@@ -2374,7 +2367,7 @@ mod tilt_tests {
         };
         let centre = [0.5, 0.5];
         assert!(coc(1920.0, 1080.0, centre, 0.5, 0.5) < 1e-4);
-        // Coin lointain (BL) : ~0.25 P, donc ~5.9 texels, bien au-dessus du seuil net (0.5).
+        // Coin lointain (BL) : ~0.19 P, donc ~4.6 texels, bien au-dessus du seuil net (0.5).
         let far = coc(1920.0, 1080.0, centre, 0.0, 1.0);
         assert!((3.5..6.0).contains(&far), "coin lointain {far}");
         // Focus posé sur le coin proche (TR) : le lointain s'en éloigne encore.
@@ -2417,12 +2410,6 @@ mod tilt_tests {
             .min(v(c[1], c[2]))
     }
 
-    /// Débordement relatif du quad hors du rect d'origine (> 0 = déborde).
-    fn overflow(c: &[(f32, f32); 4], w: f32, h: f32) -> f32 {
-        let (mx, my) = projected_extents(c);
-        (mx / (w * 0.5)).max(my / (h * 0.5)) - 1.0
-    }
-
     /// Toutes les parts dynamiques d'un budget réduit de `g`, sur une grille qui inclut les
     /// coins de la boîte (le pire cas combine les deux axes).
     fn budget_sweep(g: f32) -> impl Iterator<Item = [f32; 3]> {
@@ -2441,9 +2428,9 @@ mod tilt_tests {
 
     /// La règle des 2° tient sur TOUT le balayage du budget, et pas qu'aux présets : à force 1
     /// sur la boîte entière, et pendant l'ease-in, où la part dynamique ne doit jamais faire
-    /// passer une arête sous min(2°, ce que la base seule donne). Sous ~0,82 de force, `left`
-    /// et `right` sont DÉJÀ dans la bande (l'ease-in traverse 0°, puis le tangage où leur bord
-    /// haut ressort à plat) ; on ne leur demande alors que de ne pas empirer.
+    /// passer une arête sous min(2°, ce que la base seule donne). Sous ~0,48 de force, `left`
+    /// et `right` sont DÉJÀ dans la bande (l'ease-in traverse 0°) ; on ne leur demande alors que
+    /// de ne pas empirer.
     #[test]
     fn the_budget_sweep_keeps_every_edge_off_axis() {
         let (w, h) = (1920.0f32, 1080.0f32);
@@ -2465,26 +2452,6 @@ mod tilt_tests {
         }
     }
 
-    /// Les chiffres du budget sont ceux des maths du crate, à peu près au ras : le balayage à 15 %
-    /// de plus sur X et Y ensemble fait casser à `left` une des deux règles, arête à moins de 2°
-    /// d'un axe (16:9) ou débordement de sa boîte (les trois formes), et Y seul aussi. X seul a
-    /// plus de marge : c'est avec Y qu'il la consomme. Z n'a pas de budget, c'est la règle produit.
-    #[test]
-    fn the_budget_is_close_to_what_left_allows() {
-        let base = preset("left");
-        let breaks = |d: [f32; 3]| {
-            [(1920.0f32, 1080.0f32), (1080.0, 1920.0), (800.0, 800.0)].into_iter().any(|(w, h)| {
-                let c = rotated_quad_corners_px(w, h, base, d).corners;
-                (w > h && min_edge_angle(&c) < 2.0) || overflow(&c, w, h) > 0.0
-            })
-        };
-        let b = DYNAMIC_TILT_BUDGET;
-        assert!(!budget_sweep(1.0).any(|d| breaks(d)), "le budget lui-même doit tenir");
-        assert!(budget_sweep(1.15).any(|d| breaks(d)), "X et Y");
-        assert!(breaks([0.0, b[1] * 1.15, 0.0]) || breaks([0.0, -b[1] * 1.15, 0.0]), "Y");
-        assert_eq!(b[2], 0.0, "Z n'a pas de budget");
-    }
-
     /// Échelle gelée : la part dynamique ne fait que re-projeter les coins, et le quad ne
     /// déborde toujours pas du rect d'origine — sur les trois formes de boîte de
     /// `every_preset_stays_inside_the_original_rect`.
@@ -3359,7 +3326,7 @@ mod follow_camera_tests {
         assert_eq!((blind.aim, blind.orbit), ([0.5, 0.5], [0.5, 0.5]));
         // Un angle fixe garde exactement son état.
         let left = zoom_state_in(&[region("left", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());
-        assert_eq!((left.rotation, left.camera, left.click_impact), ([-23.0, -25.0, 0.0], 0.0, 1.0));
+        assert_eq!((left.rotation, left.camera, left.click_impact), ([-12.0, -18.0, -2.0], 0.0, 1.0));
         let unknown = zoom_state_in(&[region("orbit", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());
         assert_eq!((unknown.rotation, unknown.tilt, unknown.camera), ([0.0; 3], 0.0, 0.0));
     }
 
@@ -253,8 +253,8 @@ float3 quad_inverse_projective(float2 P, float2 c00, float2 c10, float2 c11, flo
     return float3(s, t, ok);
 }
 
-// Le warp inverse d'un calque posé sur le plan : projectif (`projective` = 1, cf.
-// `TiltedQuad::warp_flag`, que tout écran incliné porte), bilinéaire sinon.
+// Le warp inverse d'un calque posé sur le plan : projectif sous la caméra réelle ou un appareil
+// (`projective` = 1, cf. `TiltedQuad::warp_flag`), bilinéaire sous un angle fixe, inchangé.
 float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, float projective)
 {
     if (projective > 0.5)
@@ -1455,8 +1455,8 @@ float4 ps_main(VSOut i) : SV_Target
     // mode 8 : écran tilté en 3D (zoom regions "rotation" : iso/left/right) ou vu par la caméra
     // réelle (`follow-cursor`). `dst`/`quad_px` couvrent la BOUNDING BOX des 4 coins projetés
     // (`frame_geometry::tilted_screen_cb`) ; ce shader retrouve où tombe chaque pixel DANS le quad
-    // (warp inverse : projectif exact quand dst_prev.w = 1, ce que porte tout écran incliné,
-    // bilinéaire sinon) et échantillonne la vidéo à l'UV correspondant, sinon transparent.
+    // (warp inverse : bilinéaire sous un angle fixe, projectif exact sous la caméra réelle ou un
+    // appareil, dst_prev.w = 1) et échantillonne la vidéo à l'UV correspondant, sinon transparent.
     // fx.xy/fx.zw = coins TL/TR (px locaux, 0..quad_px) ; src_prev.xy/.zw = coins BR/BL.
     // color.xy (caméra réelle) : éclairage 1 + color.x·(s − 0.5) + color.y·(t − 0.5).
     // mb = [gx, gy, z_focus, k] : profondeur du point r du plan = (r.x - 0.5)*gx + (r.y - 0.5)*gy