feat: GPUI desktop port foundation

- scene crate: full project/scene/element model, serde round-trip
  proven against the web SerializedProject shape
- transfer crate: .ocp zip container, cross-compat with web fflate
  archives proven in both directions
- storage crate: filesystem project store replacing IndexedDB,
  .ocp import/export
- media crate: ffmpeg-next 8 decoder (frames, audio, thumbnails,
  waveform summaries)
- playback crate: wall-clock anchored, frame-rounded playback clock
- gpu crate: native texture readback; compositor renders headless
  offscreen on Vulkan (spike test)
- flake devshell: rust toolchain, GPUI native deps, ffmpeg dev,
  bindgen clang args; GPUI hello-world builds
- port plan in notes/gpui-port.md

1 files changed, 101 insertions, 0 deletions

diff --git a/rust/crates/timeline/src/placement/apply.rs b/rust/crates/timeline/src/placement/apply.rs
new file mode 100644
index 00000000..4e044a68
--- /dev/null
+++ b/rust/crates/timeline/src/placement/apply.rs
@@ -0,0 +1,101 @@
+use scene::{Element, SceneTracks, Track};
+
+use super::track_factory::build_empty_track;
+use super::{PlacementResult, ordered_tracks};
+use crate::track_element_update::update_track_in_scene_tracks;
+use crate::types::TrackType;
+
+pub struct PlacementApplied {
+    pub updated_tracks: SceneTracks,
+    pub target_track_id: String,
+}
+
+pub struct ApplyPlacementParams {
+    pub tracks: SceneTracks,
+    pub placement_result: PlacementResult,
+    pub elements: Vec<Element>,
+    pub new_track_id: String,
+    pub new_track_insert_index_override: Option<usize>,
+}
+
+pub fn apply_placement(params: &ApplyPlacementParams) -> Option<PlacementApplied> {
+    let tracks = &params.tracks;
+    match &params.placement_result {
+        PlacementResult::ExistingTrack { track_index, .. } => {
+            let ordered = ordered_tracks(tracks);
+            let target_track = ordered.get(*track_index)?;
+
+            let updated_tracks =
+                update_track_in_scene_tracks(tracks, target_track.id(), |track| {
+                    let mut next = track.clone();
+                    next.elements_mut().extend(params.elements.iter().cloned());
+                    next
+                });
+
+            Some(PlacementApplied {
+                updated_tracks,
+                target_track_id: target_track.id().to_string(),
+            })
+        }
+        PlacementResult::NewTrack {
+            track_type,
+            insert_index,
+            ..
+        } => {
+            let new_track_id = params.new_track_id.clone();
+            let insert_index = params
+                .new_track_insert_index_override
+                .unwrap_or(*insert_index);
+            let new_track = build_empty_track(new_track_id.clone(), *track_type, None)
+                .with_elements(params.elements.clone());
+
+            let updated_tracks = if *track_type == TrackType::Audio {
+                SceneTracks {
+                    audio: insert_into_audio_tracks(tracks, insert_index, new_track),
+                    ..tracks.clone()
+                }
+            } else {
+                SceneTracks {
+                    overlay: insert_into_overlay_tracks(tracks, insert_index, new_track),
+                    ..tracks.clone()
+                }
+            };
+
+            Some(PlacementApplied {
+                updated_tracks,
+                target_track_id: new_track_id,
+            })
+        }
+    }
+}
+
+fn insert_into_overlay_tracks(
+    tracks: &SceneTracks,
+    insert_index: usize,
+    track: Track,
+) -> Vec<Track> {
+    let normalized = insert_index.min(tracks.overlay.len());
+    let mut next = tracks.overlay.clone();
+    next.insert(normalized, track);
+    next
+}
+
+fn insert_into_audio_tracks(tracks: &SceneTracks, insert_index: usize, track: Track) -> Vec<Track> {
+    let audio_index = insert_index
+        .saturating_sub(tracks.overlay.len() + 1)
+        .min(tracks.audio.len());
+    let mut next = tracks.audio.clone();
+    next.insert(audio_index, track);
+    next
+}
+
+trait WithElements {
+    fn with_elements(self, elements: Vec<Element>) -> Self;
+}
+
+impl WithElements for Track {
+    fn with_elements(mut self, elements: Vec<Element>) -> Self {
+        *self.elements_mut() = elements;
+        self
+    }
+}