perf(studio): preview scale selector and prefetch worker pool

Heavy scenarios (glass, camera, parallax) cost ~150ms CPU per frame at
full resolution — 4.5x the 33ms budget of 30fps playback — and the
single prefetch thread rendered at scale 1.0, so the cache drained and
playback stalled while the exported MP4 (parallel, offline) was smooth.

- render preview frames at a UI-selected scale (100/75/50/25%, default
  50%); the scale is part of the frame cache key and a scale switch
  purges stale-scale entries on first insert
- replace the single prefetch thread with a worker pool
  (cores-2, clamped to [2,6]); workers spread over the window through a
  shared claim set so no frame is rendered twice concurrently
- the transport bar gains a preview-quality select; export still
  renders at 100%

Author: LeadcodeDev

crates/rustmotion-studio/src/editor/frames.rs

@@ -185,6 +185,15 @@ mod tests {
         assert_eq!(&jpeg[0..2], &[0xFF, 0xD8], "must be a JPEG");
     }
 
+    #[test]
+    fn renders_frame_at_reduced_scale() {
+        let scenario = rustmotion::loader::load_scenario_from_source(None, Some(SCENARIO)).unwrap();
+        let tasks = rustmotion::encode::build_frame_tasks(&scenario);
+        let jpeg = render_frame(&scenario, &tasks, 0, 0.5);
+        let img = image::load_from_memory(&jpeg).expect("decodable JPEG");
+        assert_eq!((img.width(), img.height()), (640, 360), "half of 1280x720");
+    }
+
     #[test]
     fn frame_hits_are_in_percent_and_have_kind() {
         let json = r##"{ "video": { "width": 800, "height": 600, "background": "#101418" }, "scenes": [ { "duration": 1.0, "children": [ { "type": "text", "content": "Hi", "style": { "font-size": 40 } } ] } ] }"##;

crates/rustmotion-studio/src/editor/playback.rs

@@ -4,8 +4,11 @@ use dioxus::prelude::*;
 use dioxus_icons::lucide::{Pause, Play};
 
 use crate::components::button::{Button, ButtonSize, ButtonVariant};
+use crate::components::select::{Select, SelectOption};
 use crate::scenario::Shared;
 
+use super::prefetch::{set_preview_scale_pct, PREVIEW_SCALE_CHOICES};
+
 /// What a playback keyboard shortcut does (see [`playback_action`]).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PlaybackAction {
@@ -93,6 +96,7 @@ pub fn PlaybackBar(
     total: u32,
     diff_active: Signal<bool>,
     mut diff_side: Signal<super::diff_panel::DiffSide>,
+    mut preview_scale: Signal<u16>,
 ) -> Element {
     use super::diff_panel::DiffSide;
 
@@ -162,6 +166,34 @@ pub fn PlaybackBar(
                     }
                 },
             }
+            // Preview quality: render scale of the preview frames only (the
+            // export always renders at 100%). Lower = smoother playback on
+            // heavy scenarios (glass, camera, parallax).
+            div {
+                title: "Preview quality (export is always 100%)",
+                style: "width:96px; flex:none;",
+                Select::<u16> {
+                    default_value: Some(preview_scale()),
+                    on_value_change: move |v: Option<u16>| {
+                        if let Some(pct) = v {
+                            // Atomic first: the render threads and the asset
+                            // handler must see the new scale before the signal
+                            // change triggers the <img> refetch.
+                            set_preview_scale_pct(pct);
+                            preview_scale.set(pct);
+                        }
+                    },
+                    for (i, pct) in PREVIEW_SCALE_CHOICES.iter().enumerate() {
+                        SelectOption::<u16> {
+                            key: "{pct}",
+                            index: i,
+                            value: *pct,
+                            text_value: "{pct}%",
+                            "{pct}%"
+                        }
+                    }
+                }
+            }
             div { style: "min-width:120px; text-align:right; color:var(--rm-text-muted);",
                 "{cur} / {max}"
             }