EtienneLescot · Oct 15, 2026 · Oct 16, 2026 · Oct 16, 2026 · Oct 15, 2026 · Oct 15, 2026
@@ -3058,9 +3058,11 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         // clip, elle tombe dans le trou d'un trim ou dans le clip d'avant. Les régions y valent
         // ce qu'elles valent hors du clip (Full Camera coupée par un trim : 0), et le flou de
         // mouvement traînait la caméra plein cadre jusqu'à son coin PiP sur la frame de la coupe.
+        // Comparé en f32, comme les bornes des régions : la première frame d'un clip tombe pile
+        // sur son début, et un début inexact en f32 (11.388) relu en f64 passait sous la borne.
         let source_t_prev = clock.source_at(clock.at(source_t) - 1.0 / FPS);
         let source_t_prev = match scene.and_then(|s| s.clips.get(s.active_clip_index)) {
-            Some(clip) if f64::from(source_t) >= clip.source_start_sec => {
+            Some(clip) if source_t >= clip.source_start_sec as f32 => {
                 source_t_prev.max(clip.source_start_sec as f32)
             }
             _ => source_t_prev,
@@ -4849,6 +4851,41 @@ mod tests {
         assert_eq!(g.w_dst_prev, g.w_dst, "pas de traînée depuis le trou du trim");
     }
 
+    /// La même coupe, mais la première frame du clip tombe PILE sur son début, comme à l'export
+    /// (`walk_composited_timeline` pose `target_source_time as f32`), et ce début n'est pas exact
+    /// en f32 : `11.388f32` relu en f64 vaut 11.38799953…, sous le début du clip. La borne de la
+    /// frame précédente ne s'appliquait donc pas, alors que la phase Full Camera, comparée en
+    /// f32, voyait déjà la caméra plein cadre : frame 600 traînée vers le coin PiP à l'export et
+    /// dans `getFrames` (passe e2e macOS de v2.1.0-rc.3).
+    #[test]
+    fn the_first_frame_of_a_clip_starting_inside_full_camera_has_no_trail() {
+        let cfg = crate::config::all().pop().expect("au moins une config");
+        let scene = Scene::from_json(
+            r##"{
+            "clips":[{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10.001,"webcamOffsetSec":0,"hasAudio":true},
+                     {"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":11.388,"sourceEndSec":27.12,"webcamOffsetSec":0,"hasAudio":true}],
+            "layout":{"preset":"picture-in-picture","webcamSize":0.44,"webcamShape":"circle","webcamMirror":false,
+                      "webcamPosition":{"cx":0.8577,"cy":0.8159},"webcamReactiveZoom":false},
+            "effects":{"padding":0.51,"blur":false,"shadow":0.35,"roundnessFrac":0.0255,"motionBlur":0.2},
+            "background":{"kind":"color","color":"#1e1e2e"},
+            "zoomRegions":[],
+            "cameraFullscreenRegions":[{"clipIndex":0,"startSec":8.006,"endSec":10.001,"continuesAfter":true},
+                                       {"clipIndex":1,"startSec":11.388,"endSec":14.061,"continuesBefore":true}],
+            "cursor":{"show":true,"size":7.76,"smoothing":0,"motionBlur":0.35,"clickBounce":1,"clipToBounds":false,"theme":"default"},
+            "output":{"width":1080,"height":1920,"fps":60}
+        }"##,
+        )
+        .expect("scène coupée")
+        .for_clip_window(1, 11.388, 27.12);
+        assert!(f64::from(11.388f32) < 11.388, "le cas suppose un début inexact en f32");
+        let mut input = golden_input(&scene, &cfg);
+        input.timeline_t_override = Some(11.388f64 as f32);
+        let g = plan_frame(&input);
+
+        assert_eq!(g.w_dst, [0.0, 0.0, 1.0, 1.0], "la caméra reste plein cadre à travers le trim");
+        assert_eq!(g.w_dst_prev, g.w_dst, "pas de traînée depuis le trou du trim");
+    }
+
     /// La caméra en orbite, en focus auto : celle qui bouge avec le pointeur. Sans piste, elle
     /// rend comme l'orbite manuelle posée au centre.
     const ORBIT: &str = r#""orbit","focusMode":"auto""#;

@@ -16,9 +16,13 @@ use crate::frame_geometry::FootageQuad;
 use crate::live::FramePosition;
 use std::time::{Duration, Instant};
 
-/// Cases de l'anneau : une prête, une en transit vers le renderer (tenue jusqu'à ce que
-/// Chromium la relâche), une en écriture, et une de marge pour la latence de la libération.
-pub const RING_SLOTS: u32 = 4;
+/// Cases de l'anneau : une prête, une en écriture, et celles que Chromium tient encore. Une case
+/// relâchée reste tenue 40 ms de plus côté Electron (`SHARED_SLOT_RELEASE_DELAY_MS`), le temps
+/// que le GPU ait copié la frame dans le canvas : à 60 images/s, trois à quatre cases sont alors
+/// tenues en même temps. Avec quatre, le rendu attendait une case libre et sautait des frames ;
+/// huit laissent de la marge jusqu'à ~150 images/s, pour 8 × (largeur × hauteur × 4) octets de
+/// VRAM (66 Mo en 1080p).
+pub const RING_SLOTS: u32 = 8;
 
 /// Une case tenue plus longtemps que ça a perdu sa libération (renderer rechargé, import
 /// échoué en route) : Chromium relâche les autres dans la milliseconde. Même ordre que le
@@ -294,8 +298,9 @@ mod tests {
             book.publish(frame(u64::from(slot) + 1, slot));
             book.take(u64::from(slot), now);
         }
-        book.publish(frame(9, 3));
-        assert_eq!(book.claim(RING_SLOTS), Some(3));
+        let last = RING_SLOTS - 1;
+        book.publish(frame(u64::from(RING_SLOTS) + 1, last));
+        assert_eq!(book.claim(RING_SLOTS), Some(last));
         // Retirée : la livrer maintenant, pendant qu'on la réécrit, donnerait une image déchirée.
         assert_eq!(book.take(0, now), None);
     }

@@ -571,7 +571,7 @@ impl TextRasterizer {
         desc.set_width(w as u64);
         desc.set_height(h as u64);
         desc.set_usage(metal::MTLTextureUsage::ShaderRead);
-        desc.set_storage_mode(metal::MTLStorageMode::Shared);
+        desc.set_storage_mode(crate::compositor_macos::cpu_storage(&gpu.device));
         let texture = gpu.device.new_texture(&desc);
 
         texture.replace_region(

@@ -3,6 +3,9 @@
 //! ```sh
 //! OPENSCREEN_LIVE_SOURCE=/path/source.mp4 cargo test -p openscreen-compositor --test held_frame_clock -- --nocapture
 //! ```
+//!
+//! The camera test also needs `OPENSCREEN_LIVE_WEBCAM`, a camera file with a frame between 1 s and
+//! 1.25 s (any constant-frame-rate recording). The source itself does not count as a camera.
 
 #![cfg(any(windows, target_os = "macos"))]
 
@@ -52,6 +55,7 @@ fn a_held_frame_follows_the_playback_clock() {
         assert!(player.present_frame(&comp, &cfg, 1.0).expect("seek"), "paused seek");
         let held = player.screen_time_sec();
         let at_pts = player.programme_time().expect("programme clock");
+        assert_eq!(player.composed_time_sec(), 1.0f64.max(held), "a seek reports the playhead");
 
         comp.set_programme_time(None);
         assert!(player.recompose_at(&comp, &cfg, held + 0.25).expect("recompose_at"));
@@ -63,9 +67,59 @@ fn a_held_frame_follows_the_playback_clock() {
             "programme time {advanced} instead of {at_pts} + 0.25 s"
         );
 
+        // Paused there, a param change or a settle pass recomposes: the frame keeps the time it
+        // was shown at. At the pts, the cursor and the published position went back.
         comp.set_programme_time(None);
         assert!(player.recompose(&comp, &cfg).expect("recompose"));
-        assert_eq!(comp.programme_time(), Some(at_pts), "recompose stays at the pts");
-        assert_eq!(player.composed_time_sec(), held);
+        assert_eq!(comp.programme_time(), Some(advanced), "recompose keeps the time it was composed at");
+        assert_eq!(player.composed_time_sec(), held + 0.25);
+
+        // A re-anchor positions the decoders without composing: the next recompose is at the
+        // anchored playhead, never at the time the frame before it was composed at.
+        assert!(player.seek_active(0.5).expect("seek_active"), "re-anchor");
+        player.anchor_at(0.5);
+        assert!(player.recompose(&comp, &cfg).expect("recompose"));
+        assert_eq!(player.composed_time_sec(), 0.5f64.max(player.screen_time_sec()));
+    }
+}
+
+#[test]
+fn a_held_frame_advances_the_camera_to_the_clock() {
+    let (Ok(source), Ok(camera)) =
+        (std::env::var("OPENSCREEN_LIVE_SOURCE"), std::env::var("OPENSCREEN_LIVE_WEBCAM"))
+    else {
+        println!("SKIP: set OPENSCREEN_LIVE_SOURCE and OPENSCREEN_LIVE_WEBCAM (file header).");
+        return;
+    };
+    let gpu = Gpu::create(false).expect("device");
+    let mut cfg = config::all().pop().expect("at least one config");
+    cfg.zoom = false;
+    cfg.layout_anim = false;
+    let comp = Compositor::new_sized(&gpu, 480, 270).expect("compositor");
+    let scene = Scene::from_json(&scene_json(&source)).expect("valid scene");
+    comp.set_live_params(live_params_from_scene(&scene));
+    comp.set_scene(Some(scene.clone()));
+    comp.clear_cursor();
+
+    unsafe {
+        let mut player = Player::open(&source, &camera, &gpu).expect("open the source");
+        assert!(player.webcam_decoder_is_real(), "the camera file must open");
+        player.set_programme_clock(Some(&scene), 0);
+        assert!(player.present_frame(&comp, &cfg, 1.0).expect("seek"), "paused seek");
+        let held = player.screen_time_sec();
+        let camera_before = player.webcam_time_sec();
+
+        let clock = held + 0.25;
+        assert!(player.hold_at(&comp, &cfg, clock).expect("hold_at"));
+        assert_eq!(player.screen_time_sec(), held, "the screen frame must stay the held one");
+        let camera_after = player.webcam_time_sec();
+        assert!(
+            camera_after > camera_before,
+            "the camera stood still at {camera_before:.3} s through the hold"
+        );
+        assert!(
+            camera_after <= clock + 1e-6,
+            "camera at {camera_after:.3} s, ahead of the clock {clock:.3} s"
+        );
-        let held = player.screen_time_sec();
-        let camera_before = player.webcam_time_sec();
-
-        let clock = held + 0.25;
-        assert!(player.hold_at(&comp, &cfg, clock).expect("hold_at"));
-        assert_eq!(player.screen_time_sec(), held, "the screen frame must stay the held one");
-        let camera_after = player.webcam_time_sec();
-        assert!(
-            camera_after > camera_before,
-            "the camera stood still at {camera_before:.3} s through the hold"
-        );
-        assert!(
-            camera_after <= clock + 1e-6,
-            "camera at {camera_after:.3} s, ahead of the clock {clock:.3} s"
-        );
+        let held = player.screen_time_sec();
+        let camera_before = player.webcam_time_sec();
+
+        // The playback clock after a seek is the playhead, not the held frame's pts.
+        let clock = 1.0f64.max(held) + 0.25;
+        assert!(player.hold_at(&comp, &cfg, clock).expect("hold_at"));
+        assert_eq!(player.screen_time_sec(), held, "the screen frame must stay the held one");
+        let camera_after = player.webcam_time_sec();
+        assert!(
+            camera_after > camera_before,
+            "the camera stood still at {camera_before:.3} s through the hold"
+        );
+        assert!(
+            camera_after <= clock + 1e-6,
+            "camera at {camera_after:.3} s, ahead of the clock {clock:.3} s"
+        );
-        let held = player.screen_time_sec();
-        let camera_before = player.webcam_time_sec();
-
-        let clock = held + 0.25;
-        assert!(player.hold_at(&comp, &cfg, clock).expect("hold_at"));
-        assert_eq!(player.screen_time_sec(), held, "the screen frame must stay the held one");
-        let camera_after = player.webcam_time_sec();
-        assert!(
-            camera_after > camera_before,
-            "the camera stood still at {camera_before:.3} s through the hold"
-        );
-        assert!(
-            camera_after <= clock + 1e-6,
-            "camera at {camera_after:.3} s, ahead of the clock {clock:.3} s"
-        );
+        let held = player.screen_time_sec();
+        let camera_before = player.webcam_time_sec();
+
+        // The playback clock after a seek is the playhead, not the held frame's pts.
+        let clock = 1.0f64.max(held) + 0.25;
+        assert!(player.hold_at(&comp, &cfg, clock).expect("hold_at"));
+        assert_eq!(player.screen_time_sec(), held, "the screen frame must stay the held one");
+        let camera_after = player.webcam_time_sec();
+        assert!(
+            camera_after > camera_before,
+            "the camera stood still at {camera_before:.3} s through the hold"
+        );
+        assert!(
+            camera_after <= clock + 1e-6,
+            "camera at {camera_after:.3} s, ahead of the clock {clock:.3} s"
+        );
     }
 }
@@ -200,6 +200,47 @@ describe("runChat tool loop", () => {
 		expect(undo.prompt).toBe("cut the silence");
 	});
 
+	it("reports the id it stored the user's message under, which a rewind accepts", async () => {
+		// The panel shows the message before the turn answers, under a local id the session does
+		// not know. Without this id it could only rewind after reloading the conversation.
+		const session = createSession("proj_rewind_sent");
+		const result = await runChat(
+			"proj_rewind_sent",
+			session.id,
+			"cut the silence",
+			stubConfig(),
+			fixtureDocument(),
+		);
+		const { selectSession } = await import("./chat-service");
+		const stored = selectSession("proj_rewind_sent", session.id)?.messages[0];
+		expect(result.userMessageId).toBe(stored?.id);
+		expect(result.userMessageCheckpointId).toBe(stored?.id);
+
+		const rewound = rewindToMessage("proj_rewind_sent", session.id, result.userMessageId ?? "");
+		expect(rewound.success).toBe(true);
+	});
+
+	it("reports the stored user message id when the model answers nothing", async () => {
+		invokeMock.mockImplementationOnce(async (args) => ({
+			text: "",
+			document: args.document,
+			mutated: false,
+		}));
+		const session = createSession("proj_empty_reply");
+		const result = await runChat(
+			"proj_empty_reply",
+			session.id,
+			"hi",
+			stubConfig(),
+			fixtureDocument(),
+		);
+		const { selectSession } = await import("./chat-service");
+		expect(result.success).toBe(false);
+		expect(result.userMessageId).toBe(
+			selectSession("proj_empty_reply", session.id)?.messages[0].id,
+		);
+	});
+
 	it("rewindToMessage refuses when the target has no checkpoint", async () => {
 		const { createSession, selectSession, runChat } = await import("./chat-service");
 		const session = createSession("proj_rewind_no_cp");

@@ -484,6 +484,9 @@ export async function runChat(
 		return {
 			success: false,
 			error: result.reason ?? "Empty response from model.",
+			// The message is stored all the same, and can be rewound to retry it.
+			userMessageId: userMessage.id,
+			userMessageCheckpointId: userMessage.checkpointId ?? undefined,
 		};
 	}
 
@@ -508,6 +511,7 @@ export async function runChat(
 		document: result.mutated && editsAllowed ? result.document : undefined,
 		toolCalls: appliedToolCalls.length ? appliedToolCalls : undefined,
 		userMessageCheckpointId: userMessage.checkpointId ?? undefined,
+		userMessageId: userMessage.id,
 	};
 }
 

@@ -10,6 +10,8 @@ import {
 	CompositorViewService,
 	ffmpegSharedBinCandidates,
 	resolveSceneAssetPaths,
+	SHARED_SLOT_RELEASE_DELAY_MS,
+	sharedSlotHoldMs,
 } from "./compositorViewService";
 
 describe("native GIF cancellation capability", () => {
@@ -112,7 +114,13 @@ describe("CompositorViewService frames handed over as shared GPU textures", () =
 		footageProjective: false,
 	};
 
-	function setup(options: { addon?: Partial<CompositorViewAddon>; gpuCompositing?: boolean } = {}) {
+	function setup(
+		options: {
+			addon?: Partial<CompositorViewAddon>;
+			gpuCompositing?: boolean;
+			displayHz?: number | null;
+		} = {},
+	) {
 		const addon = {
 			createView: vi.fn(() => 7),
 			setSharedFrames: vi.fn(() => true),
@@ -135,6 +143,7 @@ describe("CompositorViewService frames handed over as shared GPU textures", () =
 			addon: addon as unknown as CompositorViewAddon,
 			sharedTexture,
 			gpuCompositing: () => options.gpuCompositing ?? true,
+			displayHz: () => options.displayHz ?? 60,
 		});
 		const id = service.createView({ x: 0, y: 0, width: 4, height: 2 });
 		return {
@@ -185,13 +194,74 @@ describe("CompositorViewService frames handed over as shared GPU textures", () =
 		expect(addon.releaseSharedFrame).not.toHaveBeenCalled();
 	});
 
-	it("hands the slot back once Chromium has let go of the texture everywhere", async () => {
-		const { addon, id, releaseEverywhere, service } = setup();
-		await service.readFrame(id, 0, target);
+	it("hands the slot back a while after Chromium has let go of the texture everywhere", async () => {
+		vi.useFakeTimers();
+		try {
+			const { addon, id, releaseEverywhere, service } = setup();
+			await service.readFrame(id, 0, target);
 
-		releaseEverywhere();
+			releaseEverywhere();
+			// Not at once: the GPU copy into the canvas may still be queued behind the release.
+			vi.advanceTimersByTime(SHARED_SLOT_RELEASE_DELAY_MS - 1);
+			expect(addon.releaseSharedFrame).not.toHaveBeenCalled();
 
-		expect(addon.releaseSharedFrame).toHaveBeenCalledWith(id, 1, 3);
+			vi.advanceTimersByTime(1);
+			expect(addon.releaseSharedFrame).toHaveBeenCalledWith(id, 1, 3);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("holds the slot two frames of a slow display, never less than the floor", async () => {
+		expect(sharedSlotHoldMs(60)).toBe(SHARED_SLOT_RELEASE_DELAY_MS);
+		expect(sharedSlotHoldMs(144)).toBe(SHARED_SLOT_RELEASE_DELAY_MS);
+		expect(sharedSlotHoldMs(30)).toBe(67);
+		expect(sharedSlotHoldMs(null)).toBe(SHARED_SLOT_RELEASE_DELAY_MS);
+		expect(sharedSlotHoldMs(0)).toBe(SHARED_SLOT_RELEASE_DELAY_MS);
+
+		vi.useFakeTimers();
+		try {
+			const { addon, id, releaseEverywhere, service } = setup({ displayHz: 30 });
+			await service.readFrame(id, 0, target);
+			releaseEverywhere();
+			vi.advanceTimersByTime(66);
+			expect(addon.releaseSharedFrame).not.toHaveBeenCalled();
+			vi.advanceTimersByTime(1);
+			expect(addon.releaseSharedFrame).toHaveBeenCalledWith(id, 1, 3);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("holds every frame in flight on its own clock, so none of them loses its slot", async () => {
+		vi.useFakeTimers();
+		try {
+			const frames = [
+				{ ...sharedFrame, gen: 3, slot: 1 },
+				{ ...sharedFrame, gen: 4, slot: 2 },
+			];
+			const { addon, id, service, sharedTexture } = setup({
+				addon: { readSharedFrame: vi.fn(() => frames.shift() ?? null) },
+			});
+			const released: Array<() => void> = [];
+			sharedTexture.importSharedTexture.mockImplementation((options) => {
+				released.push(options.allReferencesReleased as () => void);
+				return { release: vi.fn() } as unknown as Electron.SharedTextureImported;
+			});
+			await service.readFrame(id, 0, target);
+			await service.readFrame(id, 3, target);
+
+			released[0]();
+			vi.advanceTimersByTime(20);
+			released[1]();
+			vi.advanceTimersByTime(SHARED_SLOT_RELEASE_DELAY_MS - 20);
+			expect(addon.releaseSharedFrame).toHaveBeenCalledTimes(1);
+			expect(addon.releaseSharedFrame).toHaveBeenLastCalledWith(id, 1, 3);
+			vi.advanceTimersByTime(20);
+			expect(addon.releaseSharedFrame).toHaveBeenLastCalledWith(id, 2, 4);
+		} finally {
+			vi.useRealTimers();
+		}
 	});
 
 	it("goes back to read-back when a delivery fails", async () => {