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, 276 insertions, 0 deletions

diff --git a/rust/crates/storage/tests/store.rs b/rust/crates/storage/tests/store.rs
new file mode 100644
index 00000000..696ddde8
--- /dev/null
+++ b/rust/crates/storage/tests/store.rs
@@ -0,0 +1,276 @@
+use chrono::{DateTime, Utc};
+use scene::{
+    Background, BaseTimelineElement, CanvasSize, Element, Project, ProjectMetadata,
+    ProjectSettings, Scene, SceneTracks, Track, VideoElement,
+};
+use storage::ProjectStore;
+use tempfile::TempDir;
+use time::{FrameRate, MediaTime};
+use transfer::ArchivedMediaMetadata;
+
+fn date(day: u8) -> DateTime<Utc> {
+    DateTime::parse_from_rfc3339(&format!("2026-01-{day:02}T00:00:00Z"))
+        .unwrap()
+        .with_timezone(&Utc)
+}
+
+fn seconds(value: f64) -> MediaTime {
+    MediaTime::from_seconds_f64(value).unwrap()
+}
+
+fn sample_project(id: &str) -> Project {
+    let scene_id = format!("{id}-scene");
+    let element = Element::Video(VideoElement {
+        base: BaseTimelineElement {
+            id: "element-1".to_string(),
+            name: "Clip".to_string(),
+            duration: seconds(5.0),
+            start_time: MediaTime::ZERO,
+            trim_start: MediaTime::ZERO,
+            trim_end: MediaTime::ZERO,
+            source_duration: Some(seconds(10.0)),
+            animations: None,
+            params: Default::default(),
+        },
+        media_id: "media-1".to_string(),
+        is_source_audio_enabled: None,
+        hidden: None,
+        retime: None,
+        effects: None,
+        masks: None,
+    });
+    let scene = Scene {
+        id: scene_id.clone(),
+        name: "Main scene".to_string(),
+        is_main: true,
+        tracks: SceneTracks {
+            overlay: vec![],
+            main: Track::Video {
+                id: "track-1".to_string(),
+                name: "Main".to_string(),
+                elements: vec![element],
+                muted: false,
+                hidden: false,
+            },
+            audio: vec![],
+        },
+        bookmarks: vec![],
+        created_at: date(1),
+        updated_at: date(1),
+    };
+    Project {
+        metadata: ProjectMetadata {
+            id: id.to_string(),
+            name: "Sample Project".to_string(),
+            thumbnail: None,
+            duration: seconds(5.0),
+            created_at: date(1),
+            updated_at: date(2),
+        },
+        scenes: vec![scene],
+        current_scene_id: scene_id,
+        settings: ProjectSettings {
+            fps: FrameRate::FPS_30,
+            canvas_size: CanvasSize {
+                width: 1920,
+                height: 1080,
+            },
+            canvas_size_mode: None,
+            last_custom_canvas_size: None,
+            original_canvas_size: None,
+            background: Background::Color {
+                color: "#000000".to_string(),
+            },
+        },
+        version: 14,
+        timeline_view_state: None,
+    }
+}
+
+fn sample_media(id: &str, name: &str) -> ArchivedMediaMetadata {
+    ArchivedMediaMetadata {
+        id: id.to_string(),
+        name: name.to_string(),
+        media_type: "video".to_string(),
+        file_type: "video/mp4".to_string(),
+        last_modified: 1_700_000_000_000.0,
+        width: Some(1920.0),
+        height: Some(1080.0),
+        duration: Some(5.0),
+        ephemeral: None,
+        thumbnail_url: None,
+    }
+}
+
+fn store() -> (TempDir, ProjectStore) {
+    let dir = TempDir::new().unwrap();
+    let store = ProjectStore::new(dir.path().join("projects"));
+    (dir, store)
+}
+
+#[test]
+fn project_round_trip() {
+    let (_dir, store) = store();
+    let project = sample_project("project-1");
+
+    store.create_project(&project).unwrap();
+    assert!(store.create_project(&project).is_err());
+
+    let mut updated = project.clone();
+    updated.metadata.name = "Renamed Project".to_string();
+    store.save_project(&updated).unwrap();
+
+    let listed = store.list_projects().unwrap();
+    assert_eq!(listed, vec![updated.metadata.clone()]);
+
+    let loaded = store.load_project("project-1").unwrap();
+    assert_eq!(loaded, updated);
+
+    let raw = std::fs::read_to_string(
+        store.project_dir("project-1").join("project.json"),
+    )
+    .unwrap();
+    assert!(raw.contains("\"currentSceneId\""));
+    assert!(raw.contains("\"createdAt\""));
+}
+
+#[test]
+fn list_projects_sorts_by_updated_descending() {
+    let (_dir, store) = store();
+    store.create_project(&sample_project("project-old")).unwrap();
+    let mut newer = sample_project("project-new");
+    newer.metadata.updated_at = date(20);
+    store.create_project(&newer).unwrap();
+
+    let listed = store.list_projects().unwrap();
+    let ids: Vec<&str> = listed.iter().map(|meta| meta.id.as_str()).collect();
+    assert_eq!(ids, vec!["project-new", "project-old"]);
+}
+
+#[test]
+fn media_round_trip() {
+    let (_dir, store) = store();
+    let project = sample_project("project-1");
+    store.create_project(&project).unwrap();
+
+    let metadata = sample_media("media-1", "my clip.mp4");
+    let bytes = b"fake video bytes";
+    store.add_media("project-1", &metadata, bytes).unwrap();
+
+    let listed = store.list_media("project-1").unwrap();
+    assert_eq!(listed, vec![metadata.clone()]);
+
+    let path = store.media_path("project-1", "media-1").unwrap();
+    assert_eq!(
+        path.file_name().unwrap().to_str().unwrap(),
+        "media-1-my_clip.mp4"
+    );
+    assert_eq!(std::fs::read(&path).unwrap(), bytes);
+
+    let manifest = std::fs::read_to_string(
+        store
+            .project_dir("project-1")
+            .join("media")
+            .join("manifest.json"),
+    )
+    .unwrap();
+    let parsed: Vec<ArchivedMediaMetadata> = serde_json::from_str(&manifest).unwrap();
+    assert_eq!(parsed, vec![metadata.clone()]);
+    assert!(!parsed[0].media_type.is_empty());
+
+    store.delete_media("project-1", "media-1").unwrap();
+    assert!(store.list_media("project-1").unwrap().is_empty());
+    assert!(store.media_path("project-1", "media-1").is_err());
+    assert!(!path.exists());
+}
+
+#[test]
+fn add_media_replaces_existing_id() {
+    let (_dir, store) = store();
+    let project = sample_project("project-1");
+    store.create_project(&project).unwrap();
+
+    let first = sample_media("media-1", "first.mp4");
+    store.add_media("project-1", &first, b"first").unwrap();
+    let second = sample_media("media-1", "second.mp4");
+    store.add_media("project-1", &second, b"second").unwrap();
+
+    let listed = store.list_media("project-1").unwrap();
+    assert_eq!(listed, vec![second]);
+    let path = store.media_path("project-1", "media-1").unwrap();
+    assert_eq!(std::fs::read(&path).unwrap(), b"second");
+    let media_dir = store.project_dir("project-1").join("media");
+    let files: Vec<_> = std::fs::read_dir(&media_dir)
+        .unwrap()
+        .map(|entry| entry.unwrap().file_name())
+        .collect();
+    assert_eq!(files.len(), 2);
+}
+
+#[test]
+fn export_import_round_trip() {
+    let (_dir_a, source) = store();
+    let project = sample_project("project-1");
+    source.create_project(&project).unwrap();
+    let metadata = sample_media("media-1", "my clip.mp4");
+    let bytes = b"fake video bytes";
+    source.add_media("project-1", &metadata, bytes).unwrap();
+
+    let archive = source.export_ocp("project-1").unwrap();
+
+    let (_dir_b, target) = store();
+    let imported_id = target.import_ocp(&archive).unwrap();
+    assert_eq!(imported_id, "project-1");
+
+    let loaded = target.load_project(&imported_id).unwrap();
+    assert_eq!(loaded, project);
+
+    let listed = target.list_media(&imported_id).unwrap();
+    assert_eq!(listed, vec![metadata]);
+    let path = target.media_path(&imported_id, "media-1").unwrap();
+    assert_eq!(std::fs::read(&path).unwrap(), bytes);
+}
+
+#[test]
+fn delete_project_removes_directory() {
+    let (_dir, store) = store();
+    let project = sample_project("project-1");
+    store.create_project(&project).unwrap();
+    store
+        .add_media("project-1", &sample_media("media-1", "clip.mp4"), b"data")
+        .unwrap();
+
+    let project_dir = store.project_dir("project-1");
+    assert!(project_dir.is_dir());
+
+    store.delete_project("project-1").unwrap();
+    assert!(!project_dir.exists());
+    assert!(store.load_project("project-1").is_err());
+    assert!(store.list_projects().unwrap().is_empty());
+    assert!(store.delete_project("project-1").is_err());
+}
+
+#[test]
+fn import_id_collision_gets_new_id() {
+    let (_dir_a, source) = store();
+    let project = sample_project("project-1");
+    source.create_project(&project).unwrap();
+    let archive = source.export_ocp("project-1").unwrap();
+
+    let (_dir_b, target) = store();
+    let first = target.import_ocp(&archive).unwrap();
+    let second = target.import_ocp(&archive).unwrap();
+
+    assert_eq!(first, "project-1");
+    assert_ne!(first, second);
+    assert_eq!(second, "project-1-1");
+
+    let first_project = target.load_project(&first).unwrap();
+    let second_project = target.load_project(&second).unwrap();
+    assert_eq!(first_project.metadata.id, first);
+    assert_eq!(second_project.metadata.id, second);
+    assert_eq!(second_project.scenes, first_project.scenes);
+
+    let listed = target.list_projects().unwrap();
+    assert_eq!(listed.len(), 2);
+}