restructure project file again

oscartbeaumont · oscartbeaumont · commit c411b0229801 · 2025-09-29T16:19:03.000+10:00
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
@@ -30,8 +30,8 @@ use auth::{AuthStore, AuthenticationInvalid, Plan};
 use camera::CameraPreviewState;
 use cap_editor::{EditorInstance, EditorState};
 use cap_project::{
-    ProjectConfiguration, RecordingMeta, RecordingMetaInner, SharingMeta, StudioRecordingMeta, XY,
-    ZoomSegment,
+    ProjectConfiguration, RecordingMeta, RecordingMetaInner, SharingMeta, StudioRecordingMeta,
+    StudioRecordingStatus, XY, ZoomSegment,
 };
 use cap_recording::{
     RecordingMode,
@@ -901,21 +901,24 @@ async fn get_video_metadata(path: PathBuf) -> Result<VideoRecordingMetadata, Str
         RecordingMetaInner::Instant(_) => {
             vec![path.join("content/output.mp4")]
         }
-        RecordingMetaInner::Studio(meta) => match meta {
-            StudioRecordingMeta::SingleSegment { segment } => {
-                vec![recording_meta.path(&segment.display.path)]
+        RecordingMetaInner::Studio(meta) => {
+            let status = meta.status();
+            if let StudioRecordingStatus::Failed { .. } = status {
+                return Err(format!("Unable to get metadata on failed recording"));
+            } else if let StudioRecordingStatus::InProgress = status {
+                return Err(format!("Unable to get metadata on in-progress recording"));
+            }
+
+            match meta {
+                StudioRecordingMeta::SingleSegment { segment } => {
+                    vec![recording_meta.path(&segment.display.path)]
+                }
+                StudioRecordingMeta::MultipleSegments { inner } => inner
+                    .segments
+                    .iter()
+                    .map(|s| recording_meta.path(&s.display.path))
+                    .collect(),
             }
-            StudioRecordingMeta::MultipleSegments { inner, .. } => inner
-                .segments
-                .iter()
-                .map(|s| recording_meta.path(&s.display.path))
-                .collect(),
-        },
-        RecordingMetaInner::InProgress { .. } => {
-            return Err(format!("Unable to get metadata on in-progress recording"));
-        }
-        RecordingMetaInner::Failed { .. } => {
-            return Err(format!("Unable to get metadata on failed recording"));
         }
     };
 
@@ -1069,11 +1072,7 @@ async fn upload_exported_video(
 
     let mut meta = RecordingMeta::load_for_project(&path).map_err(|v| v.to_string())?;
 
-    let Some(output_path) = meta.output_path() else {
-        notifications::send_notification(&app, notifications::NotificationType::UploadFailed);
-        return Err("Failed to upload video: Recording failed to complete".to_string());
-    };
-
+    let output_path = meta.output_path();
     if !output_path.exists() {
         notifications::send_notification(&app, notifications::NotificationType::UploadFailed);
         return Err("Failed to upload video: Rendered video not found".to_string());
@@ -1401,17 +1400,6 @@ async fn save_file_dialog(
     }
 }
 
-// #[derive(Serialize, specta::Type)]
-// #[serde(tag = "status")]
-// pub enum RecordingStatus {
-//     Recording,
-//     Failed { error: String },
-//     Complete { mode: RecordingMode },
-// }
-//
-// #[serde(flatten)]
-// pub status: RecordingStatus,
-
 #[derive(Serialize, specta::Type)]
 pub struct RecordingMetaWithMode {
     #[serde(flatten)]
@@ -1425,8 +1413,6 @@ impl RecordingMetaWithMode {
             mode: match &inner.inner {
                 RecordingMetaInner::Studio(_) => Some(RecordingMode::Studio),
                 RecordingMetaInner::Instant(_) => Some(RecordingMode::Instant),
-                RecordingMetaInner::InProgress { .. } => None,
-                RecordingMetaInner::Failed { .. } => None,
             },
             inner,
         }
@@ -2498,9 +2484,15 @@ fn open_project_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
     let meta = RecordingMeta::load_for_project(path).map_err(|v| v.to_string())?;
 
     match &meta.inner {
-        RecordingMetaInner::Studio(_) => {
-            let project_path = path.to_path_buf();
+        RecordingMetaInner::Studio(meta) => {
+            let status = meta.status();
+            if let StudioRecordingStatus::Failed { .. } = status {
+                return Err(format!("Unable to open failed recording"));
+            } else if let StudioRecordingStatus::InProgress = status {
+                return Err(format!("Recording in progress"));
+            }
 
+            let project_path = path.to_path_buf();
             tokio::spawn(async move { ShowCapWindow::Editor { project_path }.show(&app).await });
         }
         RecordingMetaInner::Instant(_) => {
@@ -2515,10 +2507,6 @@ fn open_project_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
                 }
             }
         }
-        RecordingMetaInner::InProgress { .. } => return Err(format!("Recording in progress")),
-        RecordingMetaInner::Failed { .. } => {
-            return Err(format!("Unable to open failed recording"));
-        }
     }
 
     Ok(())
diff --git a/apps/desktop/src-tauri/src/recording.rs b/apps/desktop/src-tauri/src/recording.rs
@@ -1,8 +1,8 @@
 use cap_fail::fail;
 use cap_project::{
-    CursorClickEvent, Platform, ProjectConfiguration, RecordingMeta, RecordingMetaInner,
-    SharingMeta, StudioRecordingMeta, TimelineConfiguration, TimelineSegment, ZoomMode,
-    ZoomSegment, cursor::CursorEvents,
+    CursorClickEvent, InstantRecordingMeta, MultipleSegments, Platform, ProjectConfiguration,
+    RecordingMeta, RecordingMetaInner, SharingMeta, StudioRecordingMeta, StudioRecordingStatus,
+    TimelineConfiguration, TimelineSegment, ZoomMode, ZoomSegment, cursor::CursorEvents,
 };
 use cap_recording::{
     RecordingError, RecordingMode,
@@ -297,7 +297,20 @@ pub async fn start_recording(
         project_path: recording_dir.clone(),
         sharing: None, // TODO: Is this gonna be problematic as it was previously always set
         pretty_name: format!("{target_name} {date_time}"),
-        inner: RecordingMetaInner::InProgress { recording: true },
+        inner: match inputs.mode {
+            RecordingMode::Studio => {
+                RecordingMetaInner::Studio(StudioRecordingMeta::MultipleSegments {
+                    inner: MultipleSegments {
+                        segments: Default::default(),
+                        cursors: Default::default(),
+                        status: Some(StudioRecordingStatus::InProgress),
+                    },
+                })
+            }
+            RecordingMode::Instant => {
+                RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { recording: true })
+            }
+        },
         upload: None,
     };
 
@@ -688,7 +701,16 @@ async fn handle_recording_end(
         Err(error) => {
             // TODO: Error handling -> Can we reuse `RecordingMeta` too?
             let mut project_meta = RecordingMeta::load_for_project(&recording_dir).unwrap();
-            project_meta.inner = RecordingMetaInner::Failed { error };
+            match &mut project_meta.inner {
+                RecordingMetaInner::Studio(meta) => {
+                    if let StudioRecordingMeta::MultipleSegments { inner } = meta {
+                        inner.status = Some(StudioRecordingStatus::Failed { error });
+                    }
+                }
+                RecordingMetaInner::Instant(meta) => {
+                    *meta = InstantRecordingMeta::Failed { error };
+                }
+            }
             project_meta.save_for_project().unwrap();
 
             None
diff --git a/apps/desktop/src/utils/tauri.ts b/apps/desktop/src/utils/tauri.ts
@@ -394,7 +394,7 @@ export type Hotkey = { code: string; meta: boolean; ctrl: boolean; alt: boolean;
 export type HotkeyAction = "startStudioRecording" | "startInstantRecording" | "stopRecording" | "restartRecording" | "openRecordingPicker" | "openRecordingPickerDisplay" | "openRecordingPickerWindow" | "openRecordingPickerArea" | "other"
 export type HotkeysConfiguration = { show: boolean }
 export type HotkeysStore = { hotkeys: { [key in HotkeyAction]: Hotkey } }
-export type InstantRecordingMeta = { fps: number; sample_rate: number | null }
+export type InstantRecordingMeta = { recording: boolean } | { error: string } | { fps: number; sample_rate: number | null }
 export type JsonValue<T> = [T]
 export type LogicalBounds = { position: LogicalPosition; size: LogicalSize }
 export type LogicalPosition = { x: number; y: number }
@@ -403,7 +403,7 @@ export type MainWindowRecordingStartBehaviour = "close" | "minimise"
 export type ModelIDType = string
 export type Mp4ExportSettings = { fps: number; resolution_base: XY<number>; compression: ExportCompression }
 export type MultipleSegment = { display: VideoMeta; camera?: VideoMeta | null; mic?: AudioMeta | null; system_audio?: AudioMeta | null; cursor?: string | null }
-export type MultipleSegments = { segments: MultipleSegment[]; cursors: Cursors }
+export type MultipleSegments = { segments: MultipleSegment[]; cursors: Cursors; status?: StudioRecordingStatus | null }
 export type NewNotification = { title: string; body: string; is_error: boolean }
 export type NewScreenshotAdded = { path: string }
 export type NewStudioRecordingAdded = { path: string }
@@ -422,8 +422,8 @@ export type ProjectConfiguration = { aspectRatio: AspectRatio | null; background
 export type ProjectRecordingsMeta = { segments: SegmentRecordings[] }
 export type RecordingDeleted = { path: string }
 export type RecordingEvent = { variant: "Countdown"; value: number } | { variant: "Started" } | { variant: "Stopped" } | { variant: "Failed"; error: string }
-export type RecordingMeta = ({ recording: boolean } | { error: string } | StudioRecordingMeta | InstantRecordingMeta) & { platform?: Platform | null; pretty_name: string; sharing?: SharingMeta | null; upload?: UploadState | null }
-export type RecordingMetaWithMode = (({ recording: boolean } | { error: string } | StudioRecordingMeta | InstantRecordingMeta) & { platform?: Platform | null; pretty_name: string; sharing?: SharingMeta | null; upload?: UploadState | null }) & { mode: RecordingMode | null }
+export type RecordingMeta = (StudioRecordingMeta | InstantRecordingMeta) & { platform?: Platform | null; pretty_name: string; sharing?: SharingMeta | null; upload?: UploadState | null }
+export type RecordingMetaWithMode = ((StudioRecordingMeta | InstantRecordingMeta) & { platform?: Platform | null; pretty_name: string; sharing?: SharingMeta | null; upload?: UploadState | null }) & { mode: RecordingMode | null }
 export type RecordingMode = "studio" | "instant"
 export type RecordingOptionsChanged = null
 export type RecordingSettingsStore = { target: ScreenCaptureTarget | null; micName: string | null; cameraId: DeviceOrModelID | null; mode: RecordingMode | null; systemAudio: boolean }
@@ -448,6 +448,7 @@ export type SingleSegment = { display: VideoMeta; camera?: VideoMeta | null; aud
 export type StartRecordingInputs = { capture_target: ScreenCaptureTarget; capture_system_audio?: boolean; mode: RecordingMode }
 export type StereoMode = "stereo" | "monoL" | "monoR"
 export type StudioRecordingMeta = { segment: SingleSegment } | { inner: MultipleSegments }
+export type StudioRecordingStatus = "inProgress" | { failed: { error: string } } | "completed"
 export type TargetUnderCursor = { display_id: DisplayId | null; window: WindowUnderCursor | null }
 export type TimelineConfiguration = { segments: TimelineSegment[]; zoomSegments: ZoomSegment[]; sceneSegments?: SceneSegment[] }
 export type TimelineSegment = { recordingSegment?: number; timescale: number; start: number; end: number }
diff --git a/crates/export/src/lib.rs b/crates/export/src/lib.rs
@@ -99,8 +99,7 @@ impl ExporterBuilder {
 
         let output_path = self
             .output_path
-            .or_else(|| recording_meta.output_path())
-            .ok_or(Error::RecordingFailed)?;
+            .unwrap_or_else(|| recording_meta.output_path());
 
         if let Some(parent) = output_path.parent() {
             std::fs::create_dir_all(parent)
diff --git a/crates/project/src/meta.rs b/crates/project/src/meta.rs
@@ -85,16 +85,26 @@ pub enum UploadState {
 #[derive(Debug, Clone, Serialize, Deserialize, Type)]
 #[serde(untagged, rename_all = "camelCase")]
 pub enum RecordingMetaInner {
-    InProgress { recording: bool },
-    Failed { error: String },
     Studio(StudioRecordingMeta),
     Instant(InstantRecordingMeta),
 }
 
+impl specta::Flatten for RecordingMetaInner {}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct InstantRecordingMeta {
-    pub fps: u32,
-    pub sample_rate: Option<u32>,
+#[serde(untagged, rename_all = "camelCase")]
+pub enum InstantRecordingMeta {
+    InProgress {
+        // This field means nothing and is just because this enum is untagged.
+        recording: bool,
+    },
+    Failed {
+        error: String,
+    },
+    Complete {
+        fps: u32,
+        sample_rate: Option<u32>,
+    },
 }
 
 impl RecordingMeta {
@@ -142,14 +152,10 @@ impl RecordingMeta {
         config
     }
 
-    pub fn output_path(&self) -> Option<PathBuf> {
+    pub fn output_path(&self) -> PathBuf {
         match &self.inner {
-            RecordingMetaInner::Instant(_) => Some(self.project_path.join("content/output.mp4")),
-            RecordingMetaInner::Studio(_) => {
-                Some(self.project_path.join("output").join("result.mp4"))
-            }
-            RecordingMetaInner::InProgress { .. } => None,
-            RecordingMetaInner::Failed { .. } => None,
+            RecordingMetaInner::Instant(_) => self.project_path.join("content/output.mp4"),
+            RecordingMetaInner::Studio(_) => self.project_path.join("output").join("result.mp4"),
         }
     }
 
@@ -177,12 +183,20 @@ pub enum StudioRecordingMeta {
 }
 
 impl StudioRecordingMeta {
+    pub fn status(&self) -> StudioRecordingStatus {
+        match self {
+            StudioRecordingMeta::SingleSegment { .. } => StudioRecordingStatus::Completed,
+            StudioRecordingMeta::MultipleSegments { inner } => inner
+                .status
+                .clone()
+                .unwrap_or(StudioRecordingStatus::Completed),
+        }
+    }
+
     pub fn camera_path(&self) -> Option<RelativePathBuf> {
         match self {
-            StudioRecordingMeta::SingleSegment { segment } => {
-                segment.camera.as_ref().map(|c| c.path.clone())
-            }
-            StudioRecordingMeta::MultipleSegments { inner, .. } => inner
+            Self::SingleSegment { segment } => segment.camera.as_ref().map(|c| c.path.clone()),
+            Self::MultipleSegments { inner, .. } => inner
                 .segments
                 .first()
                 .and_then(|s| s.camera.as_ref().map(|c| c.path.clone())),
@@ -191,17 +205,17 @@ impl StudioRecordingMeta {
 
     pub fn min_fps(&self) -> u32 {
         match self {
-            StudioRecordingMeta::SingleSegment { segment } => segment.display.fps,
-            StudioRecordingMeta::MultipleSegments { inner, .. } => {
+            Self::SingleSegment { segment } => segment.display.fps,
+            Self::MultipleSegments { inner, .. } => {
                 inner.segments.iter().map(|s| s.display.fps).min().unwrap()
             }
         }
     }
 
     pub fn max_fps(&self) -> u32 {
         match self {
-            StudioRecordingMeta::SingleSegment { segment } => segment.display.fps,
-            StudioRecordingMeta::MultipleSegments { inner, .. } => {
+            Self::SingleSegment { segment } => segment.display.fps,
+            Self::MultipleSegments { inner, .. } => {
                 inner.segments.iter().map(|s| s.display.fps).max().unwrap()
             }
         }
@@ -227,6 +241,16 @@ pub struct MultipleSegments {
     pub segments: Vec<MultipleSegment>,
     #[serde(default, skip_serializing_if = "Cursors::is_empty")]
     pub cursors: Cursors,
+    #[serde(default)]
+    pub status: Option<StudioRecordingStatus>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum StudioRecordingStatus {
+    InProgress,
+    Failed { error: String },
+    Completed,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Type)]
diff --git a/crates/recording/src/instant_recording.rs b/crates/recording/src/instant_recording.rs
@@ -480,7 +480,7 @@ async fn stop_recording(actor: Actor) -> CompletedRecording {
 
     CompletedRecording {
         project_path: actor.recording_dir.clone(),
-        meta: InstantRecordingMeta {
+        meta: InstantRecordingMeta::Complete {
             fps: actor.video_info.fps(),
             sample_rate: None,
         },
diff --git a/crates/recording/src/studio_recording.rs b/crates/recording/src/studio_recording.rs
@@ -603,6 +603,7 @@ async fn stop_recording(
                     })
                     .collect(),
             ),
+            status: Some(StudioRecordingStatus::Completed),
         },
     };
 
