fix(editor): prevent transport button desync and boundary pause during replay

When replaying a timeline from the end boundary, starting playback
could trigger spurious pause events before the rewind seek completes,
causing the transport play/pause icon to momentarily flip from play to
pause and back to play (leaving the UI desynchronized from actual
playback).

1. In VirtualPreview, guard the playback rAF tick against checking clip
   boundaries and kept segments while the video element is seeking or
   has a programmatic seek in flight, and clear the programmatic seek
   flag upon seeked.
2. In NewEditorShell onEnded, verify that the playhead is genuinely at
   the timeline end before marking playback as stopped.
3. In NewEditorShell togglePlay, rewind the playhead to 0 before
   starting playback when stopped at or past the timeline duration.

Author: bet4it

src/components/ai-edition/NewEditorShell.tsx

@@ -49,6 +49,7 @@ import {
 	trimAppliesToClip,
 	ventilateTimelineSpanToTrims,
 } from "@/lib/ai-edition/timeline/trim-mapping";
+import { totalVirtualDuration } from "@/lib/ai-edition/timeline/virtual-preview";
 import { firstTimelineBusyView } from "@/lib/ai-edition/transcription/status";
 import { matchesShortcut } from "@/lib/shortcuts";
 import { nativeBridgeClient } from "@/native";
@@ -615,8 +616,10 @@ export function NewEditorShell() {
 		// vérité pour "y a-t-il encore de la timeline à jouer".
 		const onEnded = () => {
 			const playhead = useProjectStore.getState().currentTimeSec;
+			const duration = totalVirtualDuration(clipsForEndedRef.current);
+			const isAtEnd = duration > 0 && playhead >= duration - 0.1;
 			const hasNextClip = clipsForEndedRef.current.some((c) => c.timelineStartSec > playhead + 0.1);
-			if (!hasNextClip) setPlaying(false);
+			if (isAtEnd && !hasNextClip) setPlaying(false);
 		};
 		el.addEventListener("play", onPlay);
 		el.addEventListener("pause", onPause);
@@ -634,6 +637,11 @@ export function NewEditorShell() {
 	const togglePlay = useCallback(() => {
 		if (!videoElement) return;
 		if (videoElement.paused) {
+			const playhead = useProjectStore.getState().currentTimeSec;
+			const duration = totalVirtualDuration(clipsForEndedRef.current);
+			if (duration > 0 && playhead >= duration) {
+				handleSeek(0);
+			}
 			// Same catch as VirtualPreview's: `play()` rejects on the autoplay policy
 			// or when a new load interrupts it, and the store's `playing` flag is
 			// driven by the element's own play/pause listeners above — so a rejection
@@ -644,7 +652,7 @@ export function NewEditorShell() {
 		} else {
 			videoElement.pause();
 		}
-	}, [videoElement]);
+	}, [videoElement, handleSeek]);
 
 	// "Transcribe now" from the transcript pane. The run itself belongs to the
 	// transcription store (it owns the queue, the toasts and the failure

src/components/ai-edition/VirtualPreview.playback.test.tsx

@@ -790,4 +790,35 @@ describe("VirtualPreview replay", () => {
 		expect(video.currentTime).toBe(0);
 		expect(element.paused).toBe(false);
 	});
+
+	it("does not pause or cancel playback while a replay seek is in flight", () => {
+		const { video, element, onTimeChange } = mount([clip("clip_1", "a1", 2, 4, 0)]);
+		video.play();
+		video.seekTo(3.96);
+		tick();
+		tick();
+		expect(element.paused).toBe(true);
+		const initialPauseCalls = video.pauseCalls.length;
+
+		let seeking = true;
+		Object.defineProperty(element, "seeking", { configurable: true, get: () => seeking });
+
+		act(() => {
+			video.play();
+			fireEvent.play(element);
+		});
+		// While seek is in flight across ticks, boundary check must not pause:
+		tick();
+		expect(element.paused).toBe(false);
+		expect(video.pauseCalls.length).toBe(initialPauseCalls);
+
+		// Demuxer finishes seeking to target:
+		seeking = false;
+		act(() => fireEvent.seeked(element));
+		tick();
+		expect(element.paused).toBe(false);
+		expect(video.pauseCalls.length).toBe(initialPauseCalls);
+		expect(video.currentTime).toBe(2);
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(0);
+	});
 });

src/components/ai-edition/VirtualPreview.tsx

@@ -1171,10 +1171,25 @@ export function VirtualPreview({
 			// position rather than jumping. Note this cannot ride on `v.paused`,
 			// the gate the rest of the tick uses — an `error` does not fire
 			// `pause`, so a failure mid-playback leaves `paused` false.
-			if (recoveringRef.current) {
+			if (recoveringRef.current || v.seeking) {
 				return;
 			}
 			const activeSourceId = videoSourcesRef.current[sourceIndexRef.current]?.id;
+			if (isProgrammaticSeekRef.current) {
+				isProgrammaticSeekRef.current = false;
+				const pos = locateSourcePosition(
+					clipsRef.current,
+					v.currentTime,
+					activeSourceId,
+					0.05,
+					activeClipIdRef.current ?? undefined,
+				);
+				if (pos) {
+					activeClipIdRef.current = pos.clip.id;
+					updateVirtualTime(clampVirtualTime(clipsRef.current, pos.virtualTimeSec));
+				}
+				return;
+			}
 			// Trims only trim ahead during actual playback — scrubbing/paused seeks are
 			// intentionally NOT clamped, so the user can navigate freely into a trim while
 			// editing; only Play/export treats it as a cut (mirrors the pre-existing intent
@@ -1290,21 +1305,6 @@ export function VirtualPreview({
 				updateVirtualTime(v.currentTime);
 				return;
 			}
-			if (isProgrammaticSeekRef.current) {
-				isProgrammaticSeekRef.current = false;
-				const pos = locateSourcePosition(
-					clipsRef.current,
-					v.currentTime,
-					activeSourceId,
-					0.05,
-					activeClipIdRef.current ?? undefined,
-				);
-				if (pos) {
-					activeClipIdRef.current = pos.clip.id;
-					updateVirtualTime(clampVirtualTime(clipsRef.current, pos.virtualTimeSec));
-				}
-				return;
-			}
 			const position = locateSourcePosition(
 				clipsRef.current,
 				v.currentTime,
@@ -1739,6 +1739,7 @@ export function VirtualPreview({
 								}
 							}}
 							onSeeked={(e) => {
+								isProgrammaticSeekRef.current = false;
 								// The demuxer is free again: apply the newest target that
 								// arrived while it was busy, if the playhead has moved on.
 								const queued = pendingScrubTargetRef.current;