feat: port domain crates to Rust (session 1 complete)

All green: cargo test --workspace (~300 tests, 0 failures).
- timeline (45): placement, resize/ripple, split, snap, retime,
  audio separation, scene helpers
- animation (73): bezier solver, channel sampling, keyframe ops,
  split/clamp/clone, param definitions
- commands (9): Command trait, BatchCommand, history, 19 concrete
  commands, freeze-frame port 1:1
- audio (22): audible collection, range mixing, mastering limiter,
  rms/peak buckets
- text (19): cosmic-text layout/measure/raster, backgrounds,
  decorations
- graphics (52): full CSS gradient parser, tiny-skia raster,
  4 shape definitions
- effect-defs (16): blur definition, registry, pass resolution
- mask-defs (19): all 9 mask renderers via tiny-skia
- renderer (6): node model + scene builder port
- desktop: GPUI projects screen wired to ProjectStore
- scene: factory (web defaults: v32, Main Track, 1920x1080, 30fps)

4 files changed, 446 insertions, 0 deletions

diff --git a/rust/crates/audio/tests/collection.rs b/rust/crates/audio/tests/collection.rs
new file mode 100644
index 00000000..6c1f8a9f
--- /dev/null
+++ b/rust/crates/audio/tests/collection.rs
@@ -0,0 +1,263 @@
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+
+use audio::collect_audible_elements;
+use scene::{
+    AudioElement, BaseTimelineElement, Element, LibraryAudioElement, ParamValue, RetimeConfig,
+    SceneTracks, Track, UploadAudioElement, VideoElement,
+};
+use time::MediaTime;
+
+fn seconds(value: f64) -> MediaTime {
+    MediaTime::from_seconds_f64(value).expect("finite seconds")
+}
+
+fn base(id: &str, start: f64, duration: f64) -> BaseTimelineElement {
+    BaseTimelineElement {
+        id: id.to_string(),
+        name: id.to_string(),
+        duration: seconds(duration),
+        start_time: seconds(start),
+        trim_start: MediaTime::ZERO,
+        trim_end: MediaTime::ZERO,
+        source_duration: None,
+        animations: None,
+        params: BTreeMap::new(),
+    }
+}
+
+fn upload_audio(id: &str, start: f64, duration: f64) -> Element {
+    Element::Audio(AudioElement::Upload(UploadAudioElement {
+        base: base(id, start, duration),
+        retime: None,
+        media_id: format!("media-{id}"),
+    }))
+}
+
+fn library_audio(id: &str, start: f64, duration: f64) -> Element {
+    Element::Audio(AudioElement::Library(LibraryAudioElement {
+        base: base(id, start, duration),
+        retime: None,
+        source_url: format!("https://cdn.test/{id}.mp3"),
+    }))
+}
+
+fn video(id: &str, start: f64, duration: f64) -> Element {
+    Element::Video(VideoElement {
+        base: base(id, start, duration),
+        media_id: format!("media-{id}"),
+        is_source_audio_enabled: None,
+        hidden: None,
+        retime: None,
+        effects: None,
+        masks: None,
+    })
+}
+
+fn main_track(elements: Vec<Element>) -> Track {
+    Track::Video {
+        id: "main".to_string(),
+        name: "main".to_string(),
+        elements,
+        muted: false,
+        hidden: false,
+    }
+}
+
+fn audio_track(id: &str, muted: bool, elements: Vec<Element>) -> Track {
+    Track::Audio {
+        id: id.to_string(),
+        name: id.to_string(),
+        elements,
+        muted,
+    }
+}
+
+fn tracks(main: Vec<Element>, audio: Vec<Track>) -> SceneTracks {
+    SceneTracks {
+        overlay: vec![],
+        main: main_track(main),
+        audio,
+    }
+}
+
+fn resolve_any(key: &str) -> Option<PathBuf> {
+    Some(PathBuf::from(key))
+}
+
+fn full_range() -> (MediaTime, MediaTime) {
+    (MediaTime::ZERO, seconds(60.0))
+}
+
+#[test]
+fn collects_upload_audio_and_video_with_source_audio() {
+    let scene = tracks(
+        vec![video("v1", 0.0, 2.0)],
+        vec![audio_track("a", false, vec![upload_audio("u1", 1.0, 1.0)])],
+    );
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert_eq!(clips.len(), 2);
+    assert_eq!(clips[0].element_id, "v1");
+    assert_eq!(clips[1].element_id, "u1");
+    assert_eq!(clips[0].path, PathBuf::from("media-v1"));
+    assert_eq!(clips[1].start_time, seconds(1.0));
+    assert_eq!(clips[1].duration, seconds(1.0));
+}
+
+#[test]
+fn library_audio_resolves_by_source_url() {
+    let scene = tracks(
+        vec![],
+        vec![audio_track("a", false, vec![library_audio("lib", 0.0, 1.0)])],
+    );
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert_eq!(clips.len(), 1);
+    assert_eq!(clips[0].path, PathBuf::from("https://cdn.test/lib.mp3"));
+}
+
+#[test]
+fn muted_track_excludes_its_elements() {
+    let scene = tracks(
+        vec![],
+        vec![
+            audio_track("muted-track", true, vec![upload_audio("u1", 0.0, 1.0)]),
+            audio_track("live-track", false, vec![upload_audio("u2", 0.0, 1.0)]),
+        ],
+    );
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert_eq!(clips.len(), 1);
+    assert_eq!(clips[0].element_id, "u2");
+}
+
+#[test]
+fn muted_element_is_excluded() {
+    let mut element = match upload_audio("u1", 0.0, 1.0) {
+        Element::Audio(AudioElement::Upload(mut upload)) => {
+            upload
+                .base
+                .params
+                .insert("muted".to_string(), ParamValue::Bool(true));
+            Element::Audio(AudioElement::Upload(upload))
+        }
+        other => other,
+    };
+    let scene = tracks(vec![], vec![audio_track("a", false, vec![element])]);
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert!(clips.is_empty());
+
+    element = match upload_audio("u2", 0.0, 1.0) {
+        Element::Audio(AudioElement::Upload(mut upload)) => {
+            upload
+                .base
+                .params
+                .insert("muted".to_string(), ParamValue::Bool(false));
+            Element::Audio(AudioElement::Upload(upload))
+        }
+        other => other,
+    };
+    let scene = tracks(vec![], vec![audio_track("a", false, vec![element])]);
+    assert_eq!(collect_audible_elements(&scene, &resolve_any, full_range()).len(), 1);
+}
+
+#[test]
+fn hidden_video_is_excluded() {
+    let hidden = Element::Video(VideoElement {
+        hidden: Some(true),
+        ..match video("v1", 0.0, 2.0) {
+            Element::Video(v) => v,
+            _ => unreachable!(),
+        }
+    });
+    let scene = tracks(vec![hidden], vec![]);
+    assert!(collect_audible_elements(&scene, &resolve_any, full_range()).is_empty());
+}
+
+#[test]
+fn video_with_source_audio_disabled_is_excluded() {
+    let disabled = Element::Video(VideoElement {
+        is_source_audio_enabled: Some(false),
+        ..match video("v1", 0.0, 2.0) {
+            Element::Video(v) => v,
+            _ => unreachable!(),
+        }
+    });
+    let enabled = Element::Video(VideoElement {
+        is_source_audio_enabled: Some(true),
+        ..match video("v2", 0.0, 2.0) {
+            Element::Video(v) => v,
+            _ => unreachable!(),
+        }
+    });
+    let scene = tracks(vec![disabled, enabled], vec![]);
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert_eq!(clips.len(), 1);
+    assert_eq!(clips[0].element_id, "v2");
+}
+
+#[test]
+fn range_overlap_trims_collection() {
+    let scene = tracks(
+        vec![video("v1", 2.0, 2.0), video("v2", 10.0, 2.0)],
+        vec![],
+    );
+    let clips = collect_audible_elements(&scene, &resolve_any, (seconds(3.0), seconds(4.5)));
+    assert_eq!(clips.len(), 1);
+    assert_eq!(clips[0].element_id, "v1");
+
+    let clips = collect_audible_elements(&scene, &resolve_any, (seconds(4.0), seconds(10.0)));
+    assert!(clips.is_empty());
+
+    let clips = collect_audible_elements(&scene, &resolve_any, (seconds(4.0), seconds(10.5)));
+    assert_eq!(clips.len(), 1);
+    assert_eq!(clips[0].element_id, "v2");
+}
+
+#[test]
+fn volume_param_is_decibels_with_zero_default() {
+    let quiet = match upload_audio("u1", 0.0, 1.0) {
+        Element::Audio(AudioElement::Upload(mut upload)) => {
+            upload
+                .base
+                .params
+                .insert("volume".to_string(), ParamValue::Number(-6.0));
+            Element::Audio(AudioElement::Upload(upload))
+        }
+        other => other,
+    };
+    let plain = upload_audio("u2", 0.0, 1.0);
+    let scene = tracks(vec![], vec![audio_track("a", false, vec![quiet, plain])]);
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert_eq!(clips[0].volume_db, -6.0);
+    assert_eq!(clips[1].volume_db, 0.0);
+    assert!((clips[0].static_gain() - 0.5012).abs() < 0.001);
+    assert_eq!(clips[1].static_gain(), 1.0);
+}
+
+#[test]
+fn retime_and_trim_are_carried() {
+    let element = match upload_audio("u1", 0.0, 0.5) {
+        Element::Audio(AudioElement::Upload(mut upload)) => {
+            upload.base.trim_start = seconds(0.25);
+            upload.base.trim_end = seconds(0.25);
+            upload.retime = Some(RetimeConfig {
+                rate: 2.0,
+                maintain_pitch: None,
+            });
+            Element::Audio(AudioElement::Upload(upload))
+        }
+        other => other,
+    };
+    let scene = tracks(vec![], vec![audio_track("a", false, vec![element])]);
+    let clips = collect_audible_elements(&scene, &resolve_any, full_range());
+    assert_eq!(clips.len(), 1);
+    assert_eq!(clips[0].trim_start, seconds(0.25));
+    assert_eq!(clips[0].effective_rate(), 2.0);
+    assert!(!clips[0].requires_maintain_pitch());
+}
+
+#[test]
+fn unresolvable_media_is_excluded() {
+    let scene = tracks(vec![video("v1", 0.0, 1.0)], vec![]);
+    let clips = collect_audible_elements(&scene, &|_| None, full_range());
+    assert!(clips.is_empty());
+}
diff --git a/rust/crates/audio/tests/fixtures/sample.mp4 b/rust/crates/audio/tests/fixtures/sample.mp4
new file mode 100644
index 00000000..13c113e5
--- /dev/null
+++ b/rust/crates/audio/tests/fixtures/sample.mp4
diff --git a/rust/crates/audio/tests/fixtures/tone.wav b/rust/crates/audio/tests/fixtures/tone.wav
new file mode 100644
index 00000000..8d5f7886
--- /dev/null
+++ b/rust/crates/audio/tests/fixtures/tone.wav
diff --git a/rust/crates/audio/tests/mix.rs b/rust/crates/audio/tests/mix.rs
new file mode 100644
index 00000000..6d0ed0d1
--- /dev/null
+++ b/rust/crates/audio/tests/mix.rs
@@ -0,0 +1,183 @@
+use std::path::PathBuf;
+
+use audio::{
+    AudibleClip, Error, apply_mastering, extract_rms_buckets, mix_range, render_export_buffer,
+};
+use media::Decoder;
+use scene::RetimeConfig;
+use time::MediaTime;
+
+const TONE_WAV: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/tone.wav");
+
+fn seconds(value: f64) -> MediaTime {
+    MediaTime::from_seconds_f64(value).expect("finite seconds")
+}
+
+fn tone_clip(id: &str, start: f64, duration: f64) -> AudibleClip {
+    AudibleClip {
+        element_id: id.to_string(),
+        path: PathBuf::from(TONE_WAV),
+        start_time: seconds(start),
+        duration: seconds(duration),
+        trim_start: MediaTime::ZERO,
+        trim_end: MediaTime::ZERO,
+        volume_db: 0.0,
+        retime: None,
+        animations: None,
+    }
+}
+
+fn decode_tone(start: f64, end: f64) -> (Vec<f32>, u32, usize) {
+    let mut decoder = Decoder::open(TONE_WAV).expect("open tone.wav");
+    let stream = decoder.info().audio_streams.first().cloned().expect("audio stream");
+    let decoded = decoder
+        .decode_audio_range(stream.index, seconds(start), seconds(end))
+        .expect("decode tone");
+    (decoded.samples, decoded.sample_rate, decoded.channels as usize)
+}
+
+#[test]
+fn two_overlapping_tones_sum() {
+    let clip_a = tone_clip("a", 0.0, 1.0);
+    let clip_b = tone_clip("b", 0.0, 1.0);
+    let single = mix_range(&[clip_a.clone()], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap();
+    let doubled = mix_range(&[clip_a, clip_b], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap();
+    assert_eq!(single.len(), doubled.len());
+    for (one, two) in single.iter().zip(doubled.iter()) {
+        assert!((two - 2.0 * one).abs() < 1e-6, "{two} != 2 * {one}");
+    }
+}
+
+#[test]
+fn volume_param_scales_samples() {
+    let full = tone_clip("full", 0.0, 1.0);
+    let mut half = tone_clip("half", 0.0, 1.0);
+    half.volume_db = -6.020599913279624;
+    let full_mix = mix_range(&[full], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap();
+    let half_mix = mix_range(&[half], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap();
+    for (f, h) in full_mix.iter().zip(half_mix.iter()) {
+        assert!((h - f * 0.5).abs() < 1e-3, "{h} != 0.5 * {f}");
+    }
+}
+
+#[test]
+fn retime_2x_consumes_source_twice_as_fast() {
+    let normal = tone_clip("normal", 0.0, 1.0);
+    let mut fast = tone_clip("fast", 0.0, 0.5);
+    fast.retime = Some(RetimeConfig {
+        rate: 2.0,
+        maintain_pitch: None,
+    });
+    let normal_mix = mix_range(&[normal], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap();
+    let fast_mix = mix_range(&[fast], (seconds(0.0), seconds(0.5)), 44100, 2).unwrap();
+    let frames = fast_mix.len() / 2;
+    for i in 0..frames {
+        for channel in 0..2 {
+            let expected = normal_mix[2 * i * 2 + channel];
+            let actual = fast_mix[i * 2 + channel];
+            assert!((actual - expected).abs() < 1e-6, "frame {i}: {actual} != {expected}");
+        }
+    }
+}
+
+#[test]
+fn trim_start_offsets_source() {
+    let mut clip = tone_clip("trimmed", 0.0, 0.5);
+    clip.trim_start = seconds(0.5);
+    let mix = mix_range(&[clip], (seconds(0.0), seconds(0.5)), 44100, 2).unwrap();
+    let (decoded, _rate, channels) = decode_tone(0.5, 1.0);
+    assert_eq!(channels, 1);
+    let frames = mix.len() / 2;
+    for i in 0..frames {
+        for channel in 0..2 {
+            let actual = mix[i * 2 + channel];
+            assert!((actual - decoded[i]).abs() < 1e-6, "frame {i}: {actual} != {}", decoded[i]);
+        }
+    }
+}
+
+#[test]
+fn rms_buckets_of_tone_match_hand_computed() {
+    let (samples, rate, channels) = decode_tone(0.0, 1.0);
+    let peak = samples.iter().fold(0.0_f32, |p, s| p.max(s.abs()));
+    let expected_rms = peak / 2.0_f32.sqrt();
+    let buckets = extract_rms_buckets(&samples, channels, rate, 10);
+    assert_eq!(buckets.len(), 10);
+    for bucket in &buckets {
+        let relative = (bucket - expected_rms).abs() / expected_rms;
+        assert!(relative < 0.05, "bucket {bucket} vs expected {expected_rms}");
+    }
+}
+
+#[test]
+fn mastering_limits_peaks_on_hot_input() {
+    let frames = 4096;
+    let mut samples = vec![1.5_f32; frames * 2];
+    apply_mastering(&mut samples, 2, 44100);
+    let peak = samples.iter().fold(0.0_f32, |p, s| p.max(s.abs()));
+    assert!(peak <= 0.98, "peak was {peak}");
+    assert!(peak > 0.9, "limiter over-attenuated: peak {peak}");
+}
+
+#[test]
+fn mastering_leaves_quiet_input_untouched() {
+    let mut samples: Vec<f32> = (0..1000).map(|i| (i as f32 / 1000.0) * 0.5).collect();
+    let original = samples.clone();
+    apply_mastering(&mut samples, 1, 44100);
+    assert_eq!(samples, original);
+}
+
+#[test]
+fn maintain_pitch_true_returns_typed_error() {
+    let mut clip = tone_clip("pitched", 0.0, 0.5);
+    clip.retime = Some(RetimeConfig {
+        rate: 2.0,
+        maintain_pitch: Some(true),
+    });
+    let result = mix_range(&[clip], (seconds(0.0), seconds(1.0)), 44100, 2);
+    match result {
+        Err(Error::MaintainPitchUnsupported { element_id, rate }) => {
+            assert_eq!(element_id, "pitched");
+            assert_eq!(rate, 2.0);
+        }
+        other => panic!("expected MaintainPitchUnsupported, got {other:?}"),
+    }
+}
+
+#[test]
+fn maintain_pitch_at_unity_rate_is_allowed() {
+    let mut clip = tone_clip("unity", 0.0, 0.5);
+    clip.retime = Some(RetimeConfig {
+        rate: 1.0,
+        maintain_pitch: Some(true),
+    });
+    assert!(mix_range(&[clip], (seconds(0.0), seconds(0.5)), 44100, 2).is_ok());
+}
+
+#[test]
+fn render_export_buffer_mixes_and_masters() {
+    let clip = tone_clip("a", 0.0, 1.0);
+    let buffer = render_export_buffer(&[clip], seconds(1.0), 44100, 2).unwrap();
+    assert_eq!(buffer.len(), 44100 * 2);
+    let peak = buffer.iter().fold(0.0_f32, |p, s| p.max(s.abs()));
+    assert!(peak > 0.05, "peak was {peak}");
+    assert!(render_export_buffer(&[], seconds(1.0), 44100, 2).unwrap().is_empty());
+}
+
+#[test]
+fn range_render_only_covers_requested_window() {
+    let clip = tone_clip("a", 1.0, 1.0);
+    let buffer = mix_range(&[clip], (seconds(0.0), seconds(2.0)), 44100, 2).unwrap();
+    let first_half = &buffer[..44100 * 2];
+    assert!(first_half.iter().all(|s| *s == 0.0));
+    let second_peak = buffer[44100 * 2..].iter().fold(0.0_f32, |p, s| p.max(s.abs()));
+    assert!(second_peak > 0.05);
+}
+
+#[test]
+fn undecodable_clip_contributes_silence() {
+    let mut clip = tone_clip("missing", 0.0, 1.0);
+    clip.path = PathBuf::from("/nonexistent/nope.wav");
+    let buffer = mix_range(&[clip], (seconds(0.0), seconds(0.5)), 44100, 2).unwrap();
+    assert!(buffer.iter().all(|s| *s == 0.0));
+}