From 7252406cd72afcbad3fa5079bc44b13ada9b79f8 Mon Sep 17 00:00:00 2001
From: baiqing <lbx12309@icloud.com>
Date: Sun, 9 Aug 2026 14:44:24 +0800
Subject: [PATCH 1/4] fix(release): keep publish checkout bytecode-free

---
 .github/workflows/release.yml          |  1 +
 scripts/check_release_workflow.py      |  5 ++++-
 scripts/test_check_release_workflow.py | 21 +++++++++++++++++++++
 3 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 630a9d0a..7d6036e7 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -636,6 +636,7 @@ jobs:
       RELEASE_SHA: ${{ needs.validate.outputs.source_sha }}
       RELEASE_VERSION: ${{ needs.validate.outputs.version }}
       NOTES_PATH: ${{ needs.validate.outputs.notes_path }}
+      PYTHONDONTWRITEBYTECODE: '1'
     steps:
       - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
         with:
diff --git a/scripts/check_release_workflow.py b/scripts/check_release_workflow.py
index f9cdafa8..a69ce11c 100644
--- a/scripts/check_release_workflow.py
+++ b/scripts/check_release_workflow.py
@@ -190,7 +190,7 @@
     "quality": "43599825f68088f3cc744220227267f77454e2c7ce389a52b8aee5a492491eec",
     "macos_arm64": "f913508e4f041614a967f680515cc0b8779800f0b2a7b4b6ff29f24f4bb1efd2",
     "windows_x64": "5f012278c20843ba1b38cffb27f3c614716bd92e3fec63a11885b41692be78b5",
-    "publish": "dd325630c78f236e972ca425ccc83018d12b4ec35a6b8a80d1af94990c8179a2",
+    "publish": "89192ac021d48cc8c8ef17b612a2da666d96c01d195c4e2b58eec24b2cc24d1b",
 }
 
 
@@ -969,6 +969,9 @@ def validate_workflow(workflow: str) -> list[str]:
         return list(dict.fromkeys(errors))
     if publish.get("permissions") != {"contents": "write"}:
         errors.append("publish-only contents write permission")
+    publish_env = _as_mapping(publish.get("env"))
+    if publish_env is None or publish_env.get("PYTHONDONTWRITEBYTECODE") != "1":
+        errors.append("publish Python helpers cannot write bytecode into the checkout")
     initialize_publish = _structured_step(publish, "Initialize isolated publish root")
     download_macos = _structured_step(publish, "Download macOS artifact")
     download_windows = _structured_step(publish, "Download Windows artifact")
diff --git a/scripts/test_check_release_workflow.py b/scripts/test_check_release_workflow.py
index 1beb6184..7c2198f0 100644
--- a/scripts/test_check_release_workflow.py
+++ b/scripts/test_check_release_workflow.py
@@ -334,6 +334,27 @@ def test_publish_outputs_must_stay_outside_the_worktree(self) -> None:
         )
         self.assert_rejected(mutated, "publish outputs stay outside the worktree")
 
+    def test_publish_python_helpers_cannot_write_bytecode_into_checkout(self) -> None:
+        protected_env = "      PYTHONDONTWRITEBYTECODE: '1'\n"
+        if protected_env in WORKFLOW:
+            protected = WORKFLOW
+        else:
+            protected = self.mutate(
+                "      NOTES_PATH: ${{ needs.validate.outputs.notes_path }}\n",
+                "      NOTES_PATH: ${{ needs.validate.outputs.notes_path }}\n"
+                + protected_env,
+            )
+        unprotected = protected.replace(protected_env, "", 1)
+
+        self.assertNotIn(
+            "publish Python helpers cannot write bytecode into the checkout",
+            contract.validate_workflow(protected),
+        )
+        self.assert_rejected(
+            unprotected,
+            "publish Python helpers cannot write bytecode into the checkout",
+        )
+
     def test_macos_package_command_cannot_be_faked_by_an_echo_string(self) -> None:
         original = (
             "        run: >-\n"

From 39651b39549d68d946aae6ba571ce5d860f97440 Mon Sep 17 00:00:00 2001
From: baiqing <lbx12309@icloud.com>
Date: Sun, 9 Aug 2026 21:34:13 +0800
Subject: [PATCH 2/4] fix(playback): harden source preview and Space transport

---
 docs/architecture/PLAYBACK-ENGINE.md          |  24 ++
 src-tauri/src/playback/commands.rs            |  10 +-
 src-tauri/src/playback/project.rs             | 141 ++++++++-
 src-tauri/src/render.rs                       |  60 +++-
 src-tauri/tests/playback_probe.rs             |  74 +++--
 web/src/components/media/MediaPanel.test.tsx  |   4 +-
 .../preview/Preview.interaction.test.tsx      | 159 +++++++++-
 web/src/components/preview/Preview.test.tsx   |  46 +++
 web/src/components/preview/Preview.tsx        | 289 +++++++++++++++++-
 .../components/preview/RustFrameBuffer.tsx    |   7 +-
 .../preview/nativePlaybackSession.test.ts     |  84 +++++
 .../preview/nativePlaybackSession.ts          |  59 +++-
 web/src/hooks/useKeyboardShortcuts.test.ts    |  91 +++++-
 web/src/hooks/useKeyboardShortcuts.ts         |  32 +-
 web/src/lib/api.ts                            |   3 +
 15 files changed, 1002 insertions(+), 81 deletions(-)

diff --git a/docs/architecture/PLAYBACK-ENGINE.md b/docs/architecture/PLAYBACK-ENGINE.md
index d7ecc36d..320bdc5e 100644
--- a/docs/architecture/PLAYBACK-ENGINE.md
+++ b/docs/architecture/PLAYBACK-ENGINE.md
@@ -32,6 +32,23 @@ surface. Reverse and positive-speed media can remain on this route when no
 compositor-only content is present. This route has no libmpv dependency or
 transparent native-player hole.
 
+## Source-media preview route
+
+The source tab uses the Rust streaming engine whenever the packaged playback
+capability is available. `playback_start(mediaId)` projects the selected video
+into a private one-track timeline at the project fps, then reuses the same
+FFmpeg RGBA decode, compositor, cpal audio clock, exact publication, and
+identity-scoped pause/seek/stop lifecycle as timeline playback. The source
+asset is read directly; this route does not create a whole-file proxy or
+transcode by default.
+
+Paused source frames and paused seeks use `composite_frame(sourceMediaId)` so
+they also decode through FFmpeg instead of switching back to WebKit. A terminal
+frame remains painted, Play rewinds it to frame zero, and selecting another
+asset retires the previous source session before accepting its publications.
+The ordinary `<video>` source preview remains only for the browser shell and a
+minimal build where the native playback capability handshake is unavailable.
+
 ## Rust route and exact publication
 
 Rust continuously decodes, builds the RenderPlan, composites with wgpu, and
@@ -121,6 +138,13 @@ the same project retain valid caches.
   text/color/multi-track Rust project, then switched back across the project
   boundary without retaining the previous duration or playhead. Receipt:
   [playback-route-lifecycle-real-device-2026-08-01.md](../audit/2026-07-14/runtime-artifacts/automated/playback-route-lifecycle-real-device-2026-08-01.md).
+- 2026-08-09 source-preview regression: the production source projection and a
+  seeked native start at frame 1572 decoded the reported 2.5 GB HEVC Main10,
+  yuv420p10le, 3840x2160, ~100 Mbps + PCM asset for three seconds. It published
+  61 frames, advanced to frame 1662, kept the minimum non-black pixel ratio at
+  0.945, and observed zero neon-green corruption. The probe remains ignored by
+  the default workspace gate because it requires that external real-device
+  fixture.
 
 Artifact hashes and the separation between older installed-app evidence and
 fresh detached bundles are recorded in
diff --git a/src-tauri/src/playback/commands.rs b/src-tauri/src/playback/commands.rs
index 43b8c985..3f141b62 100644
--- a/src-tauri/src/playback/commands.rs
+++ b/src-tauri/src/playback/commands.rs
@@ -24,7 +24,7 @@ use super::audio::{
 use super::engine::{
     BoundedReaper, FrameSink, PlaybackClock, PlaybackEngine, PlayheadEmitter, ReapPermit,
 };
-use super::project::{project_media_with_proxies, project_text};
+use super::project::{project_media_with_proxies, project_text, source_preview_timeline};
 use super::session::{
     PlaybackCommandError, PlaybackIdentity, ProjectTransition, SessionControl, SessionRegistry,
     StartDecision, StartTicket,
@@ -543,6 +543,7 @@ pub async fn playback_start(
     app: AppHandle,
     from_frame: i32,
     identity: PlaybackIdentity,
+    media_id: Option<String>,
 ) -> Result<(), PlaybackCommandError> {
     let identity = identity.validate()?;
     let snapshot = app.state::<AppCore>().runtime_snapshot();
@@ -577,9 +578,14 @@ pub async fn playback_start(
         server,
         project_dir,
     ) = {
-        let timeline = snapshot.timeline;
+        let root_timeline = snapshot.timeline;
         let manifest = snapshot.media;
         let project_dir = snapshot.project_dir;
+        let timeline = match media_id.as_deref() {
+            Some(media_id) => source_preview_timeline(&manifest, media_id, root_timeline.fps)
+                .map_err(PlaybackCommandError::engine)?,
+            None => root_timeline,
+        };
         let prefer_proxy = app.state::<crate::media::MediaProxyState>().enabled();
         let (sizes, media) = project_media_with_proxies(&manifest, &project_dir, prefer_proxy);
         let text = project_text(&timeline);
diff --git a/src-tauri/src/playback/project.rs b/src-tauri/src/playback/project.rs
index e73bbbca..ffb20ee1 100644
--- a/src-tauri/src/playback/project.rs
+++ b/src-tauri/src/playback/project.rs
@@ -13,7 +13,7 @@
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 
-use opentake_domain::{ClipType, MediaManifest, MediaSource, TextStyle, Timeline};
+use opentake_domain::{Clip, ClipType, MediaManifest, MediaSource, TextStyle, Timeline, Track};
 use opentake_render::SourceMetrics;
 
 /// Resolvable info for one media asset, projected from the manifest.
@@ -154,6 +154,59 @@ pub fn project_media_with_proxies(
     (sizes, media)
 }
 
+/// Build the one-track render graph used by the source-preview tab. Keeping the
+/// asset on the same FFmpeg -> RGBA -> compositor path as timeline playback
+/// avoids delegating HEVC Main10 / high-bitrate decode to the platform WebView.
+pub fn source_preview_timeline(
+    manifest: &MediaManifest,
+    media_id: &str,
+    project_fps: i32,
+) -> Result<Timeline, String> {
+    let entry = manifest
+        .entries
+        .iter()
+        .find(|entry| entry.id == media_id)
+        .ok_or_else(|| format!("source preview media not found: {media_id}"))?;
+    if entry.kind != ClipType::Video {
+        return Err(format!("source preview asset is not a video: {media_id}"));
+    }
+    if !entry.duration.is_finite() || entry.duration <= 0.0 {
+        return Err(format!(
+            "source preview asset has invalid duration: {}",
+            entry.duration
+        ));
+    }
+
+    let fps = project_fps.max(1);
+    let duration_frames = (entry.duration * f64::from(fps))
+        .trunc()
+        .clamp(1.0, f64::from(i32::MAX)) as i32;
+    let mut timeline = Timeline::new();
+    timeline.fps = fps;
+    timeline.width = entry
+        .source_width
+        .filter(|width| *width > 0)
+        .unwrap_or(1920);
+    timeline.height = entry
+        .source_height
+        .filter(|height| *height > 0)
+        .unwrap_or(1080);
+    timeline.settings_configured = true;
+
+    let mut track = Track::new(format!("source-preview-track-{media_id}"), ClipType::Video);
+    let mut clip = Clip::new(
+        format!("source-preview-clip-{media_id}"),
+        media_id,
+        0,
+        duration_frames,
+    );
+    clip.media_type = ClipType::Video;
+    clip.source_clip_type = ClipType::Video;
+    track.clips.push(clip);
+    timeline.tracks.push(track);
+    Ok(timeline)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -321,4 +374,90 @@ mod tests {
         tl.tracks.push(track);
         assert!(project_text(&tl).is_empty());
     }
+
+    #[test]
+    fn source_preview_builds_a_native_video_timeline_at_project_fps() {
+        let mut manifest = MediaManifest::new();
+        let mut main10 = entry(
+            "main10",
+            MediaSource::External {
+                absolute_path: "/media/main10.mov".into(),
+            },
+            Some((3840, 2160)),
+        );
+        main10.duration = 210.7105;
+        main10.source_fps = Some(30_000.0 / 1_001.0);
+        main10.has_audio = Some(true);
+        manifest.entries.push(main10);
+
+        let timeline = source_preview_timeline(&manifest, "main10", 30)
+            .expect("video source projects into native playback");
+
+        assert_eq!(
+            (timeline.width, timeline.height, timeline.fps),
+            (3840, 2160, 30)
+        );
+        assert_eq!(timeline.total_frames(), 6_321);
+        assert_eq!(timeline.tracks.len(), 1);
+        assert_eq!(timeline.tracks[0].kind, ClipType::Video);
+        let clip = &timeline.tracks[0].clips[0];
+        assert_eq!(clip.media_ref, "main10");
+        assert_eq!(clip.media_type, ClipType::Video);
+        assert_eq!(clip.source_clip_type, ClipType::Video);
+        assert_eq!(clip.duration_frames, 6_321);
+    }
+
+    #[test]
+    fn source_preview_truncates_fractional_terminal_frames() {
+        let mut manifest = MediaManifest::new();
+        let mut video = entry(
+            "fractional",
+            MediaSource::External {
+                absolute_path: "/media/fractional.mov".into(),
+            },
+            Some((1920, 1080)),
+        );
+        video.duration = 1.55;
+        manifest.entries.push(video);
+
+        let timeline = source_preview_timeline(&manifest, "fractional", 30)
+            .expect("fractional source projects into native playback");
+
+        assert_eq!(timeline.total_frames(), 46);
+        assert_eq!(timeline.tracks[0].clips[0].duration_frames, 46);
+    }
+
+    #[test]
+    fn source_preview_rejects_non_video_and_invalid_duration() {
+        let mut manifest = MediaManifest::new();
+        let mut audio = entry(
+            "audio",
+            MediaSource::External {
+                absolute_path: "/media/audio.wav".into(),
+            },
+            None,
+        );
+        audio.kind = ClipType::Audio;
+        manifest.entries.push(audio);
+
+        let mut invalid = entry(
+            "invalid",
+            MediaSource::External {
+                absolute_path: "/media/invalid.mov".into(),
+            },
+            Some((1920, 1080)),
+        );
+        invalid.duration = f64::NAN;
+        manifest.entries.push(invalid);
+
+        assert!(source_preview_timeline(&manifest, "audio", 30)
+            .unwrap_err()
+            .contains("not a video"));
+        assert!(source_preview_timeline(&manifest, "invalid", 30)
+            .unwrap_err()
+            .contains("duration"));
+        assert!(source_preview_timeline(&manifest, "missing", 30)
+            .unwrap_err()
+            .contains("not found"));
+    }
 }
diff --git a/src-tauri/src/render.rs b/src-tauri/src/render.rs
index b51ab3a9..e5b7b214 100644
--- a/src-tauri/src/render.rs
+++ b/src-tauri/src/render.rs
@@ -34,8 +34,8 @@ use tauri::State;
 use opentake_core::{AppCore, EditCommand, ProjectRevision};
 use opentake_domain::{ClipType, LutReference, MediaSource, TextStyle, Timeline};
 use opentake_media::{
-    decode_frame_at, decode_frame_at_cancellable, interpolate_frame_pair,
-    FrameInterpolationFallback, FrameInterpolationMode, FrameRequest, MediaCancelToken,
+    decode_frame_at_cancellable, interpolate_frame_pair, FrameInterpolationFallback,
+    FrameInterpolationMode, FrameRequest, MediaCancelToken,
 };
 use opentake_ops::command::RenameEntry;
 use opentake_project::ProjectRoot;
@@ -84,6 +84,8 @@ pub struct CompositeFrameRequest {
     pub seek_generation: u64,
     #[serde(default)]
     pub sequence_id: Option<String>,
+    #[serde(default)]
+    pub source_media_id: Option<String>,
 }
 
 /// Lazily-acquired GPU device + compositor, cached across composite calls.
@@ -1022,14 +1024,20 @@ pub fn composite_frame(
         request.session_generation,
         request.seek_generation,
     )?;
-    let composite = composite_rgba(
-        &core,
-        &render,
-        request.frame,
-        max_size.unwrap_or(DEFAULT_PREVIEW_CAP),
-        &cancel,
-        request.sequence_id.as_deref(),
-    )?;
+    let preview_cap = max_size.unwrap_or(DEFAULT_PREVIEW_CAP);
+    let composite = match request.source_media_id.as_deref() {
+        Some(media_id) => {
+            decode_source_frame(&core, media_id, request.frame, preview_cap, &cancel)?
+        }
+        None => composite_rgba(
+            &core,
+            &render,
+            request.frame,
+            preview_cap,
+            &cancel,
+            request.sequence_id.as_deref(),
+        )?,
+    };
     if cancel.is_cancelled()
         || core.project_revision() != revision
         || !render.preview.is_current(
@@ -1142,7 +1150,7 @@ fn capture_frame_to_media_workflow(
     // Frame → RGBA. Timeline tab composites; video tab decodes the source frame.
     let composite = match source_media_id {
         None => composite_rgba(core, render, frame, 0, &MediaCancelToken::new(), None)?,
-        Some(id) => decode_source_frame(core, id, frame)?,
+        Some(id) => decode_source_frame(core, id, frame, 0, &MediaCancelToken::new())?,
     };
 
     // Write the PNG next to the media cache so a subsequent project save can copy
@@ -1187,7 +1195,13 @@ fn capture_frame_to_media_workflow(
 /// nil` raw-asset path). The frame → time uses the TIMELINE fps, matching
 /// upstream's `CMTime(value: frame, timescale: fps)` (fps = timeline fps for both
 /// tabs). Errors when the asset is unknown, not a video, or its source is offline.
-fn decode_source_frame(core: &AppCore, media_id: &str, frame: i32) -> Result<DecodedFrame, String> {
+fn decode_source_frame(
+    core: &AppCore,
+    media_id: &str,
+    frame: i32,
+    max_size: u32,
+    cancel: &MediaCancelToken,
+) -> Result<DecodedFrame, String> {
     let snapshot = core.runtime_snapshot();
     let timeline = snapshot.timeline;
     let manifest = snapshot.media;
@@ -1212,11 +1226,11 @@ fn decode_source_frame(core: &AppCore, media_id: &str, frame: i32) -> Result<Dec
     let fps = if timeline.fps > 0 { timeline.fps } else { 30 };
     let req = FrameRequest {
         time_secs: (frame.max(0) as f64) / fps as f64,
-        max_size: (0, 0), // full resolution
+        max_size: (max_size, max_size),
         ..FrameRequest::default()
     };
-    let (_, rgba) =
-        decode_frame_at(&path, &req).map_err(|e| format!("decode source frame: {e}"))?;
+    let (_, rgba) = decode_frame_at_cancellable(&path, &req, cancel)
+        .map_err(|e| format!("decode source frame: {e}"))?;
     Ok(DecodedFrame::new(rgba.width, rgba.height, rgba.rgba, false))
 }
 
@@ -1366,6 +1380,22 @@ fn project_frame_time_secs(source_frame: i64, timeline_fps: i32) -> f64 {
 mod tests {
     use super::*;
 
+    #[test]
+    fn composite_request_can_target_a_single_source_asset() {
+        let request: CompositeFrameRequest = serde_json::from_value(serde_json::json!({
+            "frame": 1572,
+            "projectEpoch": 3,
+            "timelineVersion": 7,
+            "sessionId": "source-still",
+            "sessionGeneration": 1,
+            "seekGeneration": 4,
+            "sourceMediaId": "main10"
+        }))
+        .expect("source still request decodes");
+
+        assert_eq!(request.source_media_id.as_deref(), Some("main10"));
+    }
+
     #[test]
     fn preview_composite_cancel_floor_kills_old_work_but_not_its_successor() {
         let coordinator = PreviewCompositeCoordinator::default();
diff --git a/src-tauri/tests/playback_probe.rs b/src-tauri/tests/playback_probe.rs
index 56b2f691..2deaa22e 100644
--- a/src-tauri/tests/playback_probe.rs
+++ b/src-tauri/tests/playback_probe.rs
@@ -31,10 +31,13 @@ use std::sync::atomic::{AtomicI32, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use opentake_domain::{Clip, ClipType, Timeline, Track};
+use opentake_domain::{
+    Clip, ClipType, MediaManifest, MediaManifestEntry, MediaSource, Timeline, Track,
+};
 use opentake_render::{DecodedFrame, RenderSize};
+use opentake_tauri_lib::playback::project::source_preview_timeline;
 use opentake_tauri_lib::playback::{
-    audio::build_clock_paused, FrameSink, MediaInfo, PlaybackEngine, PlayheadEmitter,
+    audio::build_clock_paused, project_media, FrameSink, MediaInfo, PlaybackEngine, PlayheadEmitter,
 };
 
 #[derive(Clone, Debug)]
@@ -100,10 +103,20 @@ fn run_engine(
     media: HashMap<String, MediaInfo>,
     sizes: HashMap<String, (u32, u32)>,
     secs: f64,
+) -> (i32, i32, Option<DecodedFrame>, bool, FrameQuality) {
+    run_engine_from(timeline, media, sizes, 0, secs)
+}
+
+fn run_engine_from(
+    timeline: Timeline,
+    media: HashMap<String, MediaInfo>,
+    sizes: HashMap<String, (u32, u32)>,
+    start_frame: i32,
+    secs: f64,
 ) -> (i32, i32, Option<DecodedFrame>, bool, FrameQuality) {
     let fps = timeline.fps;
-    let (clock, audio) =
-        build_clock_paused(&timeline, &media, fps, 0).expect("probe prepared audio clock");
+    let (clock, audio) = build_clock_paused(&timeline, &media, fps, start_frame)
+        .expect("probe prepared audio clock");
     let audio_active = audio.is_some();
     let sink = Arc::new(ProbeSink {
         frames: AtomicI32::new(0),
@@ -122,7 +135,7 @@ fn run_engine(
         clock,
         sink.clone(),
         emitter.clone(),
-        0,
+        start_frame,
     )
     .expect("engine ready (GPU acquire + first frame)");
     if let Some(audio) = audio.as_ref() {
@@ -130,7 +143,7 @@ fn run_engine(
             .prepare_resume()
             .expect("prepared audio callback resumes muted");
     }
-    engine.resume(0).expect("prepared engine resumes");
+    engine.resume(start_frame).expect("prepared engine resumes");
     if let Some(audio) = audio.as_ref() {
         audio.commit_resume();
     }
@@ -275,28 +288,32 @@ fn probe_main10_playback_has_no_black_or_green_frames() {
         "Main10 probe window exceeds source duration"
     );
 
-    let mut timeline = Timeline::new();
-    timeline.fps = 30;
-    timeline.width = 1920;
-    timeline.height = 1080;
-    let mut track = Track::new("t-v1", ClipType::Video);
-    let mut clip = video_clip("c-1", "m-1", 0, 300);
-    clip.trim_start_frame = trim_start_frame;
-    track.clips.push(clip);
-    timeline.tracks.push(track);
-
-    let mut media = HashMap::new();
-    media.insert(
-        "m-1".to_string(),
-        MediaInfo {
-            path: src,
-            straight_alpha: false,
+    let mut manifest = MediaManifest::new();
+    manifest.entries.push(MediaManifestEntry {
+        id: "m-1".into(),
+        name: "Main10.mov".into(),
+        kind: ClipType::Video,
+        source: MediaSource::External {
+            absolute_path: src.to_string_lossy().into_owned(),
         },
-    );
-    let mut sizes = HashMap::new();
-    sizes.insert("m-1".to_string(), source_size);
+        duration: probe.duration_secs,
+        generation_input: None,
+        source_width: Some(source_size.0 as i32),
+        source_height: Some(source_size.1 as i32),
+        source_fps: Some(source_fps),
+        has_audio: Some(true),
+        color: probe.color,
+        proxy: None,
+        folder_id: None,
+        cached_remote_url: None,
+        cached_remote_url_expires_at: None,
+    });
+    let timeline = source_preview_timeline(&manifest, "m-1", 30)
+        .expect("Main10 source projects through the production preview seam");
+    let (sizes, media) = project_media(&manifest, &None);
 
-    let (frames, playhead, _last, _audio_active, quality) = run_engine(timeline, media, sizes, 3.0);
+    let (frames, playhead, _last, _audio_active, quality) =
+        run_engine_from(timeline, media, sizes, trim_start_frame, 3.0);
     eprintln!(
         "[probe] Main10 frames={frames} playhead={playhead} min_nonblack={:.3} max_neon_green={:.3}",
         quality.min_nonblack_ratio, quality.max_neon_green_ratio
@@ -305,7 +322,10 @@ fn probe_main10_playback_has_no_black_or_green_frames() {
         frames > 1,
         "Main10 playback did not publish consecutive frames"
     );
-    assert!(playhead > 0, "Main10 playback playhead did not advance");
+    assert!(
+        playhead > trim_start_frame,
+        "Main10 source-preview seek did not advance: {playhead}"
+    );
     assert!(
         quality.min_nonblack_ratio > 0.01,
         "Main10 playback published a black frame (minimum nonblack ratio {:.4})",
diff --git a/web/src/components/media/MediaPanel.test.tsx b/web/src/components/media/MediaPanel.test.tsx
index 06b8b462..53edef11 100644
--- a/web/src/components/media/MediaPanel.test.tsx
+++ b/web/src/components/media/MediaPanel.test.tsx
@@ -800,7 +800,7 @@ describe("media grid interaction consistency", () => {
     await act(async () => root.unmount());
   });
 
-  it("lets a focused media card own Space instead of toggling transport", async () => {
+  it("lets global transport own Space while a media card is focused", async () => {
     const requestMediaPreviewToggle = vi.fn();
     useEditorUiStore.setState({
       view: "editor",
@@ -855,7 +855,7 @@ describe("media grid interaction consistency", () => {
       ),
     );
 
-    expect(requestMediaPreviewToggle).not.toHaveBeenCalled();
+    expect(requestMediaPreviewToggle).toHaveBeenCalledOnce();
     expect(useEditorUiStore.getState().previewMediaId).toBe("asset-a");
     expect([...useEditorUiStore.getState().selectedMediaAssetIds]).toEqual(["asset-a"]);
     await act(async () => root.unmount());
diff --git a/web/src/components/preview/Preview.interaction.test.tsx b/web/src/components/preview/Preview.interaction.test.tsx
index 845e39dd..0b03b83a 100644
--- a/web/src/components/preview/Preview.interaction.test.tsx
+++ b/web/src/components/preview/Preview.interaction.test.tsx
@@ -5,7 +5,17 @@ import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import type { MediaItem } from "../../lib/types";
 import { useEditorUiStore } from "../../store/uiStore";
-import { BadgeMenu, exactTimelineFrame, PreviewTabs, ScrubBar } from "./Preview";
+import {
+  BadgeMenu,
+  exactTimelineFrame,
+  NativeSourcePlaybackSurface,
+  PreviewTabs,
+  retireSourcePlaybackStart,
+  ScrubBar,
+  sourceDurationFrames,
+  sourcePreviewFrame,
+  sourcePlaybackStartFrame,
+} from "./Preview";
 
 (globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT: boolean })
   .IS_REACT_ACT_ENVIRONMENT = true;
@@ -23,6 +33,44 @@ it("normalizes fractional playback ticks before exact frame stepping", () => {
   expect(exactTimelineFrame(100.6, 100)).toBe(100);
 });
 
+it("rewinds a completed source preview and otherwise resumes its exact frame", () => {
+  expect(sourcePlaybackStartFrame(42, 100)).toBe(42);
+  expect(sourcePlaybackStartFrame(99, 100)).toBe(0);
+  expect(sourcePlaybackStartFrame(120, 100)).toBe(0);
+});
+
+it("keeps source still requests on the last decodable frame", () => {
+  expect(sourcePreviewFrame(42, 100)).toBe(42);
+  expect(sourcePreviewFrame(100, 100)).toBe(99);
+  expect(sourcePreviewFrame(120, 100)).toBe(99);
+});
+
+it("truncates fractional source durations at the terminal frame", () => {
+  expect(sourceDurationFrames(1.55, 30)).toBe(46);
+  expect(sourceDurationFrames(Number.NaN, 30)).toBe(0);
+});
+
+it("invalidates a pending source start before its deferred completion", async () => {
+  const generation = { current: 3 };
+  const starting = { current: true };
+  const pendingToken = generation.current;
+  let release!: () => void;
+  let committed = false;
+  const completion = new Promise<void>((resolve) => {
+    release = resolve;
+  }).then(() => {
+    if (pendingToken === generation.current) committed = true;
+  });
+
+  retireSourcePlaybackStart(generation, starting);
+  release();
+  await completion;
+
+  expect(generation.current).toBe(4);
+  expect(starting.current).toBe(false);
+  expect(committed).toBe(false);
+});
+
 beforeEach(() => {
   onSeek = vi.fn();
   onExactSeek = vi.fn();
@@ -161,6 +209,115 @@ it("gives preview tabs a connected tablist and roving keyboard behavior", async
   expect(document.activeElement).toBe(tabs[0]);
 });
 
+it("requests latest-only FFmpeg source stills for paused source seek", async () => {
+  const requestSourceFrame = vi.fn().mockResolvedValue({
+    width: 1280,
+    height: 720,
+    dataUrl: "data:image/png;base64,source",
+  });
+  const item: MediaItem = {
+    id: "main10",
+    name: "Main10",
+    type: "video",
+    duration: 210.7105,
+    width: 3840,
+    height: 2160,
+    hasAudio: true,
+    favorite: false,
+  };
+  const renderFrame = (frame: number) => (
+    <NativeSourcePlaybackSurface
+      item={item}
+      event={null}
+      endpoint="http://127.0.0.1/frame"
+      projectEpoch={3}
+      timelineVersion={7}
+      playing={false}
+      frame={frame}
+      previewQualityShortEdge={720}
+      onPlayingChange={vi.fn()}
+      onTerminalFailure={vi.fn()}
+      requestSourceFrame={requestSourceFrame}
+      cancelSourceFrame={vi.fn().mockResolvedValue(undefined)}
+    />
+  );
+
+  await act(async () => {
+    root.render(renderFrame(1_572));
+    await Promise.resolve();
+  });
+  await act(async () => {
+    root.render(renderFrame(1_600));
+    await Promise.resolve();
+  });
+
+  expect(requestSourceFrame.mock.calls.map(([request]) => request)).toEqual([
+    expect.objectContaining({ frame: 1_572, sourceMediaId: "main10" }),
+    expect.objectContaining({ frame: 1_600, sourceMediaId: "main10" }),
+  ]);
+  expect(requestSourceFrame).toHaveBeenLastCalledWith(
+    expect.objectContaining({ frame: 1_600, sourceMediaId: "main10" }),
+    1280,
+  );
+});
+
+it("drops the previous source still while the replacement source decodes", async () => {
+  const item = (id: string): MediaItem => ({
+    id,
+    name: id,
+    type: "video",
+    duration: 10,
+    width: 1920,
+    height: 1080,
+    hasAudio: true,
+    favorite: false,
+  });
+  const requestSourceFrame = vi.fn(
+    (request: { sourceMediaId?: string }) =>
+      request.sourceMediaId === "source-a"
+        ? Promise.resolve({
+            width: 1280,
+            height: 720,
+            dataUrl: "data:image/png;base64,source-a",
+          })
+        : new Promise<never>(() => undefined),
+  );
+  const renderSource = (id: string) => (
+    <NativeSourcePlaybackSurface
+      item={item(id)}
+      event={null}
+      endpoint="http://127.0.0.1/frame"
+      projectEpoch={3}
+      timelineVersion={7}
+      playing={false}
+      frame={12}
+      previewQualityShortEdge={720}
+      onPlayingChange={vi.fn()}
+      onTerminalFailure={vi.fn()}
+      requestSourceFrame={requestSourceFrame}
+      cancelSourceFrame={vi.fn().mockResolvedValue(undefined)}
+    />
+  );
+
+  await act(async () => {
+    root.render(renderSource("source-a"));
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+  expect(
+    container.querySelector<HTMLImageElement>("[data-testid='rust-idle-composite-still']")
+      ?.src,
+  ).toContain("source-a");
+
+  await act(async () => {
+    root.render(renderSource("source-b"));
+    await Promise.resolve();
+  });
+  expect(
+    container.querySelector<HTMLImageElement>("[data-testid='rust-idle-composite-still']"),
+  ).toBeNull();
+});
+
 it("moves focus through BadgeMenu listbox options and restores it on Escape", async () => {
   const selected = vi.fn();
   await act(async () =>
diff --git a/web/src/components/preview/Preview.test.tsx b/web/src/components/preview/Preview.test.tsx
index 6cefcd98..5f08ce01 100644
--- a/web/src/components/preview/Preview.test.tsx
+++ b/web/src/components/preview/Preview.test.tsx
@@ -435,6 +435,52 @@ describe("Preview timeline rendering", () => {
     expect(html).toContain("pointer-events:none");
   });
 
+  it("routes a source video through the native frame surface when available", () => {
+    store.ui.previewMediaId = "base";
+    store.media.items = [
+      {
+        id: "base",
+        name: "Main10",
+        type: "video",
+        duration: 210.7105,
+        width: 3840,
+        height: 2160,
+        hasAudio: true,
+        path: "/main10.mov",
+      },
+    ];
+
+    const html = renderToStaticMarkup(<Preview />);
+
+    expect(html).toContain('data-source-playback-surface="native"');
+    expect(html.match(/data-rust-frame-slot=/g)).toHaveLength(2);
+    expect(html).not.toContain("<video");
+    expect(html).not.toContain("asset:///main10.mov");
+  });
+
+  it("retains the WebKit source fallback when native playback is unavailable", () => {
+    store.playbackCapability = { checked: true, available: false, endpoint: null };
+    store.ui.previewMediaId = "base";
+    store.media.items = [
+      {
+        id: "base",
+        name: "portable",
+        type: "video",
+        duration: 3,
+        width: 1920,
+        height: 1080,
+        hasAudio: true,
+        path: "/portable.mp4",
+      },
+    ];
+
+    const html = renderToStaticMarkup(<Preview />);
+
+    expect(html).not.toContain('data-source-playback-surface="native"');
+    expect(html).toContain("<video");
+    expect(html).toContain("asset:///portable.mp4");
+  });
+
   // Note: only the NEGATIVE guard cases are provable here. `renderToStaticMarkup`
   // never runs `useEffect`, so the ResizeObserver that measures `stageSize` (and
   // therefore `fittedCanvas`, Preview.tsx:156) never fires — `fittedCanvas` is
diff --git a/web/src/components/preview/Preview.tsx b/web/src/components/preview/Preview.tsx
index 32996694..4978b9f9 100644
--- a/web/src/components/preview/Preview.tsx
+++ b/web/src/components/preview/Preview.tsx
@@ -65,8 +65,12 @@ import {
   type QualityPreset,
   type ZoomPreset,
 } from "../../lib/previewPresets";
-import type { MediaItem } from "../../lib/types";
-import { useNativePlaybackPublication } from "./nativePlaybackSession";
+import type { MediaItem, PlaybackIdentity } from "../../lib/types";
+import {
+  nativePlaybackController,
+  samePlaybackIdentity,
+  useNativePlaybackPublication,
+} from "./nativePlaybackSession";
 import {
   isRetryableRustPlaybackFailure,
   resolveTimelinePlaybackRoute,
@@ -83,6 +87,30 @@ export function exactTimelineFrame(frame: number, total: number): number {
   return Math.max(0, Math.min(safeTotal, rounded));
 }
 
+export function sourcePreviewFrame(frame: number, totalFrames: number): number {
+  const safeTotal = Math.max(1, Math.round(Number.isFinite(totalFrames) ? totalFrames : 1));
+  return exactTimelineFrame(frame, safeTotal - 1);
+}
+
+export function sourceDurationFrames(durationSeconds: number, fps: number): number {
+  if (!Number.isFinite(durationSeconds) || !Number.isFinite(fps)) return 0;
+  return Math.max(0, Math.trunc(Math.max(0, durationSeconds) * Math.max(1, fps)));
+}
+
+export function retireSourcePlaybackStart(
+  generation: { current: number },
+  starting: { current: boolean },
+): void {
+  generation.current += 1;
+  starting.current = false;
+}
+
+export function sourcePlaybackStartFrame(currentFrame: number, totalFrames: number): number {
+  const safeTotal = Math.max(1, Math.round(Number.isFinite(totalFrames) ? totalFrames : 1));
+  const current = sourcePreviewFrame(currentFrame, safeTotal);
+  return current >= safeTotal - 1 ? 0 : current;
+}
+
 export function Preview() {
   const t = useT();
   const rootTimeline = useProjectStore((s) => s.timeline);
@@ -106,6 +134,7 @@ export function Preview() {
     (s) => s.setWebkitPlaybackFailedRevision,
   );
   const setScrubbing = useEditorUiStore((s) => s.setScrubbing);
+  const setTimelinePlaying = useEditorUiStore((s) => s.setPlaying);
   const togglePlayTimeline = useEditorUiStore((s) => s.togglePlay);
   const previewMediaId = useEditorUiStore((s) => s.previewMediaId);
   const selectedClipIds = useEditorUiStore((s) => s.selectedClipIds);
@@ -167,6 +196,11 @@ export function Preview() {
   const [mediaTime, setMediaTime] = useState(0);
   const [mediaDuration, setMediaDuration] = useState(0);
   const [mediaPlaying, setMediaPlaying] = useState(false);
+  const [sourcePlaybackIdentity, setSourcePlaybackIdentity] =
+    useState<PlaybackIdentity | null>(null);
+  const sourcePlaybackIdentityRef = useRef<PlaybackIdentity | null>(null);
+  const sourcePlaybackStartingRef = useRef(false);
+  const sourcePlaybackGenerationRef = useRef(0);
   const nativeFrameEvent = useNativePlaybackPublication();
   const rustPlaybackCapability = useRustPlaybackCapability();
   const previewFrameEndpoint = rustPlaybackCapability.endpoint;
@@ -176,9 +210,21 @@ export function Preview() {
   const canvasBoxRef = useRef<HTMLDivElement | null>(null);
   const [stageSize, setStageSize] = useState({ width: 0, height: 0 });
   useEffect(() => {
+    retireSourcePlaybackStart(sourcePlaybackGenerationRef, sourcePlaybackStartingRef);
+    mediaRef.current?.pause();
+    mediaRef.current = null;
     setMediaTime(0);
-    setMediaDuration(0);
+    setMediaDuration(Math.max(0, previewItem?.duration ?? 0));
     setMediaPlaying(false);
+    const identity = sourcePlaybackIdentityRef.current;
+    sourcePlaybackIdentityRef.current = null;
+    setSourcePlaybackIdentity(null);
+    if (identity) void nativePlaybackController.stop(identity).catch(() => undefined);
+    return () => {
+      const current = sourcePlaybackIdentityRef.current;
+      sourcePlaybackIdentityRef.current = null;
+      if (current) void nativePlaybackController.stop(current).catch(() => undefined);
+    };
   }, [previewMediaId]);
   useEffect(() => {
     const el = stageRef.current;
@@ -218,10 +264,48 @@ export function Preview() {
   }, [mediaToggleCount]);
 
   const previewing = previewItem !== null;
+  const nativeSourcePreview =
+    previewItem?.type === "video" &&
+    !previewItem.missing &&
+    rustPlaybackCapability.available;
+  useEffect(() => {
+    retireSourcePlaybackStart(sourcePlaybackGenerationRef, sourcePlaybackStartingRef);
+    const identity = sourcePlaybackIdentityRef.current;
+    sourcePlaybackIdentityRef.current = null;
+    setSourcePlaybackIdentity(null);
+    setMediaPlaying(false);
+    if (identity) void nativePlaybackController.stop(identity).catch(() => undefined);
+  }, [projectEpoch, timelineVersion]);
+  useEffect(() => {
+    if (nativeSourcePreview) {
+      // Capability discovery can replace a briefly-mounted WebKit fallback.
+      // Never carry its playing state into a native surface with no session.
+      if (!sourcePlaybackIdentityRef.current) setMediaPlaying(false);
+      return;
+    }
+    retireSourcePlaybackStart(sourcePlaybackGenerationRef, sourcePlaybackStartingRef);
+    const identity = sourcePlaybackIdentityRef.current;
+    sourcePlaybackIdentityRef.current = null;
+    setSourcePlaybackIdentity(null);
+    if (identity) {
+      setMediaPlaying(false);
+      void nativePlaybackController.stop(identity).catch(() => undefined);
+    }
+  }, [nativeSourcePreview]);
   const timelineHasContent = !previewing && timeline.tracks.length > 0;
   const fps = timeline.fps;
+  const sourceNativeFrameEvent =
+    sourcePlaybackIdentity &&
+    nativeFrameEvent &&
+    samePlaybackIdentity(sourcePlaybackIdentity, nativeFrameEvent)
+      ? nativeFrameEvent
+      : null;
+  useEffect(() => {
+    if (!nativeSourcePreview || !sourceNativeFrameEvent) return;
+    setMediaTime(sourceNativeFrameEvent.frame / Math.max(1, fps));
+  }, [fps, nativeSourcePreview, sourceNativeFrameEvent]);
   const total = previewing
-    ? Math.max(0, Math.round(mediaDuration * fps))
+    ? sourceDurationFrames(mediaDuration, fps)
     : totalFrames(timeline);
   const activeShownFrame = previewing ? Math.round(mediaTime * fps) : activeFrame;
   const playing = previewing ? mediaPlaying : isPlaying;
@@ -249,10 +333,20 @@ export function Preview() {
   );
 
   const seekTo = (frame: number) => {
-    const clamped = Math.max(0, Math.min(total, frame));
+    const clamped = nativeSourcePreview
+      ? sourcePreviewFrame(frame, total)
+      : Math.max(0, Math.min(total, frame));
     if (previewing) {
       // A single media item has no clip edges to snap to.
-      if (mediaRef.current) mediaRef.current.currentTime = clamped / fps;
+      const time = clamped / Math.max(1, fps);
+      if (nativeSourcePreview) {
+        setMediaTime(time);
+        if (mediaPlaying && sourcePlaybackIdentity) {
+          void nativePlaybackController.seek(sourcePlaybackIdentity, clamped);
+        }
+      } else if (mediaRef.current) {
+        mediaRef.current.currentTime = time;
+      }
     } else {
       // Magnetize the scrub bar to clip start/end edges (~0.25s threshold) and
       // tick on engage, like dragging the playhead in the timeline.
@@ -266,9 +360,19 @@ export function Preview() {
   // They must not pass through clip-edge magnetism or a request for frame 1
   // near a clip starting at 0 would snap straight back to 0.
   const seekToExact = (frame: number) => {
-    const clamped = exactTimelineFrame(frame, total);
+    const clamped = nativeSourcePreview
+      ? sourcePreviewFrame(frame, total)
+      : exactTimelineFrame(frame, total);
     if (previewing) {
-      if (mediaRef.current) mediaRef.current.currentTime = clamped / fps;
+      const time = clamped / Math.max(1, fps);
+      if (nativeSourcePreview) {
+        setMediaTime(time);
+        if (mediaPlaying && sourcePlaybackIdentity) {
+          void nativePlaybackController.seek(sourcePlaybackIdentity, clamped);
+        }
+      } else if (mediaRef.current) {
+        mediaRef.current.currentTime = time;
+      }
     } else {
       setCurrentFrame(clamped);
     }
@@ -276,6 +380,69 @@ export function Preview() {
 
   const togglePlay = () => {
     if (previewing) {
+      if (nativeSourcePreview && previewItem) {
+        const identity = sourcePlaybackIdentityRef.current ?? sourcePlaybackIdentity;
+        if (mediaPlaying) {
+          setMediaPlaying(false);
+          if (sourcePlaybackStartingRef.current) {
+            retireSourcePlaybackStart(
+              sourcePlaybackGenerationRef,
+              sourcePlaybackStartingRef,
+            );
+            sourcePlaybackIdentityRef.current = null;
+            setSourcePlaybackIdentity(null);
+            if (identity) void nativePlaybackController.stop(identity).catch(() => undefined);
+          } else {
+            if (!identity) return;
+            void nativePlaybackController
+              .pause(identity, Math.max(0, Math.floor(mediaTime * Math.max(1, fps))))
+              .catch(() => setMediaPlaying(false));
+          }
+          return;
+        }
+
+        const totalFrames = Math.max(1, sourceDurationFrames(mediaDuration, fps));
+        const currentFrame = Math.max(0, Math.floor(mediaTime * Math.max(1, fps)));
+        const startFrame = sourcePlaybackStartFrame(currentFrame, totalFrames);
+        if (startFrame === 0 && currentFrame !== 0) setMediaTime(0);
+        setTimelinePlaying(false);
+        setMediaPlaying(true);
+        sourcePlaybackStartingRef.current = true;
+        const generation = sourcePlaybackGenerationRef.current;
+        void nativePlaybackController
+          .start({ projectEpoch, timelineVersion }, startFrame, {
+            mediaId: previewItem.id,
+            onIdentity: (started) => {
+              if (generation !== sourcePlaybackGenerationRef.current) {
+                void nativePlaybackController.stop(started).catch(() => undefined);
+                return;
+              }
+              sourcePlaybackIdentityRef.current = started;
+              setSourcePlaybackIdentity(started);
+            },
+          })
+          .then((started) => {
+            if (generation !== sourcePlaybackGenerationRef.current) {
+              void nativePlaybackController.stop(started).catch(() => undefined);
+              return;
+            }
+            sourcePlaybackIdentityRef.current = started;
+            setSourcePlaybackIdentity(started);
+          })
+          .catch(() => {
+            if (generation !== sourcePlaybackGenerationRef.current) return;
+            sourcePlaybackIdentityRef.current = null;
+            setSourcePlaybackIdentity(null);
+            setMediaPlaying(false);
+            pushToast(t("preview.terminalFrameFailed"));
+          })
+          .finally(() => {
+            if (generation === sourcePlaybackGenerationRef.current) {
+              sourcePlaybackStartingRef.current = false;
+            }
+          });
+        return;
+      }
       const el = mediaRef.current;
       if (!el) return;
       if (el.paused) void el.play();
@@ -330,6 +497,12 @@ export function Preview() {
   };
 
   const fittedCanvas = aspectFitBox(stageSize.width, stageSize.height, timeline.width, timeline.height);
+  const fittedSource = aspectFitBox(
+    stageSize.width,
+    stageSize.height,
+    previewItem?.width ?? 16,
+    previewItem?.height ?? 9,
+  );
   // The zoomed canvas box: the aspect-fit box physically resized by `canvasZoom`
   // (upstream `.frame(fitSize * zoom)`, PreviewContainerView.swift:20-22,43). The
   // box stays flex-centered in the stage; `canvasOffset` then translates it
@@ -423,7 +596,31 @@ export function Preview() {
           padding: 8,
         }}
       >
-        {previewItem ? (
+        {previewItem && nativeSourcePreview ? (
+          <NativeSourcePlaybackSurface
+            item={previewItem}
+            width={fittedSource?.width}
+            height={fittedSource?.height}
+            event={sourceNativeFrameEvent}
+            endpoint={previewFrameEndpoint}
+            projectEpoch={projectEpoch}
+            timelineVersion={timelineVersion}
+            playing={mediaPlaying}
+            frame={sourcePreviewFrame(
+              mediaTime * Math.max(1, fps),
+              Math.max(1, sourceDurationFrames(mediaDuration, fps)),
+            )}
+            previewQualityShortEdge={previewQualityShortEdge}
+            onPlayingChange={(playing) => {
+              setMediaPlaying(playing);
+              if (!playing && sourceNativeFrameEvent?.terminal) {
+                sourcePlaybackIdentityRef.current = null;
+                setSourcePlaybackIdentity(null);
+              }
+            }}
+            onTerminalFailure={() => pushToast(t("preview.terminalFrameFailed"))}
+          />
+        ) : previewItem ? (
           <MediaPreview
             item={previewItem}
             projectEpoch={projectEpoch}
@@ -598,6 +795,78 @@ export function Preview() {
   );
 }
 
+export function NativeSourcePlaybackSurface({
+  item,
+  width,
+  height,
+  event,
+  endpoint,
+  projectEpoch,
+  timelineVersion,
+  playing,
+  frame,
+  previewQualityShortEdge,
+  onPlayingChange,
+  onTerminalFailure,
+  requestSourceFrame = compositeFrame,
+  cancelSourceFrame = cancelCompositeFrame,
+}: {
+  item: MediaItem;
+  width?: number;
+  height?: number;
+  event: Parameters<typeof RustFrameBuffer>[0]["event"];
+  endpoint: string | null;
+  projectEpoch: number;
+  timelineVersion: number;
+  playing: boolean;
+  frame: number;
+  previewQualityShortEdge: number | null;
+  onPlayingChange: (playing: boolean) => void;
+  onTerminalFailure: () => void;
+  requestSourceFrame?: typeof compositeFrame;
+  cancelSourceFrame?: typeof cancelCompositeFrame;
+}) {
+  const requestSourceStill = useCallback(
+    (request: Parameters<typeof compositeFrame>[0]) =>
+      requestSourceFrame(
+        { ...request, sourceMediaId: item.id },
+        previewQualityMaxSize(
+          previewQualityShortEdge,
+          item.width ?? 1920,
+          item.height ?? 1080,
+        ),
+      ),
+    [item.height, item.id, item.width, previewQualityShortEdge, requestSourceFrame],
+  );
+
+  return (
+    <div
+      data-source-playback-surface="native"
+      style={{
+        position: "relative",
+        width: width ?? "100%",
+        height: height ?? "100%",
+        maxWidth: "100%",
+        maxHeight: "100%",
+      }}
+    >
+      <RustFrameBuffer
+        key={item.id}
+        event={event}
+        endpoint={endpoint}
+        projectEpoch={projectEpoch}
+        timelineVersion={timelineVersion}
+        engineDriving={playing}
+        stillFrame={playing ? null : frame}
+        requestCompositeStill={requestSourceStill}
+        cancelCompositeStill={cancelSourceFrame}
+        onTransportPlayingChange={onPlayingChange}
+        onTerminalFailure={onTerminalFailure}
+      />
+    </div>
+  );
+}
+
 function unsupportedReasonKey(reason: UnsupportedPlaybackReason): string {
   return `preview.unsupportedPlayback.${reason.code}`;
 }
@@ -709,6 +978,7 @@ export function MediaPreview({
         <Icon icon={Play} size={28} />
         <audio
           ref={(el) => {
+            if (!el) mediaRef.current?.pause();
             mediaRef.current = el;
           }}
           src={url}
@@ -731,6 +1001,7 @@ export function MediaPreview({
   return (
     <video
       ref={(el) => {
+        if (!el) mediaRef.current?.pause();
         mediaRef.current = el;
       }}
       src={url}
diff --git a/web/src/components/preview/RustFrameBuffer.tsx b/web/src/components/preview/RustFrameBuffer.tsx
index 5d7af08c..4fff7052 100644
--- a/web/src/components/preview/RustFrameBuffer.tsx
+++ b/web/src/components/preview/RustFrameBuffer.tsx
@@ -28,6 +28,7 @@ export interface RustFrameBufferProps {
   stillFrame?: number | null;
   requestCompositeStill: (request: CompositeStillRequest) => Promise<CompositeFrame | null>;
   cancelCompositeStill?: (request: CancelCompositeStillRequest) => Promise<void>;
+  onTransportPlayingChange?: (playing: boolean) => void;
   onTerminalFailure: () => void;
 }
 
@@ -135,6 +136,7 @@ export function RustFrameBuffer({
   stillFrame = null,
   requestCompositeStill,
   cancelCompositeStill,
+  onTransportPlayingChange,
   onTerminalFailure,
 }: RustFrameBufferProps) {
   const [state, setState] = useState<RustFrameBufferState>(createRustFrameBufferState);
@@ -242,7 +244,10 @@ export function RustFrameBuffer({
       afterPaint,
       isCurrentIdentity: (identity) =>
         samePlaybackIdentity(nativePlaybackController.currentIdentity(), identity),
-      setPlaying: (playing) => useEditorUiStore.getState().setPlaying(playing),
+      setPlaying: (playing) => {
+        if (onTransportPlayingChange) onTransportPlayingChange(playing);
+        else useEditorUiStore.getState().setPlaying(playing);
+      },
       stop: (identity) => nativePlaybackController.stop(identity),
       onTerminalFailure,
     });
diff --git a/web/src/components/preview/nativePlaybackSession.test.ts b/web/src/components/preview/nativePlaybackSession.test.ts
index 06eb8be1..1a23c006 100644
--- a/web/src/components/preview/nativePlaybackSession.test.ts
+++ b/web/src/components/preview/nativePlaybackSession.test.ts
@@ -109,6 +109,90 @@ describe("native playback identity", () => {
     expect(h.api.playbackStop).toHaveBeenCalledWith(current);
   });
 
+  it("does not resume a retained source session for a different media asset", async () => {
+    const h = harness();
+    const first = await h.controller.start(revision(4, 6), 0, { mediaId: "main10-a" });
+    await h.controller.pause(first, 12);
+
+    const second = await h.controller.start(revision(4, 6), 12, { mediaId: "main10-b" });
+
+    expect(second.sessionId).not.toBe(first.sessionId);
+    expect(h.api.playbackStop).toHaveBeenCalledWith(first);
+    expect(h.api.playbackStart).toHaveBeenLastCalledWith(12, second, "main10-b");
+  });
+
+  it("retains the exact source session across pause seek and resume", async () => {
+    const h = harness();
+    const first = await h.controller.start(revision(4, 6), 1_572, { mediaId: "main10" });
+    await h.controller.pause(first, 1_600);
+    const resumed = await h.controller.start(revision(4, 6), 1_600, { mediaId: "main10" });
+
+    expect(resumed.sessionId).toBe(first.sessionId);
+    expect(h.api.playbackStart).toHaveBeenLastCalledWith(1_600, first, "main10");
+  });
+
+  it("ignores an old source terminal event after switching media", async () => {
+    const h = harness();
+    const first = await h.controller.start(revision(4, 6), 0, { mediaId: "source-a" });
+    const second = await h.controller.start(revision(4, 6), 0, {
+      mediaId: "source-b",
+      forceNewSession: true,
+    });
+
+    h.emit({ ...first, frame: 299, sequence: 99, terminal: true });
+    expect(getNativePlaybackPublication()).toBeNull();
+
+    h.emit({ ...second, frame: 1, sequence: 1, terminal: false });
+    expect(getNativePlaybackPublication()).toMatchObject({
+      sessionId: second.sessionId,
+      frame: 1,
+      terminal: false,
+    });
+  });
+
+  it("lets the latest source start win while an older replacement awaits stop", async () => {
+    let finishStop!: () => void;
+    const api = {
+      playbackStart: vi.fn(async () => {}),
+      playbackPause: vi.fn(async () => {}),
+      playbackSeek: vi.fn(async () => {}),
+      playbackStop: vi.fn(
+        () =>
+          new Promise<void>((resolve) => {
+            finishStop = resolve;
+          }),
+      ),
+    };
+    let nextId = 0;
+    const controller = createNativePlaybackController(api, () => `source-${++nextId}`);
+    await controller.start(revision(4, 6), 0, { mediaId: "source-old" });
+
+    const older = controller.start(revision(4, 6), 0, { mediaId: "source-a" });
+    await Promise.resolve();
+    const latest = await controller.start(revision(4, 6), 0, { mediaId: "source-b" });
+    finishStop();
+
+    await expect(older).rejects.toMatchObject({ code: "superseded" });
+    expect(controller.currentIdentity()).toEqual(latest);
+    expect(api.playbackStart).toHaveBeenLastCalledWith(0, latest, "source-b");
+  });
+
+  it("does not dispatch a source start cancelled by its identity callback", async () => {
+    const h = harness();
+
+    await expect(
+      h.controller.start(revision(4, 6), 0, {
+        mediaId: "source-a",
+        onIdentity: (identity) => {
+          void h.controller.stop(identity);
+        },
+      }),
+    ).rejects.toMatchObject({ code: "superseded" });
+
+    expect(h.api.playbackStart).not.toHaveBeenCalled();
+    expect(h.controller.currentIdentity()).toBeNull();
+  });
+
   it("retires a stopped identity before the stop IPC resolves", async () => {
     let finishStop: (() => void) | undefined;
     const api = {
diff --git a/web/src/components/preview/nativePlaybackSession.ts b/web/src/components/preview/nativePlaybackSession.ts
index c12ea96e..9c936d86 100644
--- a/web/src/components/preview/nativePlaybackSession.ts
+++ b/web/src/components/preview/nativePlaybackSession.ts
@@ -79,7 +79,11 @@ function validFrameEvent(event: PlaybackFrameEvent): boolean {
 }
 
 export interface NativePlaybackApi {
-  playbackStart(frame: number, identity: PlaybackIdentity): Promise<void>;
+  playbackStart(
+    frame: number,
+    identity: PlaybackIdentity,
+    mediaId?: string,
+  ): Promise<void>;
   playbackPause(identity: PlaybackIdentity, frame: number): Promise<void>;
   playbackSeek(identity: PlaybackIdentity, frame: number): Promise<void>;
   playbackStop(identity: PlaybackIdentity): Promise<void>;
@@ -91,6 +95,7 @@ export interface NativePlaybackController {
     frame: number,
     options?: {
       forceNewSession?: boolean;
+      mediaId?: string;
       onIdentity?: (identity: PlaybackIdentity) => void;
     },
   ): Promise<PlaybackIdentity>;
@@ -109,15 +114,22 @@ export function createNativePlaybackController(
   mintSessionId: () => string = createSessionId,
 ): NativePlaybackController {
   let current: PlaybackIdentity | null = null;
+  let currentMediaId: string | null = null;
   let paused = false;
   let lastSequence = -1;
+  let lifecycleGeneration = 0;
 
-  const stopIdentity = async (identity: PlaybackIdentity) => {
+  const stopIdentity = async (
+    identity: PlaybackIdentity,
+    invalidatePendingStart = true,
+  ) => {
     if (!samePlaybackIdentity(current, identity)) return;
+    if (invalidatePendingStart) lifecycleGeneration += 1;
     // Retire locally before awaiting IPC. A final backend frame can race the
     // stop command across the WebView bridge; keeping `current` alive until the
     // promise resolves lets that stale frame overwrite a newer scrub result.
     current = null;
+    currentMediaId = null;
     paused = false;
     lastSequence = -1;
     clearNativePlaybackPublication();
@@ -131,20 +143,55 @@ export function createNativePlaybackController(
 
   return {
     async start(revision, frame, options) {
-      const reusable = sameRevision(current, revision) && paused && !options?.forceNewSession;
-      if (!reusable && current) await stopIdentity(current);
+      const startGeneration = ++lifecycleGeneration;
+      const requestedMediaId = options?.mediaId ?? null;
+      const reusable =
+        sameRevision(current, revision) &&
+        paused &&
+        currentMediaId === requestedMediaId &&
+        !options?.forceNewSession;
+      if (!reusable && current) await stopIdentity(current, false);
+      if (startGeneration !== lifecycleGeneration) {
+        throw {
+          code: "superseded",
+          message: "native playback start was superseded",
+        } satisfies PlaybackCommandError;
+      }
       if (!reusable) {
         current = {
           ...revision,
           sessionId: mintSessionId(),
         };
+        currentMediaId = requestedMediaId;
         lastSequence = -1;
         clearNativePlaybackPublication();
       }
       const identity = current;
       if (!identity) throw new Error("native playback identity was not created");
       options?.onIdentity?.({ ...identity });
-      await playbackApi.playbackStart(Math.max(0, Math.floor(frame)), identity);
+      if (
+        startGeneration !== lifecycleGeneration ||
+        !samePlaybackIdentity(current, identity)
+      ) {
+        throw {
+          code: "superseded",
+          message: "native playback start was superseded",
+        } satisfies PlaybackCommandError;
+      }
+      await playbackApi.playbackStart(
+        Math.max(0, Math.floor(frame)),
+        identity,
+        requestedMediaId ?? undefined,
+      );
+      if (
+        startGeneration !== lifecycleGeneration ||
+        !samePlaybackIdentity(current, identity)
+      ) {
+        throw {
+          code: "superseded",
+          message: "native playback start was superseded",
+        } satisfies PlaybackCommandError;
+      }
       paused = false;
       return identity;
     },
@@ -211,7 +258,7 @@ function createSessionId(): string {
 }
 
 export const nativePlaybackController = createNativePlaybackController({
-  playbackStart: (frame, identity) => api.playbackStart(frame, identity),
+  playbackStart: (frame, identity, mediaId) => api.playbackStart(frame, identity, mediaId),
   playbackPause: (identity, frame) => api.playbackPause(identity, frame),
   playbackSeek: (identity, frame) => api.playbackSeek(identity, frame),
   playbackStop: (identity) => api.playbackStop(identity),
diff --git a/web/src/hooks/useKeyboardShortcuts.test.ts b/web/src/hooks/useKeyboardShortcuts.test.ts
index 8006ce65..7aa5997f 100644
--- a/web/src/hooks/useKeyboardShortcuts.test.ts
+++ b/web/src/hooks/useKeyboardShortcuts.test.ts
@@ -26,6 +26,32 @@ describe("keyboard transport Space shortcut", () => {
     expect(shouldHandleTransportSpaceKey(event(), "editor")).toBe(true);
   });
 
+  it("handles Space from every non-editable editor panel surface", () => {
+    for (const panel of ["media", "preview", "inspector", "timeline", "agent"]) {
+      const surface = document.createElement("section");
+      surface.dataset.panel = panel;
+      expect(
+        shouldHandleTransportSpaceKey(event({ target: surface }), "editor"),
+        panel,
+      ).toBe(true);
+    }
+
+    const contentEditable = document.createElement("div");
+    contentEditable.contentEditable = "true";
+    const plaintextEditable = document.createElement("div");
+    plaintextEditable.contentEditable = "plaintext-only";
+    for (const editable of [
+      document.createElement("input"),
+      document.createElement("textarea"),
+      contentEditable,
+      plaintextEditable,
+    ]) {
+      expect(
+        shouldHandleTransportSpaceKey(event({ target: editable }), "editor"),
+      ).toBe(false);
+    }
+  });
+
   it("does not suppress Space keyup outside the editor", () => {
     expect(shouldHandleTransportSpaceKey(event(), "home")).toBe(false);
   });
@@ -34,10 +60,13 @@ describe("keyboard transport Space shortcut", () => {
     expect(shouldHandleTransportSpaceKey(event({ metaKey: true }), "editor")).toBe(false);
   });
 
-  it("does not claim Space from native controls or media interaction surfaces", () => {
+  it("claims Space from media tiles and every non-text native control", () => {
     const button = document.createElement("button");
     const buttonLabel = document.createElement("span");
     button.append(buttonLabel);
+    const slider = document.createElement("input");
+    slider.type = "range";
+    const select = document.createElement("select");
     const mediaCard = document.createElement("div");
     mediaCard.dataset.mediaTile = "true";
     const context = {
@@ -48,9 +77,12 @@ describe("keyboard transport Space shortcut", () => {
       cropEditingActive: false,
     };
 
-    expect(shouldHandleTransportSpaceKey(event({ target: buttonLabel }), "editor")).toBe(false);
-    expect(shouldHandleTransportSpaceKey(event({ target: mediaCard }), "editor")).toBe(false);
-    expect(resolveDocumentedShortcut(event({ target: buttonLabel }), context)).toBeNull();
+    for (const control of [buttonLabel, slider, select, mediaCard]) {
+      expect(shouldHandleTransportSpaceKey(event({ target: control }), "editor")).toBe(true);
+      expect(resolveDocumentedShortcut(event({ target: control }), context)).toEqual({
+        type: "transport",
+      });
+    }
     expect(
       resolveDocumentedShortcut(event({ code: "Escape", target: buttonLabel }), context),
     ).toEqual({ type: "escape" });
@@ -108,6 +140,57 @@ describe("keyboard transport Space shortcut", () => {
     expect(toggles).toBe(0);
   });
 
+  it("consumes native-control Space once without activating the local control", () => {
+    let toggles = 0;
+    let prevented = 0;
+    let stopped = 0;
+    const button = document.createElement("button");
+    const dispatch = (repeat: boolean) =>
+      handleTransportSpaceKeyDown(
+        event({
+          target: button,
+          repeat,
+          preventDefault: () => {
+            prevented += 1;
+          },
+          stopPropagation: () => {
+            stopped += 1;
+          },
+        }),
+        {
+          view: "editor",
+          previewMediaId: null,
+          timelinePlaybackAllowed: true,
+          requestMediaPreviewToggle: () => {},
+          togglePlay: () => {
+            toggles += 1;
+          },
+        },
+      );
+
+    expect(dispatch(false)).toBe(true);
+    expect(dispatch(true)).toBe(true);
+    expect({ toggles, prevented, stopped }).toEqual({
+      toggles: 1,
+      prevented: 2,
+      stopped: 2,
+    });
+  });
+
+  it("does not intercept Space while an IME composition is active", () => {
+    const composing = event({ isComposing: true });
+    const context = {
+      view: "editor" as const,
+      blocked: false,
+      focusedPanel: "preview" as const,
+      compatibilityReadOnly: false,
+      cropEditingActive: false,
+    };
+
+    expect(shouldHandleTransportSpaceKey(composing, "editor")).toBe(false);
+    expect(resolveDocumentedShortcut(composing, context)).toBeNull();
+  });
+
   it("does not start timeline playback from Space when route is Unsupported", () => {
     let toggles = 0;
     const e = event({
diff --git a/web/src/hooks/useKeyboardShortcuts.ts b/web/src/hooks/useKeyboardShortcuts.ts
index ea05ce83..ac8b5fe6 100644
--- a/web/src/hooks/useKeyboardShortcuts.ts
+++ b/web/src/hooks/useKeyboardShortcuts.ts
@@ -22,13 +22,26 @@ import { runApplicationMenuCommand } from "../components/shell/ViewMenu";
 
 /** Per-keypress zoom step for ⌘+ / ⌘- (剪映: Cmd + +/-). */
 const ZOOM_KEY_STEP = 1.3;
+const TEXT_INPUT_TYPES: ReadonlySet<string> = new Set([
+  "email",
+  "password",
+  "search",
+  "tel",
+  "text",
+  "url",
+]);
 
 function isTextEntry(target: EventTarget | null): boolean {
   if (typeof Element === "undefined" || !(target instanceof Element)) return false;
   const editable = target.closest<HTMLElement>(
-    'input, textarea, [contenteditable="true"], [contenteditable=""]',
+    "input, textarea, [contenteditable]",
+  );
+  if (!editable) return false;
+  if (editable.isContentEditable || editable.matches("textarea")) return true;
+  return (
+    editable.matches("input") &&
+    TEXT_INPUT_TYPES.has((editable as HTMLInputElement).type)
   );
-  return Boolean(editable?.isContentEditable || editable?.matches("input, textarea"));
 }
 
 function isNativeInteractionControl(target: EventTarget | null): boolean {
@@ -40,15 +53,9 @@ function isNativeInteractionControl(target: EventTarget | null): boolean {
   );
 }
 
-function isMediaInteractionSurface(target: EventTarget | null): boolean {
-  if (typeof Element === "undefined" || !(target instanceof Element)) return false;
-  return Boolean(target.closest('[data-media-tile="true"]'));
-}
-
 function nativeControlOwnsUnmodifiedKey(e: KeyboardEvent): boolean {
   if (!isNativeInteractionControl(e.target)) return false;
   return [
-    "Space",
     "Enter",
     "NumpadEnter",
     "ArrowLeft",
@@ -149,7 +156,7 @@ export function resolveDocumentedShortcut(
   e: KeyboardEvent,
   context: DocumentedShortcutContext,
 ): ResolvedShortcut | null {
-  if (context.view !== "editor" || context.blocked || isTextEntry(e.target)) {
+  if (context.view !== "editor" || context.blocked || e.isComposing || isTextEntry(e.target)) {
     return null;
   }
   const mod = e.metaKey || e.ctrlKey;
@@ -221,7 +228,7 @@ export function resolveDocumentedShortcut(
   } else if (!e.altKey && !nativeControlOwnsUnmodifiedKey(e)) {
     switch (e.code) {
       case "Space":
-        if (!e.shiftKey && !isMediaInteractionSurface(e.target)) {
+        if (!e.shiftKey) {
           command = { type: "transport" };
         }
         break;
@@ -305,9 +312,8 @@ export function shouldHandleTransportSpaceKey(e: KeyboardEvent, view: AppView):
     !e.ctrlKey &&
     !e.altKey &&
     !e.shiftKey &&
-    !isTextEntry(e.target) &&
-    !isNativeInteractionControl(e.target) &&
-    !isMediaInteractionSurface(e.target)
+    !e.isComposing &&
+    !isTextEntry(e.target)
   );
 }
 
diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts
index 6fd4b28b..497c0449 100644
--- a/web/src/lib/api.ts
+++ b/web/src/lib/api.ts
@@ -1340,6 +1340,7 @@ export interface CompositeStillRequest {
   sessionGeneration: number;
   seekGeneration: number;
   sequenceId?: string;
+  sourceMediaId?: string;
 }
 
 export interface CancelCompositeStillRequest {
@@ -2075,12 +2076,14 @@ export async function onChatDone(
 export async function playbackStart(
   fromFrame: number,
   identity: PlaybackIdentity,
+  mediaId?: string,
 ): Promise<void> {
   await ensureTauri();
   if (invokeImpl)
     await invokeImpl<void>("playback_start", {
       fromFrame: Math.floor(fromFrame),
       identity,
+      mediaId,
     });
 }
 

From b60ed723e9a3b204a5f54768d3c845591105351c Mon Sep 17 00:00:00 2001
From: baiqing <lbx12309@icloud.com>
Date: Sun, 9 Aug 2026 21:34:13 +0800
Subject: [PATCH 3/4] chore(release): prepare v1.0.0-beta.3

---
 .github/workflows/release.yml          |  7 +-
 Cargo.lock                             | 22 +++---
 Cargo.toml                             |  2 +-
 README.md                              |  7 +-
 docs/releases/1.0.0-beta.3.md          | 92 ++++++++++++++++++++++++++
 scripts/check_release_workflow.py      | 23 ++++---
 scripts/test_check_release_workflow.py | 62 ++++++++++++-----
 src-tauri/tauri.conf.json              |  4 +-
 web/package.json                       |  2 +-
 9 files changed, 177 insertions(+), 44 deletions(-)
 create mode 100644 docs/releases/1.0.0-beta.3.md

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 7d6036e7..99a1f30b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -85,12 +85,15 @@ jobs:
           }
           if versions != {version}:
               raise SystemExit(f"tag/version mismatch: {tag} != {sorted(versions)}")
+          wix_version = tauri["bundle"]["windows"]["wix"]["version"]
+          if wix_version != "1.0.0.3":
+              raise SystemExit(f"unexpected Windows installer version: {wix_version}")
           notes = Path("docs/releases") / f"{version}.md"
           if not notes.is_file() or not notes.read_text(encoding="utf-8").strip():
               raise SystemExit(f"release notes are missing or empty: {notes}")
           prerelease = "-" in version.split("+", 1)[0]
-          if version == "1.0.0-beta.2" and not prerelease:
-              raise SystemExit("OpenTake 1.0.0-beta.2 must remain a prerelease")
+          if version == "1.0.0-beta.3" and not prerelease:
+              raise SystemExit("OpenTake 1.0.0-beta.3 must remain a prerelease")
           if not prerelease:
               raise SystemExit("this release workflow publishes prereleases only")
 
diff --git a/Cargo.lock b/Cargo.lock
index 32cbf23e..5382b037 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3680,7 +3680,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-agent"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3715,7 +3715,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-core"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "opentake-domain",
  "opentake-ops",
@@ -3729,7 +3729,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-domain"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "serde",
  "serde_json",
@@ -3737,7 +3737,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-gen"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3755,7 +3755,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-media"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "anyhow",
  "byteorder",
@@ -3793,7 +3793,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-motion"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "base64 0.22.1",
  "hex",
@@ -3811,7 +3811,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-ops"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "opentake-domain",
  "serde_json",
@@ -3819,7 +3819,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-process-tree"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "libc",
  "windows-sys 0.61.2",
@@ -3827,7 +3827,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-project"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "cap-fs-ext",
  "cap-std",
@@ -3846,7 +3846,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-render"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "bytemuck",
  "cosmic-text",
@@ -3863,7 +3863,7 @@ dependencies = [
 
 [[package]]
 name = "opentake-tauri"
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 dependencies = [
  "axum",
  "base64 0.22.1",
diff --git a/Cargo.toml b/Cargo.toml
index aafc48fc..a5d8b32d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ members = [
 ]
 
 [workspace.package]
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/appergb/OpenTake"
diff --git a/README.md b/README.md
index 7b956fb3..13ceb125 100644
--- a/README.md
+++ b/README.md
@@ -303,9 +303,9 @@ cd ..
 cargo tauri dev
 ```
 
-> **Current Status**: `1.0.0-beta.2` candidate. The local editing, preview,
+> **Current Status**: `1.0.0-beta.3` candidate. The local editing, preview,
 > persistence, export, Agent, Motion Canvas, and reviewed AI workflow verticals
-> are implemented. See the [Beta release notes](docs/releases/1.0.0-beta.2.md)
+> are implemented. See the [Beta release notes](docs/releases/1.0.0-beta.3.md)
 > for validation scope and platform/provider limits.
 
 The sibling directory `palmier-pro-upstream/` contains upstream Swift sources for reference during porting.
@@ -318,7 +318,8 @@ The sibling directory `palmier-pro-upstream/` contains upstream Swift sources fo
 |:--|:--|:--|
 | `0.1.0-dev` | 2026-06 | Phase 0+1: Cargo workspace + Domain models + Edit ops + Tauri scaffold |
 | `1.0.0-beta.1` | 2026-08-01 | First installable Beta: end-to-end local editor, Agent, Motion and reviewed AI workflows |
-| `1.0.0-beta.2` | 2026-08-03 | Hardened Beta: official Codex login, atomic timeline gestures, secure MCP and interaction polish |
+| `1.0.0-beta.2` | 2026-08-08 | Hardened Beta: official Codex login, atomic timeline gestures, secure MCP and interaction polish |
+| `1.0.0-beta.3` | 2026-08-09 | Playback Beta: app-wide Space transport, native HEVC source preview and release-pipeline hardening |
 | *(planned)* `1.0.0` | TBD | Phase 10: Full release — CapCut parity + deep Agent integration |
 
 📖 [Full Roadmap](docs/architecture/ROADMAP.md)
diff --git a/docs/releases/1.0.0-beta.3.md b/docs/releases/1.0.0-beta.3.md
new file mode 100644
index 00000000..43a72620
--- /dev/null
+++ b/docs/releases/1.0.0-beta.3.md
@@ -0,0 +1,92 @@
+# OpenTake 1.0.0-beta.3
+
+发布日期：2026-08-09（Asia/Shanghai）
+
+## Beta 目标
+
+在 `1.0.0-beta.2` 的安全与交互门禁基础上，修复两个直接影响素材预览的高优先级问题：
+全局空格播放/暂停失效，以及部分 HEVC（包括 Main 10、10-bit 4K）素材在 WebView 直接解码时
+出现黑屏、解码异常或底部绿色画面。同时修复 Beta 2 发布阶段对源码树洁净度的破坏，确保同一
+exact-SHA 候选能够完整走完构建、校验和 prerelease 发布。
+
+## 主要变化
+
+- App 内的非文本编辑区域统一由全局 transport 处理空格键：素材卡片、预览、Inspector、
+  Timeline 与 Agent 面板获得焦点时均可播放或暂停；输入框和文本编辑控件保留正常的空格输入。
+- 单素材视频预览的正常路径改走 Rust 原生 FFmpeg 流式播放，不再依赖 WebKit `<video>` 对
+  原文件的 codec/profile 支持；播放、暂停、切换素材和暂停态精确 seek 绑定到当前素材会话，
+  仅在原生能力不可用时保留 WebKit fallback。
+- HEVC Main 10 / `yuv420p10le` 4K 素材通过原生解码、RGBA 帧缓冲和同一预览控制面输出，避免
+  WebView 解码差异造成的黑屏、绿色底边和异常帧；媒体错误仍显式上报，不静默伪装成功。
+- 全局空格键路径增加媒体卡片与各编辑面板的回归矩阵；原生源预览增加会话切换、暂停 seek、
+  终止状态及真实 HEVC Main 10 像素 probe 覆盖。
+- publish job 设置 `PYTHONDONTWRITEBYTECODE=1`，防止发布辅助脚本在 checkout 内生成
+  `scripts/__pycache__`，从而触发 exact-source clean-tree 门禁；release contract 包含对应突变测试。
+- 应用、Cargo workspace 与 Web 包版本统一为 `1.0.0-beta.3`；Windows MSI 的数值安装器版本
+  固定为 `1.0.0.3`，并由发布合约 fail closed 校验。
+
+Beta 2 的 `v1.0.0-beta.2` tag 保持不可移动。Beta 3 使用新的 `v1.0.0-beta.3` tag，不通过
+重写旧 tag 或旧 Release 来替代失败候选。
+
+## 候选包验收顺序
+
+同一候选包必须严格执行：
+
+1. Home / 工程生命周期与恢复。
+2. 素材库、文件夹、收藏、缩略图、波形、代理与重链接。
+3. 选中 H.264、HEVC Main 和 HEVC Main 10 素材，分别验证播放、暂停、seek、连续帧与切换素材。
+4. 素材卡片、预览、Inspector、Timeline 与 Agent 面板逐一聚焦后验证空格播放/暂停；文本输入空格
+   不得误触 transport。
+5. 时间线选择、拖放、裁剪、分割、复制、链接、吸附、撤销/重做与嵌套序列。
+6. 时间线预览、seek、scrub、A/V 同步、Transform/Crop/Mask 与关键帧。
+7. 文本/字幕、转写、翻译、SRT/VTT、特效、调色、音频处理和样式。
+8. Agent/MCP、官方 Codex / ChatGPT 登录与一次真实可撤销编辑；无凭据云功能 fail closed。
+9. Motion Canvas、保存重开和 H.264/H.265/ProRes 最终导出。
+10. 完全退出 App，重新启动并重开工程，复验两个播放入口和最终输出。
+
+代码测试不能替代 GUI 观察；GUI 观察也不能替代媒体 probe、工程重开和最终输出解析。
+
+## 外部边界
+
+- 未获得 provider key 和明确费用授权时，不执行真实付费生成、翻译、数字人或音色克隆请求；
+  只验证同意/费用门禁和无凭据拒绝。
+- 本地 macOS 包为 ad-hoc Beta，不宣称 Developer ID 签名或 Apple 公证。
+- 原生 Windows Job Object、reparse-point、安装和 WebView 交互必须由 exact-SHA Windows CI / 实机
+  验证；macOS 结果不能代替。
+- 固定端口、无认证的外部 MCP 在本 Beta 关闭；Claude、Cursor 等客户端等待安全配对流程。
+
+## GitHub 自动发布流程
+
+`.github/workflows/release.yml` 只接受 `v*` tag push；人工 `workflow_dispatch` 只能输入一个
+已存在的同名 tag，用于失败运行的重试。流水线不创建、不移动 tag。发布前必须在流水线外将
+`v1.0.0-beta.3` 标记到远端 `main` 的当前 HEAD，再 push 该 tag。
+
+每次运行依次 fail closed 执行：
+
+1. 将 `v<semver>` tag 解析为不可变 source SHA，核对 tag 目标、远端 `main` 当前 HEAD、
+   Cargo/Tauri/Web 版本、Windows MSI `1.0.0.3` 安装器版本和本文档；Beta 3 必须是 prerelease。
+2. Ubuntu 运行依赖锁定安装、audit、license、test、可复现构建，Windows/release 工作流合约、
+   sidecar provisioner、Rust fmt/clippy/workspace tests 和 Web test/build 门禁。
+3. `macos-14` ARM64 对 exact SHA 使用 checksum-pinned FFmpeg sidecar 构建 `.app` + `.dmg`，
+   执行 strict codesign、DMG verify/挂载复验和媒体 smoke；产物仅为 ad-hoc 签名。
+4. `windows-2022` x64 对 exact SHA 构建唯一 MSI 和 NSIS，静默安装 NSIS，对安装后程序做启动
+   smoke，并在无 PATH 依赖的安装目录边界执行 sidecar probe/decode/encode smoke。
+5. 两个平台 receipt 绑定 source SHA、文件字节数与 SHA-256；`SHA256SUMS` 精确覆盖 DMG、MSI、
+   NSIS 和两个 receipt。
+6. publish job 在创建/刷新 draft 前和公开前都重新解析远端 lightweight/annotated tag，并要求
+   peeled commit 与 source SHA 完全一致；Python 辅助脚本禁止向 checkout 写入 bytecode。
+7. 只在所有门禁成功后创建 draft prerelease，上传严格计数的六个资产；GraphQL 核对
+   tag/commit/assets 后以 `latest=false` 公开，最后下载回读并复验资产和 checksum。
+
+workflow 顶层权限是 `contents: read`，只有 publish job 提升为 `contents: write`；所有外部
+GitHub Actions 固定到 40-hex commit SHA。同 tag draft 只允许失败重跑刷新；同 tag 一旦公开，
+任何重跑都必须拒绝修改。
+
+## 回滚
+
+- 使用独立 prerelease 标签 `v1.0.0-beta.3`；不移动或复用 `v1.0.0-beta.1`、
+  `v1.0.0-beta.2` 或正式版标签。
+- 发布资产附 SHA-256；回滚前先复制 `.opentake` 工程包，避免旧版本保存时忽略新增字段。
+- 如 Beta 3 公开后发现回归，保留 Beta 3 tag 和资产作为审计记录，用户回退到上一份已验证的
+  已公开版本；修复通过全部门禁后使用更高的新 prerelease 版本发布。
+- `v1.0.0-beta.3` 一旦公开，不能通过 dispatch 重写。
diff --git a/scripts/check_release_workflow.py b/scripts/check_release_workflow.py
index a69ce11c..866e5f49 100644
--- a/scripts/check_release_workflow.py
+++ b/scripts/check_release_workflow.py
@@ -150,7 +150,7 @@
 }
 
 APPROVED_COMPLEX_RUN_SHA256 = {
-    ("validate", "Validate tag, source SHA, versions, and notes"): "114907da46e6f150a5ce50aa6ae26550e7f39e6f188f21f5320aedfc96e53b0b",
+    ("validate", "Validate tag, source SHA, versions, and notes"): "120a1dc8347fb5989f607f6965b1f9ce5167e934a41631d1ac0cee01e0b83876",
     ("validate", "Reassert exact source after validation"): "953657d26d2eda8490c18e7030c66ddb19aba64a5c8b19808da9a853fd1bfdd2",
     ("quality", "Assert exact checked-out SHA"): "ff0b148eecdf8603712586a6c4a05e752df0b36b5c97a366760f6cba10e58ddd",
     ("quality", "Free disk space"): "5848415c4d0e696f46965d62a2e17c8b7a0dd45ae600d28102af0b04108d9bf6",
@@ -186,7 +186,7 @@
 }
 
 APPROVED_JOB_SHA256 = {
-    "validate": "d446090c0f2defabe5820b2908ce75d980a2a9194f815c69a662739af17722e9",
+    "validate": "386c4e21bdcc884a2246eea1d078b12378b25bfef52043e5e9520a2845f51142",
     "quality": "43599825f68088f3cc744220227267f77454e2c7ce389a52b8aee5a492491eec",
     "macos_arm64": "f913508e4f041614a967f680515cc0b8779800f0b2a7b4b6ff29f24f4bb1efd2",
     "windows_x64": "5f012278c20843ba1b38cffb27f3c614716bd92e3fec63a11885b41692be78b5",
@@ -769,6 +769,8 @@ def validate_workflow(workflow: str) -> list[str]:
             'web = json.loads(Path("web/package.json").read_text(encoding="utf-8"))',
             'notes = Path("docs/releases") / f"{version}.md"',
             'if versions != {version}:',
+            'wix_version = tauri["bundle"]["windows"]["wix"]["version"]',
+            'if wix_version != "1.0.0.3":',
         ),
     ):
         errors.append("Cargo, Tauri, and Web versions match tag")
@@ -776,11 +778,11 @@ def validate_workflow(workflow: str) -> list[str]:
         bind,
         (
             'if SEMVER_RE.fullmatch(tag) is None:',
-            'if version == "1.0.0-beta.2" and not prerelease:',
+            'if version == "1.0.0-beta.3" and not prerelease:',
             'emit("prerelease", "true")',
         ),
     ):
-        errors.append("Beta 2 is a SemVer prerelease")
+        errors.append("Beta 3 is a SemVer prerelease")
     if not _has_code_lines(bind, validate_order[1:5]):
         errors.append("validate binds exact clean checkout")
 
@@ -1126,14 +1128,19 @@ def validate_repository_metadata(repository_root: Path) -> list[str]:
             tauri["version"],
             web["version"],
         }
+        wix_version = tauri["bundle"]["windows"]["wix"]["version"]
         if not all(isinstance(version, str) for version in versions):
             raise TypeError("version metadata values must be strings")
+        if not isinstance(wix_version, str):
+            raise TypeError("Windows installer version must be a string")
     except (KeyError, OSError, TypeError, UnicodeError, ValueError):
         return ["readable Cargo, Tauri, and Web version metadata"]
 
-    if versions != {"1.0.0-beta.2"}:
-        errors.append("repository metadata is OpenTake 1.0.0-beta.2")
-    notes = repository_root / "docs" / "releases" / "1.0.0-beta.2.md"
+    if versions != {"1.0.0-beta.3"}:
+        errors.append("repository metadata is OpenTake 1.0.0-beta.3")
+    if wix_version != "1.0.0.3":
+        errors.append("Windows installer version is 1.0.0.3")
+    notes = repository_root / "docs" / "releases" / "1.0.0-beta.3.md"
     try:
         notes_missing = not notes.is_file() or not notes.read_text(
             encoding="utf-8"
@@ -1141,7 +1148,7 @@ def validate_repository_metadata(repository_root: Path) -> list[str]:
     except (OSError, UnicodeError):
         notes_missing = True
     if notes_missing:
-        errors.append("Beta 2 release notes exist")
+        errors.append("Beta 3 release notes exist")
     return errors
 
 
diff --git a/scripts/test_check_release_workflow.py b/scripts/test_check_release_workflow.py
index 7c2198f0..1fe5341f 100644
--- a/scripts/test_check_release_workflow.py
+++ b/scripts/test_check_release_workflow.py
@@ -58,6 +58,13 @@ def test_validation_must_compare_all_public_versions(self) -> None:
         )
         self.assert_rejected(mutated, "Cargo, Tauri, and Web versions match tag")
 
+    def test_validation_must_bind_windows_installer_version(self) -> None:
+        mutated = self.mutate(
+            'if wix_version != "1.0.0.3":',
+            'if wix_version != "1.0.0.2":',
+        )
+        self.assert_rejected(mutated, "Cargo, Tauri, and Web versions match tag")
+
     def test_publish_must_depend_on_every_gate(self) -> None:
         mutated = self.mutate(
             "needs: [validate, quality, macos_arm64, windows_x64]",
@@ -386,7 +393,7 @@ def test_publish_command_cannot_be_faked_by_echo(self) -> None:
         )
         self.assert_rejected(mutated, "verified prerelease publication")
 
-    def test_repository_metadata_is_beta2_and_release_notes_exist(self) -> None:
+    def test_repository_metadata_is_beta3_and_release_notes_exist(self) -> None:
         self.assertEqual([], contract.validate_repository_metadata(REPOSITORY_ROOT))
 
 
@@ -398,15 +405,21 @@ def make_repository(self) -> tuple[tempfile.TemporaryDirectory[str], Path]:
         (root / "web").mkdir()
         (root / "docs" / "releases").mkdir(parents=True)
         (root / "Cargo.toml").write_text(
-            '[workspace.package]\nversion = "1.0.0-beta.2"\n', encoding="utf-8"
+            '[workspace.package]\nversion = "1.0.0-beta.3"\n', encoding="utf-8"
         )
         (root / "src-tauri" / "tauri.conf.json").write_text(
-            json.dumps({"version": "1.0.0-beta.2"}), encoding="utf-8"
+            json.dumps(
+                {
+                    "version": "1.0.0-beta.3",
+                    "bundle": {"windows": {"wix": {"version": "1.0.0.3"}}},
+                }
+            ),
+            encoding="utf-8",
         )
         (root / "web" / "package.json").write_text(
-            json.dumps({"version": "1.0.0-beta.2"}), encoding="utf-8"
+            json.dumps({"version": "1.0.0-beta.3"}), encoding="utf-8"
         )
-        (root / "docs" / "releases" / "1.0.0-beta.2.md").write_text(
+        (root / "docs" / "releases" / "1.0.0-beta.3.md").write_text(
             "release notes\n", encoding="utf-8"
         )
         return temporary, root
@@ -425,7 +438,7 @@ def test_non_object_json_metadata_returns_a_contract_error(self) -> None:
     def test_release_notes_io_error_returns_a_contract_error(self) -> None:
         temporary, root = self.make_repository()
         self.addCleanup(temporary.cleanup)
-        notes = root / "docs" / "releases" / "1.0.0-beta.2.md"
+        notes = root / "docs" / "releases" / "1.0.0-beta.3.md"
         real_read_text = Path.read_text
 
         def fail_notes(path: Path, *args, **kwargs):
@@ -435,10 +448,27 @@ def fail_notes(path: Path, *args, **kwargs):
 
         with mock.patch.object(Path, "read_text", autospec=True, side_effect=fail_notes):
             self.assertEqual(
-                ["Beta 2 release notes exist"],
+                ["Beta 3 release notes exist"],
                 contract.validate_repository_metadata(root),
             )
 
+    def test_wrong_windows_installer_version_returns_a_contract_error(self) -> None:
+        temporary, root = self.make_repository()
+        self.addCleanup(temporary.cleanup)
+        (root / "src-tauri" / "tauri.conf.json").write_text(
+            json.dumps(
+                {
+                    "version": "1.0.0-beta.3",
+                    "bundle": {"windows": {"wix": {"version": "1.0.0.2"}}},
+                }
+            ),
+            encoding="utf-8",
+        )
+        self.assertEqual(
+            ["Windows installer version is 1.0.0.3"],
+            contract.validate_repository_metadata(root),
+        )
+
 
 class ReleaseDraftStateMachineTests(unittest.TestCase):
     def release_payload(self, *, draft: bool) -> dict[str, object]:
@@ -447,7 +477,7 @@ def release_payload(self, *, draft: bool) -> dict[str, object]:
                 "repository": {
                     "release": {
                         "databaseId": 123,
-                        "tagName": "v1.0.0-beta.2",
+                        "tagName": "v1.0.0-beta.3",
                         "tagCommit": {"oid": "a" * 40},
                         "isDraft": draft,
                         "isPrerelease": True,
@@ -469,13 +499,13 @@ def resolver(self):
 
     def test_missing_release_plans_draft_creation(self) -> None:
         payload = {"data": {"repository": {"release": None}}}
-        plan = self.resolver()(payload, "v1.0.0-beta.2", "a" * 40)
+        plan = self.resolver()(payload, "v1.0.0-beta.3", "a" * 40)
         self.assertEqual("create", plan["action"])
         self.assertEqual([], plan["asset_node_ids"])
 
     def test_same_tag_draft_plans_refresh_with_existing_assets(self) -> None:
         plan = self.resolver()(
-            self.release_payload(draft=True), "v1.0.0-beta.2", "a" * 40
+            self.release_payload(draft=True), "v1.0.0-beta.3", "a" * 40
         )
         self.assertEqual("refresh", plan["action"])
         self.assertEqual(["RA_old"], plan["asset_node_ids"])
@@ -487,7 +517,7 @@ def test_published_release_fails_before_any_asset_delete_plan(self) -> None:
             error_type, "release is already published; refusing to mutate it"
         ):
             self.resolver()(
-                self.release_payload(draft=False), "v1.0.0-beta.2", "a" * 40
+                self.release_payload(draft=False), "v1.0.0-beta.3", "a" * 40
             )
 
 
@@ -499,20 +529,20 @@ def resolver(self):
 
     def test_lightweight_tag_resolves_direct_commit(self) -> None:
         sha = "a" * 40
-        refs = f"{sha}\trefs/tags/v1.0.0-beta.2\n"
+        refs = f"{sha}\trefs/tags/v1.0.0-beta.3\n"
         self.assertEqual(
-            sha, self.resolver()(refs, "v1.0.0-beta.2")
+            sha, self.resolver()(refs, "v1.0.0-beta.3")
         )
 
     def test_annotated_tag_resolves_peeled_commit(self) -> None:
         tag_object = "b" * 40
         commit = "c" * 40
         refs = (
-            f"{tag_object}\trefs/tags/v1.0.0-beta.2\n"
-            f"{commit}\trefs/tags/v1.0.0-beta.2^{{}}\n"
+            f"{tag_object}\trefs/tags/v1.0.0-beta.3\n"
+            f"{commit}\trefs/tags/v1.0.0-beta.3^{{}}\n"
         )
         self.assertEqual(
-            commit, self.resolver()(refs, "v1.0.0-beta.2")
+            commit, self.resolver()(refs, "v1.0.0-beta.3")
         )
 
 
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 2c50b185..ff57227e 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "OpenTake",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "identifier": "com.opentake.desktop",
   "build": {
     "frontendDist": "../web/dist",
@@ -96,7 +96,7 @@
     },
     "windows": {
       "wix": {
-        "version": "1.0.0.2"
+        "version": "1.0.0.3"
       }
     }
   }
diff --git a/web/package.json b/web/package.json
index 326bd132..b6ca2be7 100644
--- a/web/package.json
+++ b/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "opentake-web",
   "private": true,
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "type": "module",
   "scripts": {
     "dev": "vite",

From 2bb4adf4617ec8193fc684a4a9f86d4d19c706cf Mon Sep 17 00:00:00 2001
From: baiqing <lbx12309@icloud.com>
Date: Mon, 10 Aug 2026 00:23:52 +0800
Subject: [PATCH 4/4] fix(motion): synchronize reused Chromium viewport

---
 crates/opentake-motion/src/renderer.rs | 97 ++++++++++++++++++++------
 1 file changed, 77 insertions(+), 20 deletions(-)

diff --git a/crates/opentake-motion/src/renderer.rs b/crates/opentake-motion/src/renderer.rs
index 15be845d..b2fae88c 100644
--- a/crates/opentake-motion/src/renderer.rs
+++ b/crates/opentake-motion/src/renderer.rs
@@ -1779,6 +1779,26 @@ mod chromium_backend {
             width: u32,
             height: u32,
         ) -> MotionResult<()> {
+            // Screencast sizing is based on the compositor surface, so resize
+            // the browser contents before overriding the logical viewport.
+            let window = self.command("Browser.getWindowForTarget", json!({}), Some(session))?;
+            let window_id = window
+                .get("windowId")
+                .and_then(Value::as_u64)
+                .ok_or_else(|| {
+                    MotionError::render_failed(format!(
+                        "Chromium CDP response is missing integer field \"windowId\": {window}"
+                    ))
+                })?;
+            self.command(
+                "Browser.setContentsSize",
+                json!({
+                    "windowId": window_id,
+                    "width": width,
+                    "height": height
+                }),
+                None,
+            )?;
             self.command(
                 "Emulation.setDeviceMetricsOverride",
                 device_metrics_params(width, height),
@@ -3167,7 +3187,7 @@ mod chromium_backend {
         }
 
         #[test]
-        fn device_metrics_keep_layout_and_capture_viewport_exact() {
+        fn browser_contents_are_resized_before_device_metrics() {
             let listener = TcpListener::bind("127.0.0.1:0").unwrap();
             let client_stream = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
             let (server_stream, _) = listener.accept().unwrap();
@@ -3177,15 +3197,64 @@ mod chromium_backend {
                 None,
             );
             let mut server_socket = WebSocket::from_raw_socket(server_stream, Role::Server, None);
+            let (observed_sender, observed_receiver) = mpsc::channel();
             let server = thread::spawn(move || {
-                let request = match server_socket.read().unwrap() {
-                    Message::Text(text) => serde_json::from_str::<Value>(text.as_ref()).unwrap(),
-                    other => panic!("expected device-metrics request, got {other:?}"),
-                };
-                assert_eq!(
-                    request,
+                let mut observed = Vec::new();
+                loop {
+                    let request = match server_socket.read().unwrap() {
+                        Message::Text(text) => {
+                            serde_json::from_str::<Value>(text.as_ref()).unwrap()
+                        }
+                        other => panic!("expected viewport-sizing request, got {other:?}"),
+                    };
+                    let id = request["id"].as_u64().unwrap();
+                    let method = request["method"].as_str().unwrap().to_owned();
+                    let result = if method == "Browser.getWindowForTarget" {
+                        json!({"windowId": 42, "bounds": {}})
+                    } else {
+                        json!({})
+                    };
+                    server_socket
+                        .send(Message::text(
+                            json!({"id": id, "result": result}).to_string(),
+                        ))
+                        .unwrap();
+                    observed.push(request);
+                    if method == "Emulation.setDeviceMetricsOverride" {
+                        break;
+                    }
+                }
+                observed_sender.send(observed).unwrap();
+            });
+
+            let mut cdp = Cdp::new(
+                client_socket,
+                SandboxPolicy::default(),
+                MotionCancellationToken::new(),
+                Instant::now() + Duration::from_secs(1),
+            );
+            cdp.set_device_metrics("render-session", 48, 32).unwrap();
+            server.join().unwrap();
+            assert_eq!(
+                observed_receiver.recv().unwrap(),
+                vec![
                     json!({
                         "id": 1,
+                        "method": "Browser.getWindowForTarget",
+                        "params": {},
+                        "sessionId": "render-session"
+                    }),
+                    json!({
+                        "id": 2,
+                        "method": "Browser.setContentsSize",
+                        "params": {
+                            "windowId": 42,
+                            "width": 48,
+                            "height": 32
+                        }
+                    }),
+                    json!({
+                        "id": 3,
                         "method": "Emulation.setDeviceMetricsOverride",
                         "params": {
                             "width": 48,
@@ -3197,20 +3266,8 @@ mod chromium_backend {
                         },
                         "sessionId": "render-session"
                     })
-                );
-                server_socket
-                    .send(Message::text(json!({"id": 1, "result": {}}).to_string()))
-                    .unwrap();
-            });
-
-            let mut cdp = Cdp::new(
-                client_socket,
-                SandboxPolicy::default(),
-                MotionCancellationToken::new(),
-                Instant::now() + Duration::from_secs(1),
+                ]
             );
-            cdp.set_device_metrics("render-session", 48, 32).unwrap();
-            server.join().unwrap();
         }
 
         #[test]