AI media harness for planning, generating, and editing locally
TypeScript
use serde::{Deserialize, Serialize};
use slopus_core::slopfab::music::MusicSettings;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct MusicSong {
pub id: String,
pub title: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub folder_id: Option<String>,
#[serde(default)] pub style: String,
pub generator_id: String,
pub settings: MusicSettings,
pub steps: i32,
pub seed: i64,
pub status: String,
pub asset_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cover_relative_path: Option<String>,
pub error: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub generation: Option<MusicGeneration>,
pub created_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct MusicGeneration {
pub generator_id: String,
pub style: String,
pub settings: MusicSettings,
pub steps: i32,
pub seed: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct MusicFolder {
pub id: String,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_id: Option<String>,
}
pub(crate) fn validate(config: &mut super::ProjectConfig) -> Result<(), String> {
let mut folders = std::collections::HashMap::new();
for folder in &config.music_folders {
if folder.id.is_empty() || folder.name.trim().is_empty() || folder.name.chars().count() > 200
|| folders.insert(folder.id.as_str(), folder).is_some() { return Err("Invalid music folder.".into()); }
}
for folder in &config.music_folders {
let mut visited = std::collections::HashSet::from([folder.id.as_str()]);
let mut parent = folder.parent_id.as_deref();
while let Some(id) = parent {
if !visited.insert(id) { return Err("Music folders cannot contain a cycle.".into()); }
parent = folders.get(id).ok_or("Music folder parent does not exist.")?.parent_id.as_deref();
}
}
let mut ids = std::collections::HashSet::new();
for song in &mut config.music_songs {
song.cover_relative_path = song.cover_relative_path.as_deref()
.map(super::paths::normalize_project_path).transpose()?;
if song.folder_id.as_deref().is_some_and(|id| !folders.contains_key(id)) { return Err("Song folder does not exist.".into()); }
if song.id.is_empty() || !ids.insert(&song.id) || song.title.trim().is_empty() || song.title.chars().count() > 200
|| song.style.chars().count() > 10000 || !(2..=100).contains(&song.steps) || !(-1..=9_007_199_254_740_991).contains(&song.seed)
|| !matches!(song.status.as_str(), "draft" | "queued" | "generating" | "completed" | "failed" | "cancelled") {
return Err("Invalid music song.".into());
}
song.settings.validate()?;
if let Some(generation) = &song.generation {
generation.settings.validate()?;
if !(2..=100).contains(&generation.steps) || !(0..=9_007_199_254_740_991).contains(&generation.seed)
|| generation.style.chars().count() > 10000 { return Err("Invalid recorded music generation.".into()); }
}
}
Ok(())
}