Frontend: remove dead API client code targeting unregistered endpoints

Deletes dormant legacy API surface (zero live callers, verified against the
full backend route table):

- VoiceDesignerApi, VoiceConversionApi, AnalyticsApi (/v1/analytics/log_session
  was never registered) - both @storyteller/api and the Tauri app's ApiManager
  copies, plus their tests
- PromptsApi/EngineApi: /v1/image_studio/prompt, /v1/image_studio/session_jobs,
  /v1/jobs/session/{token} methods (routes do not exist)
- UserBookmarksApi: broken-path list methods (/list/{user} and /list/{et}/{etok};
  backend shapes are /list/user/{u} and /list/entity/{et}/{etok}) and the
  FakeYou-era scoped enums that only they consumed
- Dashboard UsersApi: RequestPasswordReset/ResetPassword pointing at removed
  /v1/request_password_reset + /v1/reset_password (live pages use
  PasswordResetApi -> /v1/password_reset/* correctly)

Fixes WeightsApi cover-image path to the registered route:
/v1/weights/weight/{token}/cover_image (both copies).

crates/api_clients/artcraft/artcraft_router/src/api/router_image_model.rs

@@ -41,6 +41,8 @@ pub enum RouterImageModel {
   Seedream4p5,
   #[serde(rename = "seedream_5_lite")]
   Seedream5Lite,
+  #[serde(rename = "seedream_5p0_pro")]
+  Seedream5p0Pro,
   #[serde(rename = "qwen_edit_2511_angles")]
   QwenEdit2511Angles,
   #[serde(rename = "flux_2_lora_angles")]
@@ -73,4 +75,9 @@ mod tests {
   fn midjourney_8_serializes_to_midjourney_8() {
     assert_round_trip(RouterImageModel::Midjourney8, "midjourney_8");
   }
+
+  #[test]
+  fn seedream_5p0_pro_serializes_to_seedream_5p0_pro() {
+    assert_round_trip(RouterImageModel::Seedream5p0Pro, "seedream_5p0_pro");
+  }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/generate_image_request_builder.rs

@@ -26,6 +26,7 @@ use crate::generate::generate_image::providers::artcraft::qwen_edit_2511_angles:
 use crate::generate::generate_image::providers::artcraft::seedream_4::build::build_artcraft_seedream_4;
 use crate::generate::generate_image::providers::artcraft::seedream_4p5::build::build_artcraft_seedream_4p5;
 use crate::generate::generate_image::providers::artcraft::seedream_5_lite::build::build_artcraft_seedream_5_lite;
+use crate::generate::generate_image::providers::artcraft::seedream_5p0_pro::build::build_artcraft_seedream_5p0_pro;
 use crate::generate::generate_image::providers::fal::flux_1_dev::build::build_fal_flux_1_dev;
 use crate::generate::generate_image::providers::fal::flux_1_schnell::build::build_fal_flux_1_schnell;
 use crate::generate::generate_image::providers::fal::flux_2_lora_angles::build::build_fal_flux_2_lora_angles;
@@ -44,6 +45,7 @@ use crate::generate::generate_image::providers::fal::seedream_5_lite::build::bui
 use crate::generate::generate_image::providers::kinovi::midjourney_7::build::build_kinovi_midjourney_7;
 use crate::generate::generate_image::providers::kinovi::midjourney_7_niji::build::build_kinovi_midjourney_7_niji;
 use crate::generate::generate_image::providers::kinovi::midjourney_8::build::build_kinovi_midjourney_8;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::build::build_kinovi_seedream_5p0_pro;
 
 #[derive(Clone, Debug)]
 pub struct GenerateImageRequestBuilder {
@@ -119,6 +121,7 @@ impl GenerateImageRequestBuilder {
       (RouterProvider::Artcraft, RouterImageModel::Seedream4) => build_artcraft_seedream_4(self),
       (RouterProvider::Artcraft, RouterImageModel::Seedream4p5) => build_artcraft_seedream_4p5(self),
       (RouterProvider::Artcraft, RouterImageModel::Seedream5Lite) => build_artcraft_seedream_5_lite(self),
+      (RouterProvider::Artcraft, RouterImageModel::Seedream5p0Pro) => build_artcraft_seedream_5p0_pro(self),
       (RouterProvider::Artcraft, RouterImageModel::QwenEdit2511Angles) => build_artcraft_qwen_edit_2511_angles(self),
       (RouterProvider::Artcraft, RouterImageModel::Flux2LoraAngles) => build_artcraft_flux_2_lora_angles(self),
       (RouterProvider::Artcraft, RouterImageModel::Midjourney7) => build_artcraft_midjourney_7(self),
@@ -141,10 +144,11 @@ impl GenerateImageRequestBuilder {
       (RouterProvider::Fal, RouterImageModel::QwenEdit2511Angles) => build_fal_qwen_edit_2511_angles(self),
       (RouterProvider::Fal, RouterImageModel::Flux2LoraAngles) => build_fal_flux_2_lora_angles(self),
 
-      // Kinovi / Seedance2Pro (Midjourney)
+      // Kinovi / Seedance2Pro (Midjourney + Seedream)
       (RouterProvider::Seedance2Pro, RouterImageModel::Midjourney7) => build_kinovi_midjourney_7(self),
       (RouterProvider::Seedance2Pro, RouterImageModel::Midjourney7Niji) => build_kinovi_midjourney_7_niji(self),
       (RouterProvider::Seedance2Pro, RouterImageModel::Midjourney8) => build_kinovi_midjourney_8(self),
+      (RouterProvider::Seedance2Pro, RouterImageModel::Seedream5p0Pro) => build_kinovi_seedream_5p0_pro(self),
 
       _ => self.unsupported_provider_and_model(),
     }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_draft.rs

@@ -9,12 +9,14 @@ use crate::generate::generate_image::providers::kinovi::midjourney_7_niji::cost:
 use crate::generate::generate_image::providers::kinovi::midjourney_7_niji::draft::KinoviMidjourney7NijiDraftState;
 use crate::generate::generate_image::providers::kinovi::midjourney_8::cost::KinoviMidjourney8CostState;
 use crate::generate::generate_image::providers::kinovi::midjourney_8::draft::KinoviMidjourney8DraftState;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::cost::KinoviSeedream5p0ProCostState;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::draft::KinoviSeedream5p0ProDraftState;
 
 /// Wrapper for all image generation draft requests.
 ///
 /// Drafts hold validated/planned parameters but may still need media
 /// resolution (e.g. uploading local files to a provider) before they can
-/// be sent. Today only Kinovi/Midjourney needs this — when the caller
+/// be sent. Today only the Kinovi models need this — when the caller
 /// supplies reference images, we must upload them to the Seedance2Pro
 /// CDN before sending the request.
 #[derive(Clone, Debug)]
@@ -22,6 +24,7 @@ pub enum ImageGenerationDraftRequest {
   KinoviMidjourney7(KinoviMidjourney7DraftState),
   KinoviMidjourney7Niji(KinoviMidjourney7NijiDraftState),
   KinoviMidjourney8(KinoviMidjourney8DraftState),
+  KinoviSeedream5p0Pro(KinoviSeedream5p0ProDraftState),
 }
 
 impl ImageGenerationDraftRequest {
@@ -30,6 +33,7 @@ impl ImageGenerationDraftRequest {
       Self::KinoviMidjourney7(_) => RouterProvider::Seedance2Pro,
       Self::KinoviMidjourney7Niji(_) => RouterProvider::Seedance2Pro,
       Self::KinoviMidjourney8(_) => RouterProvider::Seedance2Pro,
+      Self::KinoviSeedream5p0Pro(_) => RouterProvider::Seedance2Pro,
     }
   }
 
@@ -38,6 +42,7 @@ impl ImageGenerationDraftRequest {
       Self::KinoviMidjourney7(draft) => Ok(KinoviMidjourney7CostState::from_draft(draft).estimate_cost()),
       Self::KinoviMidjourney7Niji(draft) => Ok(KinoviMidjourney7NijiCostState::from_draft(draft).estimate_cost()),
       Self::KinoviMidjourney8(draft) => Ok(KinoviMidjourney8CostState::from_draft(draft).estimate_cost()),
+      Self::KinoviSeedream5p0Pro(draft) => Ok(KinoviSeedream5p0ProCostState::from_draft(draft).estimate_cost()),
     }
   }
 
@@ -55,6 +60,10 @@ impl ImageGenerationDraftRequest {
         let result = draft.to_request(&draft_context).await?;
         Ok(ImageGenerationRequest::KinoviMidjourney8(result))
       }
+      Self::KinoviSeedream5p0Pro(mut draft) => {
+        let result = draft.to_request(&draft_context).await?;
+        Ok(ImageGenerationRequest::KinoviSeedream5p0Pro(result))
+      }
     }
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_request.rs

@@ -39,6 +39,8 @@ use crate::generate::generate_image::providers::artcraft::seedream_4p5::cost::Ar
 use crate::generate::generate_image::providers::artcraft::seedream_4p5::request::ArtcraftSeedream4p5RequestState;
 use crate::generate::generate_image::providers::artcraft::seedream_5_lite::cost::ArtcraftSeedream5LiteCostState;
 use crate::generate::generate_image::providers::artcraft::seedream_5_lite::request::ArtcraftSeedream5LiteRequestState;
+use crate::generate::generate_image::providers::artcraft::seedream_5p0_pro::cost::ArtcraftSeedream5p0ProCostState;
+use crate::generate::generate_image::providers::artcraft::seedream_5p0_pro::request::ArtcraftSeedream5p0ProRequestState;
 use crate::generate::generate_image::providers::fal::flux_1_dev::cost::FalFlux1DevCostState;
 use crate::generate::generate_image::providers::fal::flux_1_dev::request::FalFlux1DevRequestState;
 use crate::generate::generate_image::providers::fal::flux_1_schnell::cost::FalFlux1SchnellCostState;
@@ -75,6 +77,8 @@ use crate::generate::generate_image::providers::kinovi::midjourney_7_niji::cost:
 use crate::generate::generate_image::providers::kinovi::midjourney_7_niji::request::KinoviMidjourney7NijiRequestState;
 use crate::generate::generate_image::providers::kinovi::midjourney_8::cost::KinoviMidjourney8CostState;
 use crate::generate::generate_image::providers::kinovi::midjourney_8::request::KinoviMidjourney8RequestState;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::cost::KinoviSeedream5p0ProCostState;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::request::KinoviSeedream5p0ProRequestState;
 
 #[derive(Clone, Debug)]
 pub enum ImageGenerationRequest {
@@ -92,6 +96,7 @@ pub enum ImageGenerationRequest {
   ArtcraftSeedream4(ArtcraftSeedream4RequestState),
   ArtcraftSeedream4p5(ArtcraftSeedream4p5RequestState),
   ArtcraftSeedream5Lite(ArtcraftSeedream5LiteRequestState),
+  ArtcraftSeedream5p0Pro(ArtcraftSeedream5p0ProRequestState),
   ArtcraftQwenEdit2511Angles(ArtcraftQwenEdit2511AnglesRequestState),
   ArtcraftFlux2LoraAngles(ArtcraftFlux2LoraAnglesRequestState),
   ArtcraftMidjourney7(ArtcraftMidjourney7RequestState),
@@ -115,10 +120,11 @@ pub enum ImageGenerationRequest {
   FalQwenEdit2511Angles(FalQwenEdit2511AnglesRequestState),
   FalFlux2LoraAngles(FalFlux2LoraAnglesRequestState),
 
-  // ── Kinovi / Seedance2Pro provider (Midjourney image generation) ──
+  // ── Kinovi / Seedance2Pro provider (Midjourney + Seedream image generation) ──
   KinoviMidjourney7(KinoviMidjourney7RequestState),
   KinoviMidjourney7Niji(KinoviMidjourney7NijiRequestState),
   KinoviMidjourney8(KinoviMidjourney8RequestState),
+  KinoviSeedream5p0Pro(KinoviSeedream5p0ProRequestState),
 }
 
 impl ImageGenerationRequest {
@@ -137,6 +143,7 @@ impl ImageGenerationRequest {
       Self::ArtcraftSeedream4(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedream4p5(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedream5Lite(_) => RouterProvider::Artcraft,
+      Self::ArtcraftSeedream5p0Pro(_) => RouterProvider::Artcraft,
       Self::ArtcraftQwenEdit2511Angles(_) => RouterProvider::Artcraft,
       Self::ArtcraftFlux2LoraAngles(_) => RouterProvider::Artcraft,
       Self::ArtcraftMidjourney7(_) => RouterProvider::Artcraft,
@@ -162,6 +169,7 @@ impl ImageGenerationRequest {
       Self::KinoviMidjourney7(_) => RouterProvider::Seedance2Pro,
       Self::KinoviMidjourney7Niji(_) => RouterProvider::Seedance2Pro,
       Self::KinoviMidjourney8(_) => RouterProvider::Seedance2Pro,
+      Self::KinoviSeedream5p0Pro(_) => RouterProvider::Seedance2Pro,
     }
   }
 
@@ -207,6 +215,9 @@ impl ImageGenerationRequest {
       Self::ArtcraftSeedream5Lite(request) => {
         Ok(ArtcraftSeedream5LiteCostState::from_request(request).estimate_cost())
       }
+      Self::ArtcraftSeedream5p0Pro(request) => {
+        Ok(ArtcraftSeedream5p0ProCostState::from_request(request).estimate_cost())
+      }
       Self::ArtcraftQwenEdit2511Angles(request) => {
         Ok(ArtcraftQwenEdit2511AnglesCostState::from_request(request).estimate_cost())
       }
@@ -243,6 +254,7 @@ impl ImageGenerationRequest {
       Self::KinoviMidjourney7(request) => Ok(KinoviMidjourney7CostState::from_request(request).estimate_cost()),
       Self::KinoviMidjourney7Niji(request) => Ok(KinoviMidjourney7NijiCostState::from_request(request).estimate_cost()),
       Self::KinoviMidjourney8(request) => Ok(KinoviMidjourney8CostState::from_request(request).estimate_cost()),
+      Self::KinoviSeedream5p0Pro(request) => Ok(KinoviSeedream5p0ProCostState::from_request(request).estimate_cost()),
     }
   }
 
@@ -301,6 +313,10 @@ impl ImageGenerationRequest {
         let artcraft_client = client.get_artcraft_client_ref()?;
         request.send(artcraft_client).await
       }
+      Self::ArtcraftSeedream5p0Pro(request) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        request.send(artcraft_client).await
+      }
       Self::ArtcraftQwenEdit2511Angles(request) => {
         let artcraft_client = client.get_artcraft_client_ref()?;
         request.send(artcraft_client).await
@@ -389,7 +405,7 @@ impl ImageGenerationRequest {
         request.send(fal_client).await
       }
 
-      // ── Kinovi / Seedance2Pro (Midjourney) ──
+      // ── Kinovi / Seedance2Pro (Midjourney + Seedream) ──
       Self::KinoviMidjourney7(request) => {
         let seedance_client = client.get_seedance2pro_client_ref()
           .map_err(ArtcraftRouterError::Client)?;
@@ -405,6 +421,11 @@ impl ImageGenerationRequest {
           .map_err(ArtcraftRouterError::Client)?;
         request.send(seedance_client).await
       }
+      Self::KinoviSeedream5p0Pro(request) => {
+        let seedance_client = client.get_seedance2pro_client_ref()
+          .map_err(ArtcraftRouterError::Client)?;
+        request.send(seedance_client).await
+      }
     }
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/mod.rs

@@ -19,3 +19,4 @@ pub(crate) mod request_common;
 pub mod seedream_4;
 pub mod seedream_4p5;
 pub mod seedream_5_lite;
+pub mod seedream_5p0_pro;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/seedream_5p0_pro/build.rs

@@ -0,0 +1,17 @@
+use enums::common::generation::common_image_model::CommonImageModel as CommonImageModelEnum;
+
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+use crate::generate::generate_image::providers::artcraft::build_common::build_artcraft_omni_image_request;
+use crate::generate::generate_image::providers::artcraft::seedream_5p0_pro::request::ArtcraftSeedream5p0ProRequestState;
+
+pub fn build_artcraft_seedream_5p0_pro(
+  builder: GenerateImageRequestBuilder,
+) -> Result<ImageGenerationDraftOrRequest, ArtcraftRouterError> {
+  let request = build_artcraft_omni_image_request(builder, CommonImageModelEnum::Seedream5p0Pro)?;
+  Ok(ImageGenerationDraftOrRequest::Request(
+    ImageGenerationRequest::ArtcraftSeedream5p0Pro(ArtcraftSeedream5p0ProRequestState { request }),
+  ))
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/seedream_5p0_pro/cost.rs

@@ -0,0 +1,187 @@
+use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::providers::artcraft::seedream_5p0_pro::request::ArtcraftSeedream5p0ProRequestState;
+
+/// Customer-facing price per image at 1k resolution (the default), in USD cents.
+const USD_CENTS_PER_IMAGE_1K: u64 = 7;
+
+/// Customer-facing price per image at 2k resolution, in USD cents.
+const USD_CENTS_PER_IMAGE_2K: u64 = 12;
+
+/// Cost state for Artcraft Seedream 5.0 Pro. Pricing is per image and
+/// resolution-dependent:
+///
+///   1K (default) → 7¢, 2K → 12¢. 3K/4K fall back to 2K pricing; 0.5K and
+///   legacy video resolutions (480p/720p/1080p) fall back to 1K.
+#[derive(Clone, Debug)]
+pub struct ArtcraftSeedream5p0ProCostState {
+  pub resolution: Option<CommonResolutionEnum>,
+  pub num_images: u16,
+}
+
+impl ArtcraftSeedream5p0ProCostState {
+  pub fn from_request(request: &ArtcraftSeedream5p0ProRequestState) -> Self {
+    Self {
+      resolution: request.request.resolution,
+      num_images: request.request.image_batch_count.unwrap_or(1),
+    }
+  }
+
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    let cost_per_image: u64 = cost_per_image_in_cents(self.resolution);
+    let cost_in_usd_cents = cost_per_image * self.num_images as u64;
+    ImageGenerationCostEstimate {
+      cost_in_credits: Some(cost_in_usd_cents),
+      cost_in_usd_cents: Some(cost_in_usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+fn cost_per_image_in_cents(resolution: Option<CommonResolutionEnum>) -> u64 {
+  use CommonResolutionEnum as R;
+  match resolution {
+    None
+    | Some(R::HalfK)
+    | Some(R::OneK)
+    | Some(R::FourEightyP)
+    | Some(R::SevenTwentyP)
+    | Some(R::TenEightyP) => USD_CENTS_PER_IMAGE_1K,
+    Some(R::TwoK) | Some(R::ThreeK) | Some(R::FourK) => USD_CENTS_PER_IMAGE_2K,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+
+  fn estimate(resolution: Option<RouterResolution>, image_batch_count: u16) -> ImageGenerationCostEstimate {
+    let builder = GenerateImageRequestBuilder {
+      model: RouterImageModel::Seedream5p0Pro,
+      provider: RouterProvider::Artcraft,
+      prompt: Some("an anime girl riding a dinosaur".to_string()),
+      image_inputs: None,
+      resolution,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: Some(image_batch_count),
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    builder.build2().unwrap().estimate_cost().unwrap()
+  }
+
+  fn cost_cents(resolution: Option<RouterResolution>, image_batch_count: u16) -> u64 {
+    estimate(resolution, image_batch_count).cost_in_usd_cents.unwrap()
+  }
+
+  // ── Default / 1K (7¢) ──
+
+  #[test]
+  fn default_resolution_one_image_is_7c() { assert_eq!(cost_cents(None, 1), 7); }
+
+  #[test]
+  fn one_k_one_image_is_7c() { assert_eq!(cost_cents(Some(RouterResolution::OneK), 1), 7); }
+
+  #[test]
+  fn one_k_four_images_is_28c() { assert_eq!(cost_cents(Some(RouterResolution::OneK), 4), 28); }
+
+  // ── 2K (12¢) ──
+
+  #[test]
+  fn two_k_one_image_is_12c() { assert_eq!(cost_cents(Some(RouterResolution::TwoK), 1), 12); }
+
+  #[test]
+  fn two_k_four_images_is_48c() { assert_eq!(cost_cents(Some(RouterResolution::TwoK), 4), 48); }
+
+  // ── Fallbacks ──
+
+  #[test]
+  fn four_k_falls_back_to_two_k_pricing() {
+    assert_eq!(
+      ArtcraftSeedream5p0ProCostState {
+        resolution: Some(CommonResolutionEnum::FourK),
+        num_images: 1,
+      }.estimate_cost().cost_in_usd_cents,
+      Some(12),
+    );
+  }
+
+  #[test]
+  fn half_k_falls_back_to_one_k_pricing() {
+    assert_eq!(
+      ArtcraftSeedream5p0ProCostState {
+        resolution: Some(CommonResolutionEnum::HalfK),
+        num_images: 1,
+      }.estimate_cost().cost_in_usd_cents,
+      Some(7),
+    );
+  }
+
+  // ── Credits track USD cents exactly (1 credit = 1 cent) ──
+
+  #[test]
+  fn credits_equal_usd_cents() {
+    for batch in 1..=4u16 {
+      let one_k = estimate(Some(RouterResolution::OneK), batch);
+      assert_eq!(one_k.cost_in_credits, one_k.cost_in_usd_cents, "1k batch {}", batch);
+      let two_k = estimate(Some(RouterResolution::TwoK), batch);
+      assert_eq!(two_k.cost_in_credits, two_k.cost_in_usd_cents, "2k batch {}", batch);
+    }
+  }
+
+  // ── The Artcraft price must cover the Kinovi provider cost ──
+
+  #[test]
+  fn price_covers_kinovi_cost() {
+    use seedance2pro_client::generate::image::generate_seedream_5p0_pro::{
+      KinoviSeedream5p0ProBatchCount, KinoviSeedream5p0ProResolution,
+    };
+    use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::cost::KinoviSeedream5p0ProCostState;
+
+    let cases = [
+      (RouterResolution::OneK, KinoviSeedream5p0ProResolution::OneK, 1u16, KinoviSeedream5p0ProBatchCount::One),
+      (RouterResolution::OneK, KinoviSeedream5p0ProResolution::OneK, 4u16, KinoviSeedream5p0ProBatchCount::Four),
+      (RouterResolution::TwoK, KinoviSeedream5p0ProResolution::TwoK, 1u16, KinoviSeedream5p0ProBatchCount::One),
+      (RouterResolution::TwoK, KinoviSeedream5p0ProResolution::TwoK, 4u16, KinoviSeedream5p0ProBatchCount::Four),
+    ];
+    for (router_res, kinovi_res, batch, kinovi_batch) in cases {
+      let artcraft_cents = cost_cents(Some(router_res), batch);
+      let kinovi_cents = KinoviSeedream5p0ProCostState {
+        resolution: kinovi_res,
+        batch_count: kinovi_batch,
+      }.estimate_cost().cost_in_usd_cents.unwrap();
+      assert!(
+        artcraft_cents > kinovi_cents,
+        "artcraft price {}¢ must exceed kinovi cost {}¢ ({:?} batch {})",
+        artcraft_cents, kinovi_cents, router_res, batch,
+      );
+    }
+  }
+
+  // ── Flags ──
+
+  #[test]
+  fn cost_flags_are_correct() {
+    let cost = ArtcraftSeedream5p0ProCostState { resolution: None, num_images: 1 }.estimate_cost();
+    assert!(!cost.is_free);
+    assert!(!cost.is_unlimited);
+    assert!(!cost.is_rate_limited);
+    assert!(!cost.has_watermark);
+    assert_eq!(cost.failures_are_refunded, None);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/seedream_5p0_pro/mod.rs

@@ -0,0 +1,3 @@
+pub mod build;
+pub mod cost;
+pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/seedream_5p0_pro/request.rs

@@ -0,0 +1,17 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_image_cost_and_generate_request::OmniGenImageCostAndGenerateRequest;
+
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
+use crate::generate::generate_image::providers::artcraft::request_common::send_artcraft_omni_image_request;
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftSeedream5p0ProRequestState {
+  pub request: OmniGenImageCostAndGenerateRequest,
+}
+
+impl ArtcraftSeedream5p0ProRequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+    send_artcraft_omni_image_request(&self.request, client).await
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/kinovi/mod.rs

@@ -1,6 +1,7 @@
 pub mod midjourney_7;
 pub mod midjourney_7_niji;
 pub mod midjourney_8;
+pub mod seedream_5p0_pro;
 
 pub(crate) mod resolve;
 pub(crate) mod upload;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/kinovi/seedream_5p0_pro/build.rs

@@ -0,0 +1,408 @@
+use seedance2pro_client::generate::image::generate_seedream_5p0_pro::{
+  GenerateSeedream5p0ProRequest, KinoviSeedream5p0ProAspectRatio, KinoviSeedream5p0ProBatchCount,
+  KinoviSeedream5p0ProResolution, MAX_REFERENCE_IMAGES,
+};
+
+use crate::api::image_list_ref::ImageListRef;
+use crate::api::router_aspect_ratio::RouterAspectRatio;
+use crate::api::router_resolution::RouterResolution;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+use crate::generate::generate_image::image_generation_draft::ImageGenerationDraftRequest;
+use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::draft::{
+  KinoviSeedream5p0ProDraftState, KinoviSeedream5p0ProRemainingItems,
+};
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::request::KinoviSeedream5p0ProRequestState;
+
+pub fn build_kinovi_seedream_5p0_pro(
+  mut builder: GenerateImageRequestBuilder,
+) -> Result<ImageGenerationDraftOrRequest, ArtcraftRouterError> {
+  let strategy = builder.request_mismatch_mitigation_strategy;
+
+  let aspect_ratio = plan_aspect_ratio(builder.aspect_ratio.take(), strategy)?;
+  let resolution = plan_resolution(builder.resolution.take(), strategy)?;
+  let batch_count = plan_batch_count(builder.image_batch_count.take(), strategy)?;
+  let prompt = builder.prompt.take().unwrap_or_default();
+  let image_inputs = builder.image_inputs.take();
+
+  validate_reference_image_count(image_inputs.as_ref())?;
+
+  if !has_image_inputs(image_inputs.as_ref()) {
+    let request = GenerateSeedream5p0ProRequest {
+      prompt,
+      aspect_ratio,
+      resolution,
+      batch_count,
+      reference_image_urls: None,
+    };
+    return Ok(ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::KinoviSeedream5p0Pro(KinoviSeedream5p0ProRequestState { request }),
+    ));
+  }
+
+  let draft = KinoviSeedream5p0ProDraftState {
+    prompt,
+    aspect_ratio,
+    resolution,
+    batch_count,
+    unhandled_request_state: Some(KinoviSeedream5p0ProRemainingItems {
+      reference_images: image_inputs,
+    }),
+  };
+  Ok(ImageGenerationDraftOrRequest::Draft(
+    ImageGenerationDraftRequest::KinoviSeedream5p0Pro(draft),
+  ))
+}
+
+fn has_image_inputs(image_inputs: Option<&ImageListRef>) -> bool {
+  match image_inputs {
+    None => false,
+    Some(ImageListRef::Urls(urls)) => !urls.is_empty(),
+    Some(ImageListRef::MediaFileTokens(tokens)) => !tokens.is_empty(),
+  }
+}
+
+/// Reject over-limit reference lists before any uploads happen — the
+/// Seedance2Pro client would reject them anyway, but only after the draft
+/// stage has already uploaded every image to the Kinovi CDN.
+fn validate_reference_image_count(
+  image_inputs: Option<&ImageListRef>,
+) -> Result<(), ArtcraftRouterError> {
+  let count = match image_inputs {
+    None => 0,
+    Some(ImageListRef::Urls(urls)) => urls.len(),
+    Some(ImageListRef::MediaFileTokens(tokens)) => tokens.len(),
+  };
+  if count > MAX_REFERENCE_IMAGES {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "image_inputs",
+      value: format!("{} reference images (max {})", count, MAX_REFERENCE_IMAGES),
+    }));
+  }
+  Ok(())
+}
+
+// ── Plan helpers ──
+
+pub(crate) fn plan_aspect_ratio(
+  aspect_ratio: Option<RouterAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<KinoviSeedream5p0ProAspectRatio, ArtcraftRouterError> {
+  use KinoviSeedream5p0ProAspectRatio as Ar;
+  match aspect_ratio {
+    None
+    | Some(RouterAspectRatio::Auto)
+    | Some(RouterAspectRatio::Auto2k)
+    | Some(RouterAspectRatio::Auto3k)
+    | Some(RouterAspectRatio::Auto4k) => Ok(Ar::Auto),
+
+    Some(RouterAspectRatio::Square) | Some(RouterAspectRatio::SquareHd) => Ok(Ar::Square1x1),
+    Some(RouterAspectRatio::WideFourByThree) => Ok(Ar::Standard4x3),
+    Some(RouterAspectRatio::TallThreeByFour) => Ok(Ar::Portrait3x4),
+    Some(RouterAspectRatio::WideSixteenByNine) | Some(RouterAspectRatio::Wide) => Ok(Ar::Landscape16x9),
+    Some(RouterAspectRatio::TallNineBySixteen) | Some(RouterAspectRatio::Tall) => Ok(Ar::Portrait9x16),
+    Some(RouterAspectRatio::WideThreeByTwo) => Ok(Ar::Wide3x2),
+    Some(RouterAspectRatio::TallTwoByThree) => Ok(Ar::Tall2x3),
+    Some(RouterAspectRatio::WideTwentyOneByNine) => Ok(Ar::UltraWide21x9),
+
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      _ => Ok(Ar::Auto),
+    },
+  }
+}
+
+pub(crate) fn plan_resolution(
+  resolution: Option<RouterResolution>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<KinoviSeedream5p0ProResolution, ArtcraftRouterError> {
+  use KinoviSeedream5p0ProResolution as Res;
+  match resolution {
+    None | Some(RouterResolution::OneK) => Ok(Res::OneK),
+    Some(RouterResolution::TwoK) => Ok(Res::TwoK),
+
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "resolution",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      // Snap to the nearest supported tier: sub-1k inputs (0.5K, legacy
+      // video resolutions) land on 1k; 3K/4K land on 2k.
+      _ => match unsupported {
+        RouterResolution::ThreeK | RouterResolution::FourK => Ok(Res::TwoK),
+        _ => Ok(Res::OneK),
+      },
+    },
+  }
+}
+
+pub(crate) fn plan_batch_count(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<KinoviSeedream5p0ProBatchCount, ArtcraftRouterError> {
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(KinoviSeedream5p0ProBatchCount::One),
+    2 => Ok(KinoviSeedream5p0ProBatchCount::Two),
+    3 => Ok(KinoviSeedream5p0ProBatchCount::Three),
+    4 => Ok(KinoviSeedream5p0ProBatchCount::Four),
+    5 => Ok(KinoviSeedream5p0ProBatchCount::Five),
+    6 => Ok(KinoviSeedream5p0ProBatchCount::Six),
+    7 => Ok(KinoviSeedream5p0ProBatchCount::Seven),
+    8 => Ok(KinoviSeedream5p0ProBatchCount::Eight),
+    other => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", other),
+        }))
+      }
+      // Kinovi supports batches of 1–8; only counts of 9+ reach here, so both
+      // mitigation strategies clamp to the maximum supported batch.
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(KinoviSeedream5p0ProBatchCount::Eight)
+      }
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+
+  use super::*;
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::Seedream5p0Pro,
+      provider: RouterProvider::Seedance2Pro,
+      prompt: Some("an anime girl riding a dinosaur".to_string()),
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: None,
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn build_request(builder: GenerateImageRequestBuilder) -> KinoviSeedream5p0ProRequestState {
+    match build_kinovi_seedream_5p0_pro(builder).expect("build") {
+      ImageGenerationDraftOrRequest::Request(ImageGenerationRequest::KinoviSeedream5p0Pro(r)) => r,
+      _ => panic!("expected Request"),
+    }
+  }
+
+  mod routing_tests {
+    use super::*;
+
+    #[test]
+    fn no_image_inputs_returns_request_directly() {
+      let result = build_kinovi_seedream_5p0_pro(base_builder()).expect("build");
+      assert!(matches!(
+        result,
+        ImageGenerationDraftOrRequest::Request(ImageGenerationRequest::KinoviSeedream5p0Pro(_)),
+      ));
+    }
+
+    #[test]
+    fn image_inputs_returns_draft() {
+      let builder = GenerateImageRequestBuilder {
+        image_inputs: Some(ImageListRef::Urls(vec!["https://example.com/ref.png".to_string()])),
+        ..base_builder()
+      };
+      let result = build_kinovi_seedream_5p0_pro(builder).expect("build");
+      assert!(matches!(
+        result,
+        ImageGenerationDraftOrRequest::Draft(ImageGenerationDraftRequest::KinoviSeedream5p0Pro(_)),
+      ));
+    }
+
+    #[test]
+    fn media_file_tokens_route_through_draft() {
+      let builder = GenerateImageRequestBuilder {
+        image_inputs: Some(ImageListRef::MediaFileTokens(vec![
+          MediaFileToken::new("mf_x".to_string()),
+        ])),
+        ..base_builder()
+      };
+      let draft = match build_kinovi_seedream_5p0_pro(builder).expect("build") {
+        ImageGenerationDraftOrRequest::Draft(ImageGenerationDraftRequest::KinoviSeedream5p0Pro(d)) => d,
+        _ => panic!("expected Draft"),
+      };
+      assert!(draft.unhandled_request_state.is_some());
+    }
+
+    #[test]
+    fn fourteen_reference_images_is_accepted() {
+      let urls: Vec<String> = (0..MAX_REFERENCE_IMAGES)
+        .map(|i| format!("https://example.com/ref{i}.png"))
+        .collect();
+      let builder = GenerateImageRequestBuilder {
+        image_inputs: Some(ImageListRef::Urls(urls)),
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedream_5p0_pro(builder).is_ok());
+    }
+
+    #[test]
+    fn fifteen_reference_images_is_rejected() {
+      let urls: Vec<String> = (0..MAX_REFERENCE_IMAGES + 1)
+        .map(|i| format!("https://example.com/ref{i}.png"))
+        .collect();
+      let builder = GenerateImageRequestBuilder {
+        image_inputs: Some(ImageListRef::Urls(urls)),
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedream_5p0_pro(builder).is_err());
+    }
+  }
+
+  mod plan_tests {
+    use super::*;
+
+    #[test]
+    fn default_aspect_ratio_is_auto() {
+      let req = build_request(base_builder());
+      assert_eq!(req.request.aspect_ratio, KinoviSeedream5p0ProAspectRatio::Auto);
+    }
+
+    #[test]
+    fn every_supported_aspect_ratio_maps() {
+      let cases = [
+        (RouterAspectRatio::Auto, KinoviSeedream5p0ProAspectRatio::Auto),
+        (RouterAspectRatio::Square, KinoviSeedream5p0ProAspectRatio::Square1x1),
+        (RouterAspectRatio::WideFourByThree, KinoviSeedream5p0ProAspectRatio::Standard4x3),
+        (RouterAspectRatio::TallThreeByFour, KinoviSeedream5p0ProAspectRatio::Portrait3x4),
+        (RouterAspectRatio::WideSixteenByNine, KinoviSeedream5p0ProAspectRatio::Landscape16x9),
+        (RouterAspectRatio::TallNineBySixteen, KinoviSeedream5p0ProAspectRatio::Portrait9x16),
+        (RouterAspectRatio::WideThreeByTwo, KinoviSeedream5p0ProAspectRatio::Wide3x2),
+        (RouterAspectRatio::TallTwoByThree, KinoviSeedream5p0ProAspectRatio::Tall2x3),
+        (RouterAspectRatio::WideTwentyOneByNine, KinoviSeedream5p0ProAspectRatio::UltraWide21x9),
+      ];
+      for (input, expected) in cases {
+        let planned = plan_aspect_ratio(Some(input), RequestMismatchMitigationStrategy::ErrorOut)
+          .expect("plan");
+        assert_eq!(planned, expected, "input={:?}", input);
+      }
+    }
+
+    #[test]
+    fn unsupported_aspect_ratio_errors_out() {
+      let result = plan_aspect_ratio(
+        Some(RouterAspectRatio::TallNineByTwentyOne),
+        RequestMismatchMitigationStrategy::ErrorOut,
+      );
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn unsupported_aspect_ratio_falls_back_to_auto() {
+      let planned = plan_aspect_ratio(
+        Some(RouterAspectRatio::TallNineByTwentyOne),
+        RequestMismatchMitigationStrategy::PayLessDowngrade,
+      ).expect("plan");
+      assert_eq!(planned, KinoviSeedream5p0ProAspectRatio::Auto);
+    }
+
+    #[test]
+    fn default_resolution_is_1k() {
+      let req = build_request(base_builder());
+      assert_eq!(req.request.resolution, KinoviSeedream5p0ProResolution::OneK);
+    }
+
+    #[test]
+    fn two_k_resolution_maps() {
+      let builder = GenerateImageRequestBuilder {
+        resolution: Some(RouterResolution::TwoK),
+        ..base_builder()
+      };
+      let req = build_request(builder);
+      assert_eq!(req.request.resolution, KinoviSeedream5p0ProResolution::TwoK);
+    }
+
+    #[test]
+    fn four_k_resolution_errors_out() {
+      let result = plan_resolution(
+        Some(RouterResolution::FourK),
+        RequestMismatchMitigationStrategy::ErrorOut,
+      );
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn four_k_resolution_downgrades_to_2k() {
+      let planned = plan_resolution(
+        Some(RouterResolution::FourK),
+        RequestMismatchMitigationStrategy::PayLessDowngrade,
+      ).expect("plan");
+      assert_eq!(planned, KinoviSeedream5p0ProResolution::TwoK);
+    }
+
+    #[test]
+    fn half_k_resolution_snaps_to_1k() {
+      let planned = plan_resolution(
+        Some(RouterResolution::HalfK),
+        RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      ).expect("plan");
+      assert_eq!(planned, KinoviSeedream5p0ProResolution::OneK);
+    }
+
+    #[test]
+    fn batch_counts_one_through_eight_are_accepted() {
+      let cases = [
+        (1, KinoviSeedream5p0ProBatchCount::One),
+        (2, KinoviSeedream5p0ProBatchCount::Two),
+        (3, KinoviSeedream5p0ProBatchCount::Three),
+        (4, KinoviSeedream5p0ProBatchCount::Four),
+        (5, KinoviSeedream5p0ProBatchCount::Five),
+        (6, KinoviSeedream5p0ProBatchCount::Six),
+        (7, KinoviSeedream5p0ProBatchCount::Seven),
+        (8, KinoviSeedream5p0ProBatchCount::Eight),
+      ];
+      for (input, expected) in cases {
+        let planned = plan_batch_count(Some(input), RequestMismatchMitigationStrategy::ErrorOut)
+          .expect("plan");
+        assert_eq!(planned, expected, "input={}", input);
+      }
+    }
+
+    #[test]
+    fn batch_count_zero_is_rejected() {
+      assert!(plan_batch_count(Some(0), RequestMismatchMitigationStrategy::ErrorOut).is_err());
+    }
+
+    #[test]
+    fn batch_count_nine_errors_out() {
+      assert!(plan_batch_count(Some(9), RequestMismatchMitigationStrategy::ErrorOut).is_err());
+    }
+
+    #[test]
+    fn batch_count_nine_clamps_to_eight() {
+      let planned = plan_batch_count(Some(9), RequestMismatchMitigationStrategy::PayLessDowngrade)
+        .expect("plan");
+      assert_eq!(planned, KinoviSeedream5p0ProBatchCount::Eight);
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/kinovi/seedream_5p0_pro/cost.rs

@@ -0,0 +1,100 @@
+use seedance2pro_client::generate::image::generate_seedream_5p0_pro::{
+  GenerateSeedream5p0ProRequest, KinoviSeedream5p0ProAspectRatio, KinoviSeedream5p0ProBatchCount,
+  KinoviSeedream5p0ProResolution,
+};
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::draft::KinoviSeedream5p0ProDraftState;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::request::KinoviSeedream5p0ProRequestState;
+
+/// Seedream 5.0 Pro (via Kinovi) cost state. Pricing is per image and
+/// resolution-dependent (1k vs 2k); batch count multiplies.
+pub struct KinoviSeedream5p0ProCostState {
+  pub resolution: KinoviSeedream5p0ProResolution,
+  pub batch_count: KinoviSeedream5p0ProBatchCount,
+}
+
+impl KinoviSeedream5p0ProCostState {
+  pub fn from_request(request: &KinoviSeedream5p0ProRequestState) -> Self {
+    Self {
+      resolution: request.request.resolution,
+      batch_count: request.request.batch_count,
+    }
+  }
+
+  pub fn from_draft(draft: &KinoviSeedream5p0ProDraftState) -> Self {
+    Self {
+      resolution: draft.resolution,
+      batch_count: draft.batch_count,
+    }
+  }
+
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    let pricing_request = GenerateSeedream5p0ProRequest {
+      prompt: String::new(),
+      aspect_ratio: KinoviSeedream5p0ProAspectRatio::Auto,
+      resolution: self.resolution,
+      batch_count: self.batch_count,
+      reference_image_urls: None,
+    };
+
+    let costs = pricing_request.calculate_costs();
+
+    ImageGenerationCostEstimate {
+      cost_in_credits: Some(costs.kinovi_credits),
+      cost_in_usd_cents: Some(costs.usd_cents_rounded_up),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn one_1k_image_is_fourteen_credits_and_six_cents() {
+    let cost = KinoviSeedream5p0ProCostState {
+      resolution: KinoviSeedream5p0ProResolution::OneK,
+      batch_count: KinoviSeedream5p0ProBatchCount::One,
+    }.estimate_cost();
+    assert_eq!(cost.cost_in_credits, Some(14));
+    assert_eq!(cost.cost_in_usd_cents, Some(6)); // 1400/243 = 5.76 -> rounds UP
+  }
+
+  #[test]
+  fn one_2k_image_is_twentyfour_credits_and_ten_cents() {
+    let cost = KinoviSeedream5p0ProCostState {
+      resolution: KinoviSeedream5p0ProResolution::TwoK,
+      batch_count: KinoviSeedream5p0ProBatchCount::One,
+    }.estimate_cost();
+    assert_eq!(cost.cost_in_credits, Some(24));
+    assert_eq!(cost.cost_in_usd_cents, Some(10)); // 2400/243 = 9.88 -> rounds UP
+  }
+
+  /// Mirrors capture 4_seedream_5_misc.txt: 2k, batch of 4 → 96 credits.
+  #[test]
+  fn four_2k_images_is_ninetysix_credits() {
+    let cost = KinoviSeedream5p0ProCostState {
+      resolution: KinoviSeedream5p0ProResolution::TwoK,
+      batch_count: KinoviSeedream5p0ProBatchCount::Four,
+    }.estimate_cost();
+    assert_eq!(cost.cost_in_credits, Some(96));
+    assert_eq!(cost.cost_in_usd_cents, Some(40)); // 9600/243 = 39.51 -> rounds UP
+  }
+
+  /// Mirrors capture 5_seedream_5_misc2.txt: 1k, batch of 8 → 112 credits.
+  #[test]
+  fn eight_1k_images_is_one_hundred_twelve_credits() {
+    let cost = KinoviSeedream5p0ProCostState {
+      resolution: KinoviSeedream5p0ProResolution::OneK,
+      batch_count: KinoviSeedream5p0ProBatchCount::Eight,
+    }.estimate_cost();
+    assert_eq!(cost.cost_in_credits, Some(112));
+    assert_eq!(cost.cost_in_usd_cents, Some(47)); // 11200/243 = 46.09 -> rounds UP
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/kinovi/seedream_5p0_pro/draft.rs

@@ -0,0 +1,53 @@
+use seedance2pro_client::generate::image::generate_seedream_5p0_pro::{
+  GenerateSeedream5p0ProRequest, KinoviSeedream5p0ProAspectRatio, KinoviSeedream5p0ProBatchCount,
+  KinoviSeedream5p0ProResolution,
+};
+
+use crate::api::image_list_ref::ImageListRef;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::image_generation_draft_context::ImageGenerationDraftContext;
+use crate::generate::generate_image::providers::kinovi::resolve::resolve_and_upload_image_list;
+use crate::generate::generate_image::providers::kinovi::seedream_5p0_pro::request::KinoviSeedream5p0ProRequestState;
+
+#[derive(Debug, Clone)]
+pub struct KinoviSeedream5p0ProDraftState {
+  pub prompt: String,
+  pub aspect_ratio: KinoviSeedream5p0ProAspectRatio,
+  pub resolution: KinoviSeedream5p0ProResolution,
+  pub batch_count: KinoviSeedream5p0ProBatchCount,
+
+  pub unhandled_request_state: Option<KinoviSeedream5p0ProRemainingItems>,
+}
+
+#[derive(Debug, Clone)]
+pub struct KinoviSeedream5p0ProRemainingItems {
+  pub reference_images: Option<ImageListRef>,
+}
+
+impl KinoviSeedream5p0ProDraftState {
+  pub async fn to_request(
+    &mut self,
+    draft_context: &ImageGenerationDraftContext<'_>,
+  ) -> Result<KinoviSeedream5p0ProRequestState, ArtcraftRouterError> {
+    let client = draft_context.get_seedance2pro_client_ref()?;
+    let session = &client.session;
+
+    let mut reference_image_urls = None;
+    if let Some(remaining) = self.unhandled_request_state.take() {
+      let map = draft_context.media_file_to_artcraft_url_map;
+      reference_image_urls = resolve_and_upload_image_list(
+        session, remaining.reference_images, map,
+      ).await?;
+    }
+
+    let request = GenerateSeedream5p0ProRequest {
+      prompt: self.prompt.clone(),
+      aspect_ratio: self.aspect_ratio,
+      resolution: self.resolution,
+      batch_count: self.batch_count,
+      reference_image_urls,
+    };
+
+    Ok(KinoviSeedream5p0ProRequestState { request })
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/kinovi/seedream_5p0_pro/mod.rs

@@ -0,0 +1,4 @@
+pub mod build;
+pub mod cost;
+pub mod draft;
+pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/kinovi/seedream_5p0_pro/request.rs

@@ -0,0 +1,141 @@
+use seedance2pro_client::generate::image::generate_seedream_5p0_pro::{
+  generate_seedream_5p0_pro, GenerateSeedream5p0ProArgs, GenerateSeedream5p0ProRequest,
+};
+
+use crate::client::router_seedance2pro_client::RouterSeedance2ProClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  GenerateImageResponse, Seedance2proImageResponsePayload,
+};
+
+#[derive(Debug, Clone)]
+pub struct KinoviSeedream5p0ProRequestState {
+  pub request: GenerateSeedream5p0ProRequest,
+}
+
+impl KinoviSeedream5p0ProRequestState {
+  pub async fn send(
+    &self,
+    client: &RouterSeedance2ProClient,
+  ) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+    let args = GenerateSeedream5p0ProArgs {
+      session: &client.session,
+      host_override: None,
+      request: self.request.clone(),
+    };
+
+    let response = generate_seedream_5p0_pro(args)
+      .await
+      .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Seedance2Pro(err)))?;
+
+    Ok(GenerateImageResponse::Seedance2Pro(Seedance2proImageResponsePayload {
+      order_id: response.order_id,
+      task_id: response.task_id,
+      maybe_order_ids: response.order_ids,
+      maybe_task_ids: response.task_ids,
+    }))
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use std::collections::HashMap;
+
+  use seedance2pro_client::creds::seedance2pro_session::Seedance2ProSession;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::client::router_client::RouterClient;
+  use crate::client::router_seedance2pro_client::RouterSeedance2ProClient;
+  use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+  use crate::generate::generate_image::image_generation_draft::ImageGenerationDraftRequest;
+  use crate::generate::generate_image::image_generation_draft_context::ImageGenerationDraftContext;
+  use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+  use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+  use test_data::web::image_urls::JUNO_AT_LAKE_IMAGE_URL;
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::Seedream5p0Pro,
+      provider: RouterProvider::Seedance2Pro,
+      prompt: Some("an anime girl riding a dinosaur through a neon city".to_string()),
+      image_inputs: None,
+      resolution: Some(RouterResolution::OneK),
+      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
+      quality: None,
+      image_batch_count: Some(1),
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn get_kinovi_client() -> RouterClient {
+    let cookies = std::fs::read_to_string("/Users/bt/Artcraft/credentials/seedance2pro_cookies.txt")
+      .expect("Failed to read seedance2pro cookies");
+    let session = Seedance2ProSession::from_cookies_string(cookies.trim().to_string());
+    RouterClient::Seedance2Pro(RouterSeedance2ProClient::new(session))
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies; costs credits
+  async fn text_to_image_round_trip() {
+    let client = get_kinovi_client();
+    let result = base_builder().build2().expect("build2");
+
+    let request = match result {
+      ImageGenerationDraftOrRequest::Request(ImageGenerationRequest::KinoviSeedream5p0Pro(r)) => r,
+      _ => panic!("expected direct Request for text-to-image"),
+    };
+
+    let response = request.send(client.get_seedance2pro_client_ref().unwrap())
+      .await.expect("send should succeed");
+    let payload = response.get_seedance2pro_payload().expect("expected seedance2pro payload");
+    println!("seedream 5.0 pro t2i — task_id={}, order_id={}", payload.task_id, payload.order_id);
+    assert!(!payload.task_id.is_empty());
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies; costs credits
+  async fn image_reference_round_trip_via_draft() {
+    let client = get_kinovi_client();
+    let token = MediaFileToken::new("mf_test_juno_seedream5".to_string());
+
+    let mut map = HashMap::new();
+    map.insert(token.clone(), JUNO_AT_LAKE_IMAGE_URL.to_string());
+
+    let builder = GenerateImageRequestBuilder {
+      prompt: Some("The dog in @Image1 wearing a tiny crown in a royal palace".to_string()),
+      image_inputs: Some(ImageListRef::MediaFileTokens(vec![token])),
+      ..base_builder()
+    };
+
+    let draft_or_request = builder.build2().expect("build2");
+    let draft = match draft_or_request {
+      ImageGenerationDraftOrRequest::Draft(ImageGenerationDraftRequest::KinoviSeedream5p0Pro(d)) => d,
+      _ => panic!("expected Draft for image-input flow"),
+    };
+
+    let ctx = ImageGenerationDraftContext {
+      client: Some(&client),
+      media_file_to_artcraft_url_map: Some(&map),
+    };
+
+    let request = ImageGenerationDraftRequest::KinoviSeedream5p0Pro(draft)
+      .finalize(ctx).await.expect("finalize");
+
+    let response = request.send_request(&client).await.expect("send_request");
+    let payload = response.get_seedance2pro_payload().expect("expected seedance2pro payload");
+    println!("seedream 5.0 pro with ref — task_id={}, order_id={}", payload.task_id, payload.order_id);
+    assert!(!payload.task_id.is_empty());
+  }
+}

crates/api_clients/seedance2pro_client/src/generate/image/generate_seedream_5p0_pro.rs

@@ -0,0 +1,620 @@
+use serde_derive::Serialize;
+
+use crate::cost::kinovi_generation_cost::KinoviGenerationCost;
+use crate::creds::seedance2pro_session::Seedance2ProSession;
+use crate::error::seedance2pro_client_error::Seedance2ProClientError;
+use crate::error::seedance2pro_error::Seedance2ProError;
+use crate::requests::kinovi_host::KinoviHost;
+use crate::requests::workflow_run_task::workflow_run_task::{
+  workflow_run_task_custom, WorkflowRunTaskCustomArgs, WorkflowRunTaskResponse,
+};
+
+const BUSINESS_TYPE: &str = "seedream-5-pro-image-generation";
+const MODEL: &str = "seedream-5.0-pro";
+
+/// Kinovi allows at most this many reference images per request.
+pub const MAX_REFERENCE_IMAGES: usize = 14;
+
+/// Credits per generated image at 1k resolution.
+const CREDITS_PER_IMAGE_1K: u64 = 14;
+
+/// Credits per generated image at 2k resolution.
+const CREDITS_PER_IMAGE_2K: u64 = 24;
+
+// ── Args ──
+
+pub struct GenerateSeedream5p0ProArgs<'a> {
+  pub request: GenerateSeedream5p0ProRequest,
+  pub session: &'a Seedance2ProSession,
+  pub host_override: Option<KinoviHost>,
+}
+
+// ── Request ──
+
+/// Seedream 5.0 Pro: text-to-image (optionally with reference images).
+#[derive(Clone, Debug)]
+pub struct GenerateSeedream5p0ProRequest {
+  /// Reference images are cited in the prompt as @Image1, @Image2, etc.
+  pub prompt: String,
+
+  pub aspect_ratio: KinoviSeedream5p0ProAspectRatio,
+
+  pub resolution: KinoviSeedream5p0ProResolution,
+
+  /// Number of images to generate in a single request.
+  pub batch_count: KinoviSeedream5p0ProBatchCount,
+
+  /// Optional reference image URLs, up to [`MAX_REFERENCE_IMAGES`].
+  /// Referenced in prompts as @Image1, @Image2, etc.
+  pub reference_image_urls: Option<Vec<String>>,
+}
+
+// ── Enums ──
+
+/// Aspect ratios supported by Seedream 5.0 Pro.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum KinoviSeedream5p0ProAspectRatio {
+  /// Let the model pick (useful with reference images).
+  Auto,
+  Square1x1,
+  Standard4x3,
+  Portrait3x4,
+  Landscape16x9,
+  Portrait9x16,
+  Wide3x2,
+  Tall2x3,
+  UltraWide21x9,
+}
+
+/// Output resolution. Determines the per-image credit price.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum KinoviSeedream5p0ProResolution {
+  /// 1k (14 credits per image)
+  OneK,
+  /// 2k (24 credits per image)
+  TwoK,
+}
+
+/// Number of images to generate in a single request.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum KinoviSeedream5p0ProBatchCount {
+  One,
+  Two,
+  Three,
+  Four,
+  Five,
+  Six,
+  Seven,
+  Eight,
+}
+
+// ── Pricing ──
+//
+// Seedream 5.0 Pro credit pricing (per image; batch count multiplies):
+//
+// | Resolution | Credits/image |
+// |------------|---------------|
+// | 1k         |            14 |
+// | 2k         |            24 |
+//
+// Reference images do not affect cost.
+// Credit package: 525,000 credits for $2,159.0909 (~243.16 credits/$1, rounded down to 243).
+
+impl GenerateSeedream5p0ProRequest {
+  /// Calculate the cost of this generation request, in Kinovi credits and
+  /// USD cents.
+  pub fn calculate_costs(&self) -> KinoviGenerationCost {
+    let credits_per_image = match self.resolution {
+      KinoviSeedream5p0ProResolution::OneK => CREDITS_PER_IMAGE_1K,
+      KinoviSeedream5p0ProResolution::TwoK => CREDITS_PER_IMAGE_2K,
+    };
+    let total_credits = credits_per_image * u64::from(self.batch_count.as_u8());
+    KinoviGenerationCost::from_kinovi_credits(total_credits)
+  }
+}
+
+impl KinoviSeedream5p0ProBatchCount {
+  fn as_u8(&self) -> u8 {
+    match self {
+      Self::One => 1,
+      Self::Two => 2,
+      Self::Three => 3,
+      Self::Four => 4,
+      Self::Five => 5,
+      Self::Six => 6,
+      Self::Seven => 7,
+      Self::Eight => 8,
+    }
+  }
+}
+
+impl KinoviSeedream5p0ProAspectRatio {
+  fn as_api_str(&self) -> &'static str {
+    match self {
+      Self::Auto => "auto",
+      Self::Square1x1 => "1:1",
+      Self::Standard4x3 => "4:3",
+      Self::Portrait3x4 => "3:4",
+      Self::Landscape16x9 => "16:9",
+      Self::Portrait9x16 => "9:16",
+      Self::Wide3x2 => "3:2",
+      Self::Tall2x3 => "2:3",
+      Self::UltraWide21x9 => "21:9",
+    }
+  }
+}
+
+impl KinoviSeedream5p0ProResolution {
+  fn as_api_str(&self) -> &'static str {
+    match self {
+      Self::OneK => "1k",
+      Self::TwoK => "2k",
+    }
+  }
+}
+
+// ── Response ──
+
+pub struct GenerateSeedream5p0ProResponse {
+  pub task_id: String,
+  pub order_id: String,
+
+  /// Present when batch_count > 1.
+  pub task_ids: Option<Vec<String>>,
+
+  /// Present when batch_count > 1.
+  pub order_ids: Option<Vec<String>>,
+}
+
+// ── Entry point ──
+
+pub async fn generate_seedream_5p0_pro(
+  args: GenerateSeedream5p0ProArgs<'_>,
+) -> Result<GenerateSeedream5p0ProResponse, Seedance2ProError> {
+  let api_params = build_api_params(&args.request)?;
+
+  let raw_response: WorkflowRunTaskResponse = workflow_run_task_custom(WorkflowRunTaskCustomArgs {
+    business_type: BUSINESS_TYPE,
+    api_params,
+    session: args.session,
+    host_override: args.host_override,
+  }).await?;
+
+  Ok(GenerateSeedream5p0ProResponse {
+    task_id: raw_response.task_id,
+    order_id: raw_response.order_id,
+    task_ids: raw_response.task_ids,
+    order_ids: raw_response.order_ids,
+  })
+}
+
+// ── Wire payload ──
+
+/// The `apiParams` shape for `seedream-5-pro-image-generation`. Field order
+/// matches the captured browser traffic.
+#[derive(Serialize, Debug)]
+struct Seedream5p0ProApiParams {
+  prompt: String,
+  #[serde(rename = "aspectRatio")]
+  aspect_ratio: &'static str,
+  resolution: &'static str,
+  model: &'static str,
+  /// Omitted when generating a single image.
+  #[serde(rename = "batchCount", skip_serializing_if = "Option::is_none")]
+  batch_count: Option<u8>,
+  /// Omitted when no reference images are attached.
+  #[serde(rename = "uploadedUrls", skip_serializing_if = "Option::is_none")]
+  uploaded_urls: Option<Vec<String>>,
+}
+
+fn build_api_params(
+  request: &GenerateSeedream5p0ProRequest,
+) -> Result<Seedream5p0ProApiParams, Seedance2ProClientError> {
+  let uploaded_urls = match &request.reference_image_urls {
+    Some(urls) if urls.len() > MAX_REFERENCE_IMAGES => {
+      return Err(Seedance2ProClientError::InvalidRequestField {
+        field: "reference_image_urls",
+        raw_value: format!("{} urls", urls.len()),
+        reason: format!("At most {} reference images are allowed", MAX_REFERENCE_IMAGES),
+      });
+    }
+    Some(urls) if !urls.is_empty() => Some(urls.clone()),
+    _ => None,
+  };
+
+  let batch_count_value = request.batch_count.as_u8();
+  let batch_count = if batch_count_value > 1 { Some(batch_count_value) } else { None };
+
+  Ok(Seedream5p0ProApiParams {
+    prompt: request.prompt.clone(),
+    aspect_ratio: request.aspect_ratio.as_api_str(),
+    resolution: request.resolution.as_api_str(),
+    model: MODEL,
+    batch_count,
+    uploaded_urls,
+  })
+}
+
+// ── Tests ──
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  fn base_request() -> GenerateSeedream5p0ProRequest {
+    GenerateSeedream5p0ProRequest {
+      prompt: "An anime girl riding a dinosaur".to_string(),
+      aspect_ratio: KinoviSeedream5p0ProAspectRatio::Auto,
+      resolution: KinoviSeedream5p0ProResolution::TwoK,
+      batch_count: KinoviSeedream5p0ProBatchCount::One,
+      reference_image_urls: None,
+    }
+  }
+
+  mod request_shape_tests {
+    use super::*;
+
+    /// Mirrors capture 1_seedream_5.txt (auto aspect ratio, 2k, single image,
+    /// no references).
+    #[test]
+    fn auto_2k_single_image() {
+      let params = build_api_params(&base_request()).unwrap();
+      assert_eq!(
+        serde_json::to_string(&params).unwrap(),
+        r#"{"prompt":"An anime girl riding a dinosaur","aspectRatio":"auto","resolution":"2k","model":"seedream-5.0-pro"}"#,
+      );
+    }
+
+    /// Mirrors capture 2_seedream_5_21x9.txt (21:9, 2k, single image).
+    #[test]
+    fn ultra_wide_21x9_2k() {
+      let params = build_api_params(&GenerateSeedream5p0ProRequest {
+        prompt: "a pirate sailing a pirate ship".to_string(),
+        aspect_ratio: KinoviSeedream5p0ProAspectRatio::UltraWide21x9,
+        resolution: KinoviSeedream5p0ProResolution::TwoK,
+        batch_count: KinoviSeedream5p0ProBatchCount::One,
+        reference_image_urls: None,
+      }).unwrap();
+      assert_eq!(
+        serde_json::to_string(&params).unwrap(),
+        r#"{"prompt":"a pirate sailing a pirate ship","aspectRatio":"21:9","resolution":"2k","model":"seedream-5.0-pro"}"#,
+      );
+    }
+
+    /// Mirrors capture 3_seedream_5_9x16_image_refs.txt (9:16, 1k, single
+    /// image, two reference images).
+    #[test]
+    fn portrait_9x16_1k_with_image_references() {
+      let params = build_api_params(&GenerateSeedream5p0ProRequest {
+        prompt: "The man in @Image1 is staring out the door in @Image2 ".to_string(),
+        aspect_ratio: KinoviSeedream5p0ProAspectRatio::Portrait9x16,
+        resolution: KinoviSeedream5p0ProResolution::OneK,
+        batch_count: KinoviSeedream5p0ProBatchCount::One,
+        reference_image_urls: Some(vec![
+          "https://static.seedance2-pro.com/materials/20260713/1783904468032-0a803390.jpg".to_string(),
+          "https://static.seedance2-pro.com/materials/20260713/1783904481112-4a3fa0d2.png".to_string(),
+        ]),
+      }).unwrap();
+      assert_eq!(
+        serde_json::to_string(&params).unwrap(),
+        r#"{"prompt":"The man in @Image1 is staring out the door in @Image2 ","aspectRatio":"9:16","resolution":"1k","model":"seedream-5.0-pro","uploadedUrls":["https://static.seedance2-pro.com/materials/20260713/1783904468032-0a803390.jpg","https://static.seedance2-pro.com/materials/20260713/1783904481112-4a3fa0d2.png"]}"#,
+      );
+    }
+
+    /// Mirrors capture 4_seedream_5_misc.txt (2:3, 2k, batch of 4, two
+    /// reference images).
+    #[test]
+    fn tall_2x3_2k_batch_four_with_image_references() {
+      let params = build_api_params(&GenerateSeedream5p0ProRequest {
+        prompt: "An anime girl is standing in the door @Image1 Outside the door, there's the galaxy and windmill @Image2 ".to_string(),
+        aspect_ratio: KinoviSeedream5p0ProAspectRatio::Tall2x3,
+        resolution: KinoviSeedream5p0ProResolution::TwoK,
+        batch_count: KinoviSeedream5p0ProBatchCount::Four,
+        reference_image_urls: Some(vec![
+          "https://static.seedance2-pro.com/materials/20260713/1783904481112-4a3fa0d2.png".to_string(),
+          "https://static.seedance2-pro.com/materials/20260713/1783904588294-5c713908.jpg".to_string(),
+        ]),
+      }).unwrap();
+      assert_eq!(
+        serde_json::to_string(&params).unwrap(),
+        r#"{"prompt":"An anime girl is standing in the door @Image1 Outside the door, there's the galaxy and windmill @Image2 ","aspectRatio":"2:3","resolution":"2k","model":"seedream-5.0-pro","batchCount":4,"uploadedUrls":["https://static.seedance2-pro.com/materials/20260713/1783904481112-4a3fa0d2.png","https://static.seedance2-pro.com/materials/20260713/1783904588294-5c713908.jpg"]}"#,
+      );
+    }
+
+    /// Mirrors capture 5_seedream_5_misc2.txt (1:1, 1k, batch of 8, two
+    /// reference images).
+    #[test]
+    fn square_1x1_1k_batch_eight_with_image_references() {
+      let params = build_api_params(&GenerateSeedream5p0ProRequest {
+        prompt: "The mirror from @Image2 is in front of the windmill in @Image1 . The sky and galaxy are lit up at night. ".to_string(),
+        aspect_ratio: KinoviSeedream5p0ProAspectRatio::Square1x1,
+        resolution: KinoviSeedream5p0ProResolution::OneK,
+        batch_count: KinoviSeedream5p0ProBatchCount::Eight,
+        reference_image_urls: Some(vec![
+          "https://static.seedance2-pro.com/materials/20260713/1783904715554-1a7ce415.jpg".to_string(),
+          "https://static.seedance2-pro.com/materials/20260713/1783904719453-1d10e81f.png".to_string(),
+        ]),
+      }).unwrap();
+      assert_eq!(
+        serde_json::to_string(&params).unwrap(),
+        r#"{"prompt":"The mirror from @Image2 is in front of the windmill in @Image1 . The sky and galaxy are lit up at night. ","aspectRatio":"1:1","resolution":"1k","model":"seedream-5.0-pro","batchCount":8,"uploadedUrls":["https://static.seedance2-pro.com/materials/20260713/1783904715554-1a7ce415.jpg","https://static.seedance2-pro.com/materials/20260713/1783904719453-1d10e81f.png"]}"#,
+      );
+    }
+
+    #[test]
+    fn every_aspect_ratio_wire_value() {
+      let cases = [
+        (KinoviSeedream5p0ProAspectRatio::Auto, "auto"),
+        (KinoviSeedream5p0ProAspectRatio::Square1x1, "1:1"),
+        (KinoviSeedream5p0ProAspectRatio::Standard4x3, "4:3"),
+        (KinoviSeedream5p0ProAspectRatio::Portrait3x4, "3:4"),
+        (KinoviSeedream5p0ProAspectRatio::Landscape16x9, "16:9"),
+        (KinoviSeedream5p0ProAspectRatio::Portrait9x16, "9:16"),
+        (KinoviSeedream5p0ProAspectRatio::Wide3x2, "3:2"),
+        (KinoviSeedream5p0ProAspectRatio::Tall2x3, "2:3"),
+        (KinoviSeedream5p0ProAspectRatio::UltraWide21x9, "21:9"),
+      ];
+      for (variant, expected) in cases {
+        assert_eq!(variant.as_api_str(), expected, "wire value for {variant:?}");
+      }
+    }
+
+    #[test]
+    fn every_resolution_wire_value() {
+      assert_eq!(KinoviSeedream5p0ProResolution::OneK.as_api_str(), "1k");
+      assert_eq!(KinoviSeedream5p0ProResolution::TwoK.as_api_str(), "2k");
+    }
+
+    #[test]
+    fn every_batch_count_value() {
+      let cases = [
+        (KinoviSeedream5p0ProBatchCount::One, 1),
+        (KinoviSeedream5p0ProBatchCount::Two, 2),
+        (KinoviSeedream5p0ProBatchCount::Three, 3),
+        (KinoviSeedream5p0ProBatchCount::Four, 4),
+        (KinoviSeedream5p0ProBatchCount::Five, 5),
+        (KinoviSeedream5p0ProBatchCount::Six, 6),
+        (KinoviSeedream5p0ProBatchCount::Seven, 7),
+        (KinoviSeedream5p0ProBatchCount::Eight, 8),
+      ];
+      for (variant, expected) in cases {
+        assert_eq!(variant.as_u8(), expected, "value for {variant:?}");
+      }
+    }
+
+    #[test]
+    fn batch_count_one_omits_field() {
+      let params = build_api_params(&base_request()).unwrap();
+      assert_eq!(params.batch_count, None);
+    }
+
+    #[test]
+    fn empty_reference_list_omits_uploaded_urls() {
+      let params = build_api_params(&GenerateSeedream5p0ProRequest {
+        reference_image_urls: Some(vec![]),
+        ..base_request()
+      }).unwrap();
+      let json = serde_json::to_string(&params).unwrap();
+      assert!(!json.contains("uploadedUrls"), "expected no uploadedUrls in {json}");
+    }
+
+    #[test]
+    fn business_type() {
+      assert_eq!(BUSINESS_TYPE, "seedream-5-pro-image-generation");
+    }
+  }
+
+  mod reference_image_limit_tests {
+    use super::*;
+
+    #[test]
+    fn fourteen_references_is_allowed() {
+      let params = build_api_params(&request_with_n_references(MAX_REFERENCE_IMAGES)).unwrap();
+      assert_eq!(params.uploaded_urls.map(|urls| urls.len()), Some(MAX_REFERENCE_IMAGES));
+    }
+
+    #[test]
+    fn fifteen_references_is_rejected() {
+      let result = build_api_params(&request_with_n_references(MAX_REFERENCE_IMAGES + 1));
+      match result {
+        Err(Seedance2ProClientError::InvalidRequestField { field, .. }) => {
+          assert_eq!(field, "reference_image_urls");
+        }
+        other => panic!("expected InvalidRequestField, got {other:?}"),
+      }
+    }
+
+    fn request_with_n_references(count: usize) -> GenerateSeedream5p0ProRequest {
+      GenerateSeedream5p0ProRequest {
+        reference_image_urls: Some(
+          (0..count).map(|i| format!("https://example.com/ref{i}.jpg")).collect(),
+        ),
+        ..base_request()
+      }
+    }
+  }
+
+  // ── Pricing ──
+  //
+  // 1k = 14 credits/image, 2k = 24 credits/image; batch count multiplies.
+  // Verified against captured traffic: 2k x 4 images = 96 credits
+  // (4_seedream_5_misc.txt), 1k x 8 images = 112 credits
+  // (5_seedream_5_misc2.txt).
+
+  mod pricing_tests {
+    use super::*;
+
+    #[test]
+    fn one_1k_image_is_fourteen_credits() {
+      let costs = request(KinoviSeedream5p0ProResolution::OneK, KinoviSeedream5p0ProBatchCount::One).calculate_costs();
+      assert_eq!(costs.kinovi_credits, 14);
+    }
+
+    #[test]
+    fn one_2k_image_is_twentyfour_credits() {
+      let costs = request(KinoviSeedream5p0ProResolution::TwoK, KinoviSeedream5p0ProBatchCount::One).calculate_costs();
+      assert_eq!(costs.kinovi_credits, 24);
+    }
+
+    /// Mirrors capture 4_seedream_5_misc.txt: 2k, batch of 4 → 96 credits.
+    #[test]
+    fn four_2k_images_is_ninetysix_credits() {
+      let costs = request(KinoviSeedream5p0ProResolution::TwoK, KinoviSeedream5p0ProBatchCount::Four).calculate_costs();
+      assert_eq!(costs.kinovi_credits, 96);
+    }
+
+    /// Mirrors capture 5_seedream_5_misc2.txt: 1k, batch of 8 → 112 credits.
+    #[test]
+    fn eight_1k_images_is_one_hundred_twelve_credits() {
+      let costs = request(KinoviSeedream5p0ProResolution::OneK, KinoviSeedream5p0ProBatchCount::Eight).calculate_costs();
+      assert_eq!(costs.kinovi_credits, 112);
+    }
+
+    #[test]
+    fn usd_cents_one_1k_image() {
+      // 14 credits; 1400/243 = 5.7613… → up 6¢, down 5¢.
+      let costs = request(KinoviSeedream5p0ProResolution::OneK, KinoviSeedream5p0ProBatchCount::One).calculate_costs();
+      assert_eq!(costs.usd_cents_rounded_up, 6);
+      assert_eq!(costs.usd_cents_rounded_down, 5);
+      assert!((costs.usd_cents_fractional - (1400.0 / 243.0)).abs() < 1e-9);
+    }
+
+    #[test]
+    fn usd_cents_one_2k_image() {
+      // 24 credits; 2400/243 = 9.8765… → up 10¢, down 9¢.
+      let costs = request(KinoviSeedream5p0ProResolution::TwoK, KinoviSeedream5p0ProBatchCount::One).calculate_costs();
+      assert_eq!(costs.usd_cents_rounded_up, 10);
+      assert_eq!(costs.usd_cents_rounded_down, 9);
+      assert!((costs.usd_cents_fractional - (2400.0 / 243.0)).abs() < 1e-9);
+    }
+
+    #[test]
+    fn usd_cents_eight_1k_images() {
+      // 112 credits; 11200/243 = 46.0905… → up 47¢, down 46¢.
+      let costs = request(KinoviSeedream5p0ProResolution::OneK, KinoviSeedream5p0ProBatchCount::Eight).calculate_costs();
+      assert_eq!(costs.usd_cents_rounded_up, 47);
+      assert_eq!(costs.usd_cents_rounded_down, 46);
+      assert!((costs.usd_cents_fractional - (11200.0 / 243.0)).abs() < 1e-9);
+    }
+
+    #[test]
+    fn reference_images_do_not_affect_cost() {
+      let without_refs = request(KinoviSeedream5p0ProResolution::TwoK, KinoviSeedream5p0ProBatchCount::Four).calculate_costs();
+      let with_refs = GenerateSeedream5p0ProRequest {
+        reference_image_urls: Some(vec![
+          "https://example.com/ref1.jpg".to_string(),
+          "https://example.com/ref2.jpg".to_string(),
+        ]),
+        ..request(KinoviSeedream5p0ProResolution::TwoK, KinoviSeedream5p0ProBatchCount::Four)
+      }.calculate_costs();
+      assert_eq!(without_refs, with_refs);
+    }
+
+    #[test]
+    fn aspect_ratio_does_not_affect_cost() {
+      let auto = request(KinoviSeedream5p0ProResolution::OneK, KinoviSeedream5p0ProBatchCount::One).calculate_costs();
+      let ultra_wide = GenerateSeedream5p0ProRequest {
+        aspect_ratio: KinoviSeedream5p0ProAspectRatio::UltraWide21x9,
+        ..request(KinoviSeedream5p0ProResolution::OneK, KinoviSeedream5p0ProBatchCount::One)
+      }.calculate_costs();
+      assert_eq!(auto, ultra_wide);
+    }
+
+    fn request(
+      resolution: KinoviSeedream5p0ProResolution,
+      batch_count: KinoviSeedream5p0ProBatchCount,
+    ) -> GenerateSeedream5p0ProRequest {
+      GenerateSeedream5p0ProRequest {
+        resolution,
+        batch_count,
+        ..base_request()
+      }
+    }
+  }
+
+  // ── Live usage tests ──
+
+  mod live_tests {
+    use super::*;
+    use crate::test_utils::get_test_cookies::get_test_cookies;
+    use crate::test_utils::setup_test_logging::setup_test_logging;
+    use errors::AnyhowResult;
+    use log::LevelFilter;
+
+    #[tokio::test]
+    #[ignore] // Sends a real generation to Kinovi; costs 24 credits.
+    async fn test_text_to_image_2k() -> AnyhowResult<()> {
+      setup_test_logging(LevelFilter::Trace);
+      let session = test_session()?;
+      let result = generate_seedream_5p0_pro(GenerateSeedream5p0ProArgs {
+        session: &session,
+        host_override: None,
+        request: GenerateSeedream5p0ProRequest {
+          prompt: "A corgi wearing a wizard hat, studio lighting".to_string(),
+          aspect_ratio: KinoviSeedream5p0ProAspectRatio::Auto,
+          resolution: KinoviSeedream5p0ProResolution::TwoK,
+          batch_count: KinoviSeedream5p0ProBatchCount::One,
+          reference_image_urls: None,
+        },
+      }).await?;
+      println!("seedream 5.0 pro 2k — task_id={}, order_id={}", result.task_id, result.order_id);
+      assert!(!result.task_id.is_empty());
+      assert!(!result.order_id.is_empty());
+      assert_eq!(1, 2, "Inspect output above");
+      Ok(())
+    }
+
+    #[tokio::test]
+    #[ignore] // Sends a real generation to Kinovi; costs 14 credits.
+    async fn test_text_to_image_1k_with_references() -> AnyhowResult<()> {
+      setup_test_logging(LevelFilter::Trace);
+      let session = test_session()?;
+      let result = generate_seedream_5p0_pro(GenerateSeedream5p0ProArgs {
+        session: &session,
+        host_override: None,
+        request: GenerateSeedream5p0ProRequest {
+          prompt: "The man in @Image1 is staring out the door in @Image2".to_string(),
+          aspect_ratio: KinoviSeedream5p0ProAspectRatio::Portrait9x16,
+          resolution: KinoviSeedream5p0ProResolution::OneK,
+          batch_count: KinoviSeedream5p0ProBatchCount::One,
+          reference_image_urls: Some(vec![
+            "https://static.seedance2-pro.com/materials/20260713/1783904468032-0a803390.jpg".to_string(),
+            "https://static.seedance2-pro.com/materials/20260713/1783904481112-4a3fa0d2.png".to_string(),
+          ]),
+        },
+      }).await?;
+      println!("seedream 5.0 pro 1k refs — task_id={}, order_id={}", result.task_id, result.order_id);
+      assert!(!result.task_id.is_empty());
+      assert_eq!(1, 2, "Inspect output above");
+      Ok(())
+    }
+
+    #[tokio::test]
+    #[ignore] // Sends a real generation to Kinovi; costs 56 credits.
+    async fn test_batch_four_1k() -> AnyhowResult<()> {
+      setup_test_logging(LevelFilter::Trace);
+      let session = test_session()?;
+      let result = generate_seedream_5p0_pro(GenerateSeedream5p0ProArgs {
+        session: &session,
+        host_override: None,
+        request: GenerateSeedream5p0ProRequest {
+          prompt: "A lighthouse on a cliff at golden hour".to_string(),
+          aspect_ratio: KinoviSeedream5p0ProAspectRatio::Landscape16x9,
+          resolution: KinoviSeedream5p0ProResolution::OneK,
+          batch_count: KinoviSeedream5p0ProBatchCount::Four,
+          reference_image_urls: None,
+        },
+      }).await?;
+      println!("seedream 5.0 pro batch-4 — task_id={}, order_id={}", result.task_id, result.order_id);
+      assert_eq!(result.task_ids.as_ref().map(|ids| ids.len()), Some(4));
+      assert_eq!(result.order_ids.as_ref().map(|ids| ids.len()), Some(4));
+      assert_eq!(1, 2, "Inspect output above");
+      Ok(())
+    }
+
+    fn test_session() -> AnyhowResult<Seedance2ProSession> {
+      let cookies = get_test_cookies()?;
+      Ok(Seedance2ProSession::from_cookies_string(cookies))
+    }
+  }
+}

crates/api_clients/seedance2pro_client/src/generate/image/mod.rs

@@ -1,3 +1,4 @@
 pub mod generate_midjourney_v7;
 pub mod generate_midjourney_v7_niji;
 pub mod generate_midjourney_v8;
+pub mod generate_seedream_5p0_pro;

crates/desktop/artcraft/src/core/commands/generate/common/router_image_request_to_artcraft_prompt.rs

@@ -54,6 +54,7 @@ fn image_model_to_common_model_type(model: RouterImageModel) -> Option<CommonMod
     RouterImageModel::Seedream4 => Some(CommonModelType::Seedream4),
     RouterImageModel::Seedream4p5 => Some(CommonModelType::Seedream4p5),
     RouterImageModel::Seedream5Lite => Some(CommonModelType::Seedream5Lite),
+    RouterImageModel::Seedream5p0Pro => Some(CommonModelType::Seedream5p0Pro),
     RouterImageModel::QwenEdit2511Angles => Some(CommonModelType::QwenEdit2511Angles),
     RouterImageModel::Flux2LoraAngles => Some(CommonModelType::Flux2LoraAngles),
     RouterImageModel::GrokImagineImage => Some(CommonModelType::GrokImagineImage),

crates/schema/database/mysql_queries/src/queries/generic_inference/api_providers/seedance2pro/insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token.rs

@@ -82,7 +82,8 @@ pub async fn insert_generic_inference_job_for_seedance2pro_queue_with_apriori_jo
   let is_image_model = match args.maybe_model_type {
     Some(CommonModelType::Midjourney7) |
     Some(CommonModelType::Midjourney7Niji) |
-    Some(CommonModelType::Midjourney8) => true,
+    Some(CommonModelType::Midjourney8) |
+    Some(CommonModelType::Seedream5p0Pro) => true,
     _ => false,
   };
 

crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_model_type.rs

@@ -127,6 +127,8 @@ pub enum InferenceModelType {
   Seedream4p5,
   #[serde(rename = "seedream_5_lite")]
   Seedream5Lite,
+  #[serde(rename = "seedream_5p0_pro")]
+  Seedream5p0Pro,
   #[serde(rename = "midjourney")]
   Midjourney,
   #[serde(rename = "midjourney_v6")]
@@ -334,6 +336,7 @@ impl InferenceModelType {
       Self::Seedream4 => "seedream_4",
       Self::Seedream4p5 => "seedream_4p5",
       Self::Seedream5Lite => "seedream_5_lite",
+      Self::Seedream5p0Pro => "seedream_5p0_pro",
       Self::Midjourney => "midjourney",
       Self::MidjourneyV6 => "midjourney_v6",
       Self::MidjourneyV6p1 => "midjourney_v6p1",
@@ -462,6 +465,7 @@ impl InferenceModelType {
       "seedream_4" => Ok(Self::Seedream4),
       "seedream_4p5" => Ok(Self::Seedream4p5),
       "seedream_5_lite" => Ok(Self::Seedream5Lite),
+      "seedream_5p0_pro" => Ok(Self::Seedream5p0Pro),
       "midjourney" => Ok(Self::Midjourney),
       "midjourney_v6" => Ok(Self::MidjourneyV6),
       "midjourney_v6p1" => Ok(Self::MidjourneyV6p1),
@@ -594,6 +598,7 @@ impl InferenceModelType {
       Self::Seedream4,
       Self::Seedream4p5,
       Self::Seedream5Lite,
+      Self::Seedream5p0Pro,
       Self::Midjourney,
       Self::MidjourneyV6,
       Self::MidjourneyV6p1,
@@ -709,6 +714,7 @@ impl InferenceModelType {
       CommonModelType::Seedream4 => Self::Seedream4,
       CommonModelType::Seedream4p5 => Self::Seedream4p5,
       CommonModelType::Seedream5Lite => Self::Seedream5Lite,
+      CommonModelType::Seedream5p0Pro => Self::Seedream5p0Pro,
       CommonModelType::Midjourney => Self::Midjourney,
       CommonModelType::MidjourneyV6 => Self::MidjourneyV6,
       CommonModelType::MidjourneyV6p1 => Self::MidjourneyV6p1,
@@ -847,6 +853,7 @@ mod tests {
       assert_serialization(InferenceModelType::Seedream4, "seedream_4");
       assert_serialization(InferenceModelType::Seedream4p5, "seedream_4p5");
       assert_serialization(InferenceModelType::Seedream5Lite, "seedream_5_lite");
+      assert_serialization(InferenceModelType::Seedream5p0Pro, "seedream_5p0_pro");
       assert_serialization(InferenceModelType::Midjourney, "midjourney");
       assert_serialization(InferenceModelType::MidjourneyV6, "midjourney_v6");
       assert_serialization(InferenceModelType::MidjourneyV6p1, "midjourney_v6p1");
@@ -972,6 +979,7 @@ mod tests {
       assert_eq!(InferenceModelType::Seedream4.to_str(), "seedream_4");
       assert_eq!(InferenceModelType::Seedream4p5.to_str(), "seedream_4p5");
       assert_eq!(InferenceModelType::Seedream5Lite.to_str(), "seedream_5_lite");
+      assert_eq!(InferenceModelType::Seedream5p0Pro.to_str(), "seedream_5p0_pro");
       assert_eq!(InferenceModelType::Midjourney.to_str(), "midjourney");
       assert_eq!(InferenceModelType::MidjourneyV6.to_str(), "midjourney_v6");
       assert_eq!(InferenceModelType::MidjourneyV6p1.to_str(), "midjourney_v6p1");
@@ -1099,6 +1107,7 @@ mod tests {
       assert_eq!(InferenceModelType::from_str("seedream_4").unwrap(), InferenceModelType::Seedream4);
       assert_eq!(InferenceModelType::from_str("seedream_4p5").unwrap(), InferenceModelType::Seedream4p5);
       assert_eq!(InferenceModelType::from_str("seedream_5_lite").unwrap(), InferenceModelType::Seedream5Lite);
+      assert_eq!(InferenceModelType::from_str("seedream_5p0_pro").unwrap(), InferenceModelType::Seedream5p0Pro);
       assert_eq!(InferenceModelType::from_str("midjourney").unwrap(), InferenceModelType::Midjourney);
       assert_eq!(InferenceModelType::from_str("midjourney_v6").unwrap(), InferenceModelType::MidjourneyV6);
       assert_eq!(InferenceModelType::from_str("midjourney_v6p1").unwrap(), InferenceModelType::MidjourneyV6p1);

crates/schema/public/enums/src/common/generation/common_image_model.rs

@@ -47,6 +47,8 @@ pub enum CommonImageModel {
   Seedream4p5,
   #[serde(rename = "seedream_5_lite")]
   Seedream5Lite,
+  #[serde(rename = "seedream_5p0_pro")]
+  Seedream5p0Pro,
   #[serde(rename = "qwen_edit_2511_angles")]
   QwenEdit2511Angles,
   #[serde(rename = "flux_2_lora_angles")]
@@ -75,6 +77,7 @@ impl CommonImageModel {
       Self::Seedream4 => CommonModelType::Seedream4,
       Self::Seedream4p5 => CommonModelType::Seedream4p5,
       Self::Seedream5Lite => CommonModelType::Seedream5Lite,
+      Self::Seedream5p0Pro => CommonModelType::Seedream5p0Pro,
       Self::QwenEdit2511Angles => CommonModelType::QwenEdit2511Angles,
       Self::Flux2LoraAngles => CommonModelType::Flux2LoraAngles,
     }
@@ -111,6 +114,7 @@ mod tests {
       assert_serialization(CommonImageModel::Seedream4, "seedream_4");
       assert_serialization(CommonImageModel::Seedream4p5, "seedream_4p5");
       assert_serialization(CommonImageModel::Seedream5Lite, "seedream_5_lite");
+      assert_serialization(CommonImageModel::Seedream5p0Pro, "seedream_5p0_pro");
       assert_serialization(CommonImageModel::QwenEdit2511Angles, "qwen_edit_2511_angles");
       assert_serialization(CommonImageModel::Flux2LoraAngles, "flux_2_lora_angles");
     }
@@ -136,6 +140,7 @@ mod tests {
         (CommonImageModel::Seedream4, CommonModelType::Seedream4),
         (CommonImageModel::Seedream4p5, CommonModelType::Seedream4p5),
         (CommonImageModel::Seedream5Lite, CommonModelType::Seedream5Lite),
+        (CommonImageModel::Seedream5p0Pro, CommonModelType::Seedream5p0Pro),
         (CommonImageModel::QwenEdit2511Angles, CommonModelType::QwenEdit2511Angles),
         (CommonImageModel::Flux2LoraAngles, CommonModelType::Flux2LoraAngles),
       ];
@@ -164,7 +169,7 @@ mod tests {
     #[test]
     fn variant_count() {
       use strum::IntoEnumIterator;
-      assert_eq!(CommonImageModel::iter().len(), 20);
+      assert_eq!(CommonImageModel::iter().len(), 21);
     }
 
     #[test]

crates/schema/public/enums/src/common/generation/common_model_type.rs

@@ -82,6 +82,9 @@ pub enum CommonModelType {
   Seedream4p5,
   #[serde(rename = "seedream_5_lite")]
   Seedream5Lite,
+  /// Seedream 5.0 Pro as routed via kinovi
+  #[serde(rename = "seedream_5p0_pro")]
+  Seedream5p0Pro,
 
   /// Midjourney without distinguishing a model type or version
   #[serde(rename = "midjourney")]
@@ -287,6 +290,7 @@ impl CommonModelType {
       Self::Seedream4 => "seedream_4",
       Self::Seedream4p5 => "seedream_4p5",
       Self::Seedream5Lite => "seedream_5_lite",
+      Self::Seedream5p0Pro => "seedream_5p0_pro",
       Self::Midjourney => "midjourney",
       Self::MidjourneyV6 => "midjourney_v6",
       Self::MidjourneyV6p1 => "midjourney_v6p1",
@@ -398,6 +402,7 @@ impl CommonModelType {
       "seedream_4" => Ok(Self::Seedream4),
       "seedream_4p5" => Ok(Self::Seedream4p5),
       "seedream_5_lite" => Ok(Self::Seedream5Lite),
+      "seedream_5p0_pro" => Ok(Self::Seedream5p0Pro),
       "midjourney" => Ok(Self::Midjourney),
       "midjourney_v6" => Ok(Self::MidjourneyV6),
       "midjourney_v6p1" => Ok(Self::MidjourneyV6p1),
@@ -513,6 +518,7 @@ impl CommonModelType {
       Self::Seedream4,
       Self::Seedream4p5,
       Self::Seedream5Lite,
+      Self::Seedream5p0Pro,
       Self::Midjourney,
       Self::MidjourneyV6,
       Self::MidjourneyV6p1,
@@ -625,6 +631,7 @@ impl CommonModelType {
       Self::Seedream4 => CommonModelClass::Image,
       Self::Seedream4p5 => CommonModelClass::Image,
       Self::Seedream5Lite => CommonModelClass::Image,
+      Self::Seedream5p0Pro => CommonModelClass::Image,
       Self::Midjourney => CommonModelClass::Image,
       Self::MidjourneyV6 => CommonModelClass::Image,
       Self::MidjourneyV6p1 => CommonModelClass::Image,
@@ -747,6 +754,7 @@ mod tests {
       assert_serialization(CommonModelType::Seedream4, "seedream_4");
       assert_serialization(CommonModelType::Seedream4p5, "seedream_4p5");
       assert_serialization(CommonModelType::Seedream5Lite, "seedream_5_lite");
+      assert_serialization(CommonModelType::Seedream5p0Pro, "seedream_5p0_pro");
       assert_serialization(CommonModelType::Midjourney, "midjourney");
       assert_serialization(CommonModelType::MidjourneyV6, "midjourney_v6");
       assert_serialization(CommonModelType::MidjourneyV6p1, "midjourney_v6p1");
@@ -852,6 +860,7 @@ mod tests {
       assert_eq!(CommonModelType::Seedream4.to_str(), "seedream_4");
       assert_eq!(CommonModelType::Seedream4p5.to_str(), "seedream_4p5");
       assert_eq!(CommonModelType::Seedream5Lite.to_str(), "seedream_5_lite");
+      assert_eq!(CommonModelType::Seedream5p0Pro.to_str(), "seedream_5p0_pro");
       assert_eq!(CommonModelType::Midjourney.to_str(), "midjourney");
       assert_eq!(CommonModelType::MidjourneyV6.to_str(), "midjourney_v6");
       assert_eq!(CommonModelType::MidjourneyV6p1.to_str(), "midjourney_v6p1");
@@ -961,6 +970,7 @@ mod tests {
       assert_eq!(CommonModelType::from_str("seedream_4").unwrap(), CommonModelType::Seedream4);
       assert_eq!(CommonModelType::from_str("seedream_4p5").unwrap(), CommonModelType::Seedream4p5);
       assert_eq!(CommonModelType::from_str("seedream_5_lite").unwrap(), CommonModelType::Seedream5Lite);
+      assert_eq!(CommonModelType::from_str("seedream_5p0_pro").unwrap(), CommonModelType::Seedream5p0Pro);
       assert_eq!(CommonModelType::from_str("midjourney").unwrap(), CommonModelType::Midjourney);
       assert_eq!(CommonModelType::from_str("midjourney_v6").unwrap(), CommonModelType::MidjourneyV6);
       assert_eq!(CommonModelType::from_str("midjourney_v6p1").unwrap(), CommonModelType::MidjourneyV6p1);
@@ -1042,7 +1052,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = CommonModelType::all_variants();
-      assert_eq!(variants.len(), 96);
+      assert_eq!(variants.len(), 97);
       // Image models
       assert_eq!(variants.pop_first(), Some(CommonModelType::Flux1Dev));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Flux1Schnell));
@@ -1069,6 +1079,7 @@ mod tests {
       assert_eq!(variants.pop_first(), Some(CommonModelType::Seedream4));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Seedream4p5));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Seedream5Lite));
+      assert_eq!(variants.pop_first(), Some(CommonModelType::Seedream5p0Pro));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Midjourney));
       assert_eq!(variants.pop_first(), Some(CommonModelType::MidjourneyV6));
       assert_eq!(variants.pop_first(), Some(CommonModelType::MidjourneyV6p1));

crates/service/web/storyteller_web/src/configs/omni_gen/image_models.rs

@@ -439,6 +439,37 @@ fn build_omni_gen_image_models() -> Vec<OmniGenImageModelDetails> {
     ..Default::default()
   });
 
+  models.push(OmniGenImageModelDetails {
+    model: CommonImageModel::Seedream5p0Pro,
+    model_creator: Some(ModelCreator::Bytedance),
+    full_name: Some("Seedream 5.0 Pro".to_string()),
+    text_prompt_supported: Some(true),
+    image_refs_supported: Some(true),
+    image_refs_max: Some(14),
+    aspect_ratio_options: Some(vec![
+      CommonAspectRatio::Auto,
+      CommonAspectRatio::WideTwentyOneByNine,
+      CommonAspectRatio::WideSixteenByNine,
+      CommonAspectRatio::WideThreeByTwo,
+      CommonAspectRatio::WideFourByThree,
+      CommonAspectRatio::Square,
+      CommonAspectRatio::TallThreeByFour,
+      CommonAspectRatio::TallTwoByThree,
+      CommonAspectRatio::TallNineBySixteen,
+    ]),
+    aspect_ratio_default: Some(CommonAspectRatio::Square),
+    aspect_ratio_default_when_editing: Some(CommonAspectRatio::Auto),
+    resolution_options: Some(vec![
+      CommonResolution::OneK,
+      CommonResolution::TwoK,
+    ]),
+    resolution_default: Some(CommonResolution::TwoK),
+    batch_size_min: Some(1),
+    batch_size_max: Some(8),
+    batch_size_default: Some(1),
+    ..Default::default()
+  });
+
   models
 }
 
@@ -484,6 +515,10 @@ fn build_omni_gen_image_model_providers() -> Vec<OmniGenImageModelProviderDetail
         model: CommonImageModel::Seedream5Lite,
         overrides: None,
       },
+      OmniGenImageProviderModelDetails {
+        model: CommonImageModel::Seedream5p0Pro,
+        overrides: None,
+      },
       OmniGenImageProviderModelDetails {
         model: CommonImageModel::NanoBanana,
         overrides: None,

crates/service/web/storyteller_web/src/http_server/endpoints/generate/cost_estimate/image/estimate_image_cost_handler.rs

@@ -141,6 +141,7 @@ fn map_image_model(model: CommonImageModel) -> Result<RouterImageModel, HandlerE
     CommonImageModel::Seedream4 => RouterImageModel::Seedream4,
     CommonImageModel::Seedream4p5 => RouterImageModel::Seedream4p5,
     CommonImageModel::Seedream5Lite => RouterImageModel::Seedream5Lite,
+    CommonImageModel::Seedream5p0Pro => RouterImageModel::Seedream5p0Pro,
     CommonImageModel::GrokImagineImage => RouterImageModel::GrokImagineImage,
     CommonImageModel::GrokImagineImageQuality => RouterImageModel::GrokImagineImageQuality,
     CommonImageModel::QwenEdit2511Angles => RouterImageModel::QwenEdit2511Angles,

crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/generate/image/pipeline_v2/run_pipeline_v2.rs

@@ -125,7 +125,8 @@ fn provider_for_model(model: RouterImageModel) -> RouterProvider {
   match model {
     RouterImageModel::Midjourney7
     | RouterImageModel::Midjourney7Niji
-    | RouterImageModel::Midjourney8 => RouterProvider::Seedance2Pro,
+    | RouterImageModel::Midjourney8
+    | RouterImageModel::Seedream5p0Pro => RouterProvider::Seedance2Pro,
     _ => RouterProvider::Fal,
   }
 }

crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/image/pipeline_v2/run_pipeline_v2.rs

@@ -118,14 +118,15 @@ fn build_execution_request(
   })
 }
 
-/// Route each image model to the provider that fulfils it. Midjourney is
-/// served via the Seedance2Pro/Kinovi (Volcengine) backend; everything else
-/// flows through Fal.
+/// Route each image model to the provider that fulfils it. Midjourney and
+/// Seedream 5.0 Pro are served via the Seedance2Pro/Kinovi (Volcengine)
+/// backend; everything else flows through Fal.
 fn provider_for_model(model: RouterImageModel) -> RouterProvider {
   match model {
     RouterImageModel::Midjourney7
     | RouterImageModel::Midjourney7Niji
-    | RouterImageModel::Midjourney8 => RouterProvider::Seedance2Pro,
+    | RouterImageModel::Midjourney8
+    | RouterImageModel::Seedream5p0Pro => RouterProvider::Seedance2Pro,
     _ => RouterProvider::Fal,
   }
 }

frontend/apps/artcraft-dashboard/src/api/UsersApi.ts

@@ -169,60 +169,6 @@ export class UsersApi extends ApiManager {
       }));
   }
 
-  public async RequestPasswordReset({
-    email,
-  }: {
-    email: string;
-  }): Promise<ApiResponse<null>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/request_password_reset`;
-    return await this.post<
-      { email: string },
-      { success: boolean; error_message?: string }
-    >({
-      endpoint,
-      body: { email },
-    })
-      .then((response) => ({
-        success: response.success,
-        errorMessage: response.error_message,
-      }))
-      .catch((err) => ({
-        success: false,
-        errorMessage: err.message,
-      }));
-  }
-
-  public async ResetPassword({
-    token,
-    password,
-    passwordConfirmation,
-  }: {
-    token: string;
-    password: string;
-    passwordConfirmation: string;
-  }): Promise<ApiResponse<null>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/reset_password`;
-    return await this.post<
-      { token: string; password: string; password_confirmation: string },
-      { success: boolean; error_message?: string }
-    >({
-      endpoint,
-      body: {
-        token,
-        password,
-        password_confirmation: passwordConfirmation,
-      },
-    })
-      .then((response) => ({
-        success: response.success,
-        errorMessage: response.error_message,
-      }))
-      .catch((err) => ({
-        success: false,
-        errorMessage: err.message,
-      }));
-  }
-
   public async ChangePassword({
     password,
     passwordConfirmation,

frontend/apps/artcraft-webapp/src/components/sidebar/library-folders-nav.tsx

@@ -4,6 +4,7 @@ import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
 import {
   faBorderAll,
   faFolder,
+  faFolderOpen,
   faPlus,
   faStar,
 } from "@fortawesome/pro-solid-svg-icons";
@@ -34,10 +35,12 @@ export function LibraryFoldersNav({
   const onFolders =
     pathname === "/library/folders" ||
     pathname.startsWith("/library/folder_");
+  const onFolderless = pathname === "/library/folderless";
   const onUnsorted =
     !onFolders &&
+    !onFolderless &&
     (pathname === "/library" || pathname.startsWith("/library/"));
-  const inLibraryArea = onUnsorted || onFolders;
+  const inLibraryArea = onUnsorted || onFolders || onFolderless;
 
   const folders = useLibraryFoldersStore((s) => s.folders);
   const activeFolderId = useLibraryFoldersStore((s) => s.activeFolderId);
@@ -104,6 +107,18 @@ export function LibraryFoldersNav({
               </Link>
             </SidebarMenuButton>
           </SidebarMenuItem>
+          <SidebarMenuItem>
+            <SidebarMenuButton
+              asChild
+              isActive={onFolderless}
+              tooltip="Unfoldered"
+            >
+              <Link to="/library/folderless" onClick={onNavClick}>
+                <FontAwesomeIcon icon={faFolderOpen} />
+                <span>Unfoldered</span>
+              </Link>
+            </SidebarMenuButton>
+          </SidebarMenuItem>
 
           {inLibraryArea &&
             rootFolders.map((folder) => (

frontend/apps/artcraft-webapp/src/components/topbar/breadcrumbs.tsx

@@ -38,9 +38,16 @@ function resolveCrumbs(pathname: string): Crumb[] {
     const onFolders =
       pathname === "/library/folders" ||
       pathname.startsWith("/library/folder_");
+    const onFolderless = pathname === "/library/folderless";
     return [
       { label: "Library", href: "/library" },
-      { label: onFolders ? "Folders" : "All Assets" },
+      {
+        label: onFolders
+          ? "Folders"
+          : onFolderless
+            ? "Unfoldered"
+            : "All Assets",
+      },
     ];
   }
   if (ROUTE_CRUMBS[pathname]) return ROUTE_CRUMBS[pathname];

frontend/apps/artcraft-webapp/src/main.tsx

@@ -24,7 +24,7 @@ if (import.meta.env.DEV) {
     // (disabled — it overrides the origin above and points at localhost:12345,
     // which breaks dev unless a local backend is running. Re-enable only when
     // testing against a local storyteller-web.)
-    // StorytellerApiHostStore.getInstance().setDevelopment();
+    StorytellerApiHostStore.getInstance().setDevelopment();
   } catch (e) {
     console.warn("Failed to set dev API host override", e);
   }

frontend/apps/artcraft-webapp/src/pages/library/library-folders-store.ts

@@ -166,7 +166,9 @@ export function mapRawToGalleryItem(item: any): GalleryItem {
     fullImage: item.media_links?.cdn_url ?? null,
     createdAt: item.created_at,
     mediaClass: item.media_class || "image",
-    isUpload: item.origin_category === "upload",
+    // The user-media list carries `origin_category`; the folderless list
+    // carries `is_user_upload` instead.
+    isUpload: item.origin_category === "upload" || item.is_user_upload === true,
     batchImageToken: item.maybe_batch_token,
   };
 }

frontend/apps/artcraft-webapp/src/pages/library/library.tsx

@@ -9,6 +9,7 @@ import {
   UsersApi,
   GalleryModalApi,
   MediaFilesApi,
+  FoldersApi,
   FilterMediaClasses,
   FilterMediaType,
 } from "@storyteller/api";
@@ -68,6 +69,17 @@ const FILTERS = [
   { id: "splats", label: "Splats", icon: faGlobe, route: "/library/splats" },
 ];
 
+// Class scopes for the Unfoldered tab. Local state (not routes): the tab is
+// one page and the filter maps to the endpoint's `filter_media_class` param.
+const FOLDERLESS_CLASS_FILTERS = [
+  { id: "all", label: "All", icon: faBorderAll },
+  { id: "image", label: "Images", icon: faImage },
+  { id: "video", label: "Videos", icon: faVideo },
+  { id: "audio", label: "Audio", icon: faMusic },
+  { id: "mesh", label: "Meshes", icon: faCube },
+  { id: "splat", label: "Splats", icon: faGlobe },
+];
+
 const ROUTE_TO_FILTER: Record<string, string> = {
   images: "image",
   videos: "video",
@@ -150,9 +162,15 @@ export default function Library() {
   const activeFilter = filterParam
     ? (ROUTE_TO_FILTER[filterParam] ?? "all")
     : "all";
-  // Top-level tab derived from the route: All Assets (flat library) vs Folders.
+  // Top-level tab derived from the route: All Assets (flat library),
+  // Folders, or Unfoldered (files in no folder at all).
   const onFoldersRoute = pathname === "/library/folders" || !!folderToken;
-  const tab: "unsorted" | "folders" = onFoldersRoute ? "folders" : "unsorted";
+  const onFolderlessRoute = slug === "folderless";
+  const tab: "unsorted" | "folders" | "folderless" = onFoldersRoute
+    ? "folders"
+    : onFolderlessRoute
+      ? "folderless"
+      : "unsorted";
 
   const [username, setUsername] = useState<string | null>(null);
   const [isLoggedIn, setIsLoggedIn] = useState<boolean | null>(null);
@@ -176,10 +194,20 @@ export default function Library() {
 
   const api = useMemo(() => new GalleryModalApi(), []);
   const mediaFilesApi = useMemo(() => new MediaFilesApi(), []);
+  const foldersApi = useMemo(() => new FoldersApi(), []);
   // Keyset cursor for the Meshes / Splats tabs (their endpoints paginate by
   // cursor, not page index).
   const meshSplatCursorRef = useRef<string | undefined>(undefined);
 
+  // ── Unfoldered tab ──
+  // Optional media-class scope for the folderless list ("all" = unfiltered).
+  const [folderlessClass, setFolderlessClass] = useState<string>("all");
+  // Keyset cursor for the folderless endpoint.
+  const folderlessCursorRef = useRef<string | undefined>(undefined);
+  // Current tab, readable from stable callbacks without re-binding them.
+  const tabRef = useRef(tab);
+  tabRef.current = tab;
+
   // ── Folder store ──────────────────────────────────────────────────────────
   const folders = useLibraryFoldersStore((s) => s.folders);
   const activeFolderId = useLibraryFoldersStore((s) => s.activeFolderId);
@@ -286,6 +314,31 @@ export default function Library() {
       isLoadingRef.current = true;
       setLoading(true);
       try {
+        if (tabRef.current === "folderless") {
+          // The Unfoldered tab lists files in no folder at all via the
+          // dedicated endpoint (server-scoped, cursor-paginated). The server
+          // only returns a cursor when the page was full, so its presence
+          // doubles as the has-more signal.
+          const cursor = reset ? undefined : folderlessCursorRef.current;
+          const response = await foldersApi.ListMediaFilesWithoutFolder({
+            cursor,
+            limit: PAGE_SIZE,
+            filterMediaClass:
+              folderlessClass === "all" ? undefined : folderlessClass,
+          });
+          if (response.success && response.data) {
+            const newItems = response.data.map(mapRawToGalleryItem);
+            setAllItems((prev) => (reset ? newItems : [...prev, ...newItems]));
+            const nextCursor = response.pagination?.maybe_cursor ?? undefined;
+            folderlessCursorRef.current = nextCursor;
+            setHasMore(!!nextCursor);
+          }
+          setLoading(false);
+          setInitialLoading(false);
+          isLoadingRef.current = false;
+          return;
+        }
+
         if (activeFilter === "meshes" || activeFilter === "splats") {
           // The Meshes / Splats tabs use the session by-class list endpoints
           // (server-scoped, cursor-paginated) instead of the user list.
@@ -345,20 +398,22 @@ export default function Library() {
       setInitialLoading(false);
       isLoadingRef.current = false;
     },
-    [username, activeFilter, pageIndex, api, mediaFilesApi],
+    [username, activeFilter, pageIndex, api, mediaFilesApi, foldersApi, folderlessClass],
   );
 
-  // Initial load + filter change
+  // Initial load + filter / tab change
   useEffect(() => {
     if (!username) return;
+    if (tab === "folders") return; // Folder views load via the folders store.
     setAllItems([]);
     setPageIndex(0);
     meshSplatCursorRef.current = undefined;
+    folderlessCursorRef.current = undefined;
     setHasMore(true);
     setInitialLoading(true);
     isLoadingRef.current = false;
     loadItems(true);
-  }, [username, activeFilter]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [username, activeFilter, tab, folderlessClass]); // eslint-disable-line react-hooks/exhaustive-deps
 
   // Infinite scroll — listens on the real scroll container. Paginates the open
   // folder's media when inside a folder, otherwise the root library list.
@@ -374,7 +429,11 @@ export default function Library() {
       if (scrollBottom >= 500) return;
       if (activeFolderId) {
         loadFolderMedia(activeFolderId, false);
-      } else if (tab === "unsorted" && hasMore && !isLoadingRef.current) {
+      } else if (
+        (tab === "unsorted" || tab === "folderless") &&
+        hasMore &&
+        !isLoadingRef.current
+      ) {
         loadItems();
       }
     };
@@ -396,16 +455,30 @@ export default function Library() {
       if (itemIds.length === 0) return;
       const source = useLibraryFoldersStore.getState().activeFolderId;
       const known = displayItemsRef.current;
+      // On the Unfoldered tab, items that just landed in a folder no longer
+      // belong in the list — drop them (and their selection) once the add
+      // settles.
+      const pruneIfFolderless = () => {
+        if (tabRef.current !== "folderless") return;
+        const removed = new Set(itemIds);
+        setAllItems((prev) => prev.filter((it) => !removed.has(it.id)));
+        useLibrarySelectionStore.getState().removeIds(itemIds);
+      };
       if (source && source !== targetFolderId) {
         promptFolderDrop({
           count: itemIds.length,
           targetFolderName: folders.find((f) => f.id === targetFolderId)?.name,
           onMove: () =>
             moveMediaToFolder(itemIds, source, targetFolderId, known),
-          onAdd: () => addMediaToFolder(itemIds, targetFolderId, known),
+          onAdd: () =>
+            addMediaToFolder(itemIds, targetFolderId, known).then(
+              pruneIfFolderless,
+            ),
         });
       } else {
-        addMediaToFolder(itemIds, targetFolderId, known);
+        void addMediaToFolder(itemIds, targetFolderId, known).then(
+          pruneIfFolderless,
+        );
       }
     },
     [folders, addMediaToFolder, moveMediaToFolder],
@@ -745,6 +818,7 @@ export default function Library() {
     setAllItems([]);
     setPageIndex(0);
     meshSplatCursorRef.current = undefined;
+    folderlessCursorRef.current = undefined;
     setHasMore(true);
     setInitialLoading(true);
     isLoadingRef.current = false;
@@ -953,8 +1027,29 @@ export default function Library() {
                     />
                     <span className="relative z-10">Folders</span>
                   </Link>
+                  <Link
+                    to="/library/folderless"
+                    className={`relative flex items-center gap-2 px-3 sm:px-4 py-1 sm:py-1.5 rounded-md text-xs sm:text-sm font-medium transition-colors whitespace-nowrap ${
+                      tab === "folderless"
+                        ? "text-white"
+                        : "text-white/60 hover:text-white"
+                    }`}
+                  >
+                    {tab === "folderless" && (
+                      <motion.span
+                        layoutId="library-tab-indicator"
+                        className="absolute inset-0 rounded-md bg-ui-controls"
+                        transition={{ duration: 0.32, ease: EASE_EMPHASIS }}
+                      />
+                    )}
+                    <FontAwesomeIcon
+                      icon={faFolderOpen}
+                      className="relative z-10 text-xs"
+                    />
+                    <span className="relative z-10">Unfoldered</span>
+                  </Link>
                 </div>
-                {tab === "unsorted" && (
+                {(tab === "unsorted" || tab === "folderless") && (
                   <button
                     onClick={refreshRoot}
                     className="h-8 w-8 flex items-center justify-center rounded-lg text-white/50 hover:text-white hover:bg-ui-controls/40 transition-colors"
@@ -969,6 +1064,36 @@ export default function Library() {
               </div>
 
               <div className="flex items-center gap-2">
+                {tab === "folderless" && (
+                  <div className="flex items-center gap-1 bg-ui-controls/40 rounded-xl p-1 overflow-x-auto">
+                    {FOLDERLESS_CLASS_FILTERS.map((filter) => (
+                      <button
+                        key={filter.id}
+                        onClick={() => setFolderlessClass(filter.id)}
+                        className={`relative flex items-center gap-1.5 sm:gap-2 px-2.5 sm:px-4 py-1 sm:py-1.5 rounded-md text-xs sm:text-sm font-medium transition-colors whitespace-nowrap ${
+                          folderlessClass === filter.id
+                            ? "text-white"
+                            : "text-white/60 hover:text-white"
+                        }`}
+                      >
+                        {folderlessClass === filter.id && (
+                          <motion.span
+                            layoutId="library-folderless-filter-indicator"
+                            className="absolute inset-0 rounded-md bg-ui-controls"
+                            transition={{ duration: 0.32, ease: EASE_EMPHASIS }}
+                          />
+                        )}
+                        <FontAwesomeIcon
+                          icon={filter.icon}
+                          className="relative z-10 text-xs"
+                        />
+                        <span className="relative z-10 hidden sm:inline">
+                          {filter.label}
+                        </span>
+                      </button>
+                    ))}
+                  </div>
+                )}
                 {tab === "unsorted" && (
                   <div className="flex items-center gap-1 bg-ui-controls/40 rounded-xl p-1 overflow-x-auto">
                     {FILTERS.map((filter) => (
@@ -1177,7 +1302,13 @@ export default function Library() {
             </div>
           ) : rootEmpty ? (
             <div className="flex flex-col items-center justify-center py-20">
-              <p className="text-white/40 text-sm mb-4">No items yet.</p>
+              <p className="text-white/40 text-sm mb-4">
+                {tab === "folderless"
+                  ? folderlessClass === "all"
+                    ? "Everything is in a folder — nothing to organize."
+                    : "No unfoldered files of this type."
+                  : "No items yet."}
+              </p>
               <div className="flex gap-3">
                 <Link to="/create-image">
                   <Button
@@ -1454,6 +1585,13 @@ function BulkSelectionBar({
   const folderMediaItems = useLibraryFoldersStore((s) => s.folderMediaItems);
   const [popoverOpen, setPopoverOpen] = useState(false);
 
+  // Same ordering as the sidebar / folder cards: starred first, then
+  // alphabetical (the store list arrives in API order).
+  const sortedFolders = useMemo(
+    () => [...folders].sort(compareFolders),
+    [folders],
+  );
+
   // Close the popover when navigating so it doesn't dangle over the new view.
   useEffect(() => {
     setPopoverOpen(false);
@@ -1522,12 +1660,12 @@ function BulkSelectionBar({
               <div className="px-2 py-1 text-[11px] font-semibold uppercase tracking-wider text-white/40">
                 Folders
               </div>
-              {folders.length === 0 ? (
+              {sortedFolders.length === 0 ? (
                 <div className="px-2 py-1.5 text-xs italic text-white/30">
                   No folders yet
                 </div>
               ) : (
-                folders.map((folder) => (
+                sortedFolders.map((folder) => (
                   <button
                     key={folder.id}
                     type="button"

frontend/apps/artcraft/app/src/Classes/ApiManager/AnalyticsApi.ts

@@ -1,38 +0,0 @@
-import { ApiManager, ApiResponse } from "./ApiManager";
-
-export class AnalyticsApi extends ApiManager {
-  public PostAnalytics({
-    maybeLastAction,
-    maybeLogToken,
-  }: {
-    maybeLastAction: string;
-    maybeLogToken: string;
-  }): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/analytics/log_session`;
-
-    const body = {
-      maybe_last_action: maybeLastAction,
-      maybe_log_token: maybeLogToken,
-    };
-
-    return this.post<
-      {
-        maybe_last_action: string;
-        maybe_log_token: string;
-      },
-      {
-        success?: boolean;
-        log_token?: string;
-        BadInput?: string;
-      }
-    >({ endpoint, body })
-      .then((response) => ({
-        success: response.success ?? false,
-        data: response.log_token,
-        errorMessage: response.BadInput,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-}

frontend/apps/artcraft/app/src/Classes/ApiManager/EngineApi.ts

@@ -86,128 +86,4 @@ export class EngineApi extends ApiManager {
     return result;
   }
 
-  public async enqueueImageGeneration({
-    disableSystemPrompt,
-    prompt,
-    snapshotMediaToken,
-    additionalImages,
-  }: {
-    disableSystemPrompt: boolean;
-    prompt: string;
-    snapshotMediaToken: string;
-    additionalImages?: string[];
-  }): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/image_studio/prompt`;
-    
-    const uuidIdempotencyToken = crypto.randomUUID(); // Generate a new UUID
-    const body = {
-      uuid_idempotency_token: uuidIdempotencyToken,
-      disable_system_prompt: disableSystemPrompt,
-      prompt,
-      snapshot_media_token: snapshotMediaToken, // Changed from scene_media_token to snapshot_media_token
-      additional_images: additionalImages,
-    };
-
-    const postResponse = await this.post<
-      {
-        uuid_idempotency_token: string;
-        disable_system_prompt: boolean;
-        prompt: string;
-        snapshot_media_token: string;
-        additional_images?: string[];
-      },
-      { success?: boolean; job_token?: string; error_reason?: string, failure_reason?: string}
-    >({
-      endpoint,
-      body,
-    });
-    console.log("postResponse", postResponse);
-    // Check if the response is successful
-    const isSuccess = postResponse.success ?? false;
-
-    // Prepare the result object
-    const result = {
-      success: isSuccess,
-      data: isSuccess ? postResponse.job_token : undefined,
-      errorMessage: isSuccess ? undefined : (postResponse.error_reason || postResponse.failure_reason),
-    };
-
-    return result;
-  }
-
-  public async pollJobSession(jobToken: string): Promise<
-    ApiResponse<{
-      status: string;
-      result: {
-        generated_images?: string[];
-        error?: string;
-      };
-    }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/jobs/session/${jobToken}`;
-
-    const response = await this.get<{
-      success?: boolean;
-      status?: string;
-      result?: {
-        generated_images?: string[];
-        error?: string;
-      };
-      BadInput?: string;
-    }>({
-      endpoint,
-    });
-
-    const success = response.success ?? false;
-    const status = response.status ?? "";
-    const result = response.result ?? {
-      generated_images: [],
-      error: undefined,
-    };
-    const errorMessage = response.BadInput;
-
-    return {
-      success,
-      data: { status, result },
-      errorMessage,
-    };
-  }
-
-  public async pollStudioSessionJobs(jobToken: string): Promise<
-    ApiResponse<{
-      status: string;
-      result: {
-        generated_images?: string[];
-        error?: string;
-      };
-    }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/image_studio/session_jobs/${jobToken}`;
-
-    const response = await this.get<{
-      success?: boolean;
-      status?: string;
-      result?: {
-        generated_images?: string[];
-        error?: string;
-      };
-      BadInput?: string;
-    }>({
-      endpoint,
-    });
-
-    const success = response.success ?? false;
-    const status = response.status ?? "";
-    const result = response.result ?? {
-      generated_images: [],
-      error: undefined,
-    };
-    const errorMessage = response.BadInput;
-
-    return {
-      success,
-      data: { status, result },
-      errorMessage,
-    };
-  }
 }

frontend/apps/artcraft/app/src/Classes/ApiManager/UserBookmarksApi.ts

@@ -1,53 +1,5 @@
 import { ApiManager, ApiResponse } from "./ApiManager";
-import type {
-  Pagination,
-  UserBookmarkBatch,
-  UserBookmarkByEntity,
-  UserBookmarkByUser,
-} from "@storyteller/ui-pagescene";
-import { authentication } from "~/signals";
-
-export enum ScopedEntityTypes {
-  USER = "user",
-  TTS_MODEL = "tts-model",
-  TTS_RESULT = "tts-result",
-  W2L_TEMPLATE = "w2l-template",
-  W2L_RESULT = "w2l-result",
-  MEDIA_FILE = "media_file",
-  MODEL_WEIGHT = "model_weight",
-  VOICE_CONVERSION_MODEL = "voice_conversion_model",
-  ZS_VOICE = "z_voice",
-}
-
-export enum ScopedWeightTypes {
-  HIFIGAN_TTl2 = "hifigan_tt2",
-  RVC_V2 = "rvc_v2",
-  SD_1_5 = "sd_1.5",
-  SDXL = "sdxl",
-  SO_VITS_SVC = "so_vits_svc",
-  TT2 = "tt2",
-  LORA = "loRA",
-  VALL_E = "vall_e",
-  COMFY_UI = "comfy_ui",
-}
-
-export enum ScopedMediaFileType {
-  IMAGE_GENERATION = "image_generation",
-  TEXT_TO_SPEECH = "text_to_speech",
-  VOCODER = "vocoder",
-  VOICE_CONVERSION = "voice_conversion",
-  WORKFLOW_CONFIG = "workflow_config",
-}
-
-interface ListUserBookmarksByUserRequest {
-  username?: string;
-  sort_ascending?: boolean;
-  page_size?: number;
-  page_index?: number;
-  maybe_scoped_entity_type?: ScopedEntityTypes[];
-  maybe_scoped_weight_type?: ScopedWeightTypes[];
-  maybe_scoped_media_file_type?: ScopedMediaFileType[];
-}
+import type { UserBookmarkBatch } from "@storyteller/ui-pagescene";
 
 export class UserBookmarksApi extends ApiManager {
   public CreateUserBookmark({
@@ -134,69 +86,4 @@ export class UserBookmarksApi extends ApiManager {
       });
   }
 
-  public ListUserBookmarksByUser({
-    username,
-    sort_ascending,
-    page_size,
-    page_index,
-    maybe_scoped_entity_type,
-    maybe_scoped_weight_type,
-    maybe_scoped_media_file_type,
-  }: ListUserBookmarksByUserRequest): Promise<
-    ApiResponse<UserBookmarkByUser[], Pagination>
-  > {
-    const user = username ?? authentication.userInfo.value?.username;
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/user_bookmarks/list/${user}`;
-
-    const query = {
-      sort_ascending,
-      page_size,
-      page_index,
-      maybe_scoped_entity_type: maybe_scoped_entity_type
-        ? maybe_scoped_entity_type.join(",")
-        : undefined,
-      maybe_scoped_weight_type: maybe_scoped_weight_type
-        ? maybe_scoped_weight_type.join(",")
-        : undefined,
-      maybe_scoped_media_file_type: maybe_scoped_media_file_type
-        ? maybe_scoped_media_file_type.join(",")
-        : undefined,
-    };
-
-    return this.get<{
-      success?: boolean;
-      pagination?: Pagination;
-      results: UserBookmarkByUser[];
-    }>({ endpoint, query })
-      .then((response) => ({
-        success: response.success ?? false,
-        data: response.results,
-        pagination: response.pagination,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-
-  public ListUserBookmarksByEntity({
-    entityType,
-    entityToken,
-  }: {
-    entityType: string;
-    entityToken: string;
-  }): Promise<ApiResponse<UserBookmarkByEntity[]>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/user_bookmarks/list/${entityType}/${entityToken}`;
-
-    return this.get<{
-      success: boolean;
-      user_bookmarks: UserBookmarkByEntity[];
-    }>({ endpoint })
-      .then((response) => ({
-        success: true,
-        data: response.user_bookmarks,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
 }

frontend/apps/artcraft/app/src/Classes/ApiManager/VoiceConversionApi.ts

@@ -1,53 +0,0 @@
-import { ApiManager, ApiResponse } from "./ApiManager";
-
-interface VoiceConversionParams {
-  autoPredictF0?: boolean;
-  creatorSetVisibility?: string;
-  isStorytellerDemo?: boolean;
-  overrideF0Method?: string;
-  sourceMediaUploadToken: string;
-  transpose?: number;
-  uuidIdempotencyToken: string;
-  voiceConversionModelToken: string;
-}
-
-interface VoiceConversionRequest {
-  auto_predict_f0: boolean;
-  creator_set_visibility: string;
-  is_storyteller_demo: boolean;
-  override_f0_method: string;
-  source_media_upload_token: string;
-  transpose: number;
-  uuid_idempotency_token: string;
-  voice_conversion_model_token: string;
-}
-
-export class VoiceConversionApi extends ApiManager {
-  public ConvertVoice(
-    params: VoiceConversionParams,
-  ): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/voice_conversion/inference`;
-
-    const body = this.parseBodyValues<
-      VoiceConversionParams,
-      VoiceConversionRequest
-    >(params);
-
-    return this.post<
-      VoiceConversionRequest,
-      {
-        success?: boolean;
-        inference_job_token?: string;
-        BadInput?: string;
-      }
-    >({ endpoint, body })
-      .then((response) => ({
-        success: response.success ?? false,
-        data: response.inference_job_token,
-        errorMessage: response.BadInput,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-}

frontend/apps/artcraft/app/src/Classes/ApiManager/VoiceDesignerApi.ts

@@ -1,78 +0,0 @@
-import { ApiManager, ApiResponse } from "./ApiManager";
-import type { Pagination } from "@storyteller/ui-pagescene";
-import { authentication } from "~/signals";
-import { ZsDataset } from "~/models/Dataset";
-
-interface VoiceDesignerParams {
-  text: string;
-  uuidIdempotencyToken: string;
-  voiceToken: string;
-}
-
-interface VoiceDesignerRequest {
-  text: string;
-  uuid_idempotency_token: string;
-  voice_token: string;
-}
-
-export class VoiceDesignerApi extends ApiManager {
-  public EnqueueTts(
-    params: VoiceDesignerParams,
-  ): Promise<
-    ApiResponse<{ inference_job_token?: string; voice_token?: string }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/voice_designer/enqueue_tts`;
-
-    const body = this.parseBodyValues<
-      VoiceDesignerParams,
-      VoiceDesignerRequest
-    >(params);
-
-    return this.post<
-      VoiceDesignerRequest,
-      {
-        success?: boolean;
-        inference_job_token?: string;
-        voice_token: string;
-        BadInput?: string;
-      }
-    >({ endpoint, body })
-      .then((response) => ({
-        success: response.success ?? false,
-        ...(response.success
-          ? {
-              data: {
-                inference_job_token: response.inference_job_token,
-                voice_token: response.voice_token,
-              },
-            }
-          : {}),
-        errorMessage: response.BadInput,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-
-  public ListDatasetsByUser({
-    username,
-  }: {
-    username?: string;
-  }): Promise<ApiResponse<ZsDataset[]>> {
-    const user = username ?? authentication.userInfo.value?.username;
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/voice_designer/user/${user}/list`;
-
-    return this.get<{
-      success: boolean;
-      datasets: ZsDataset[];
-      pagination: Pagination;
-    }>({ endpoint })
-      .then((response) => ({
-        success: true,
-        data: response.datasets,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-}

frontend/apps/artcraft/app/src/Classes/ApiManager/WeightsApi.ts

@@ -275,7 +275,7 @@ export class WeightsApi extends ApiManager {
     weightToken: string;
     coverImageMediaFileToken: string;
   }): Promise<ApiResponse<undefined>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/weights/${weightToken}/cover_image`;
+    const endpoint = `${this.getApiSchemeAndHost()}/v1/weights/weight/${weightToken}/cover_image`;
 
     const body = {
       cover_image_media_file_token: coverImageMediaFileToken,

frontend/apps/artcraft/app/src/Classes/ApiManager/index.ts

@@ -1,5 +1,4 @@
 // https://storyteller-docs.netlify.app/#/
-export * from "./AnalyticsApi";
 export * from "./BetaKeysApi";
 export * from "./BillingApi";
 export * from "./CommentsApi";

frontend/apps/artcraft/test/app/Classes/ApiManager/AnalyticsApi.test.ts

@@ -1,39 +0,0 @@
-import { authentication } from "~/signals";
-import { UserInfo } from "~/models";
-import EnvironmentVariables from "~/Classes/EnvironmentVariables";
-import { AnalyticsApi } from "~/Classes/ApiManager/AnalyticsApi";
-import testUpdateDeleteEndpoints from "./utils/testUpdateDeleteEndpoints";
-
-EnvironmentVariables.initialize({ BASE_API: "http://localhost:3000" });
-
-describe("AnalyticsApi", () => {
-  beforeAll(() => {
-    authentication.userInfo.value = {
-      user_token: "un1",
-      username: "un1",
-    } as UserInfo;
-  });
-  describe("run tests", () => {
-    const api = new AnalyticsApi();
-    [
-      {
-        name: "PostAnalytics",
-        function: api.PostAnalytics.bind(api),
-        endpoint: "http://localhost:3000/v1/analytics/log_session",
-        method: "POST",
-        paramsIn: {
-          maybeLastAction: "mla1",
-          maybeLogToken: "mlt1",
-        },
-        paramsTest: {
-          maybe_last_action: "mla1",
-          maybe_log_token: "mlt1",
-        },
-        response: { success: true, log_token: "lt1" },
-        data: "lt1",
-      },
-    ].forEach((testMethod) => {
-      testUpdateDeleteEndpoints(api, testMethod);
-    });
-  });
-});

frontend/apps/artcraft/test/app/Classes/ApiManager/UserBookmarksApi.test.ts

@@ -1,58 +1,7 @@
 import { authentication } from "~/signals";
 import { UserInfo } from "~/models";
 import EnvironmentVariables from "~/Classes/EnvironmentVariables";
-import {
-  ScopedEntityTypes,
-  ScopedMediaFileType,
-  ScopedWeightTypes,
-  UserBookmarksApi,
-} from "~/Classes/ApiManager/UserBookmarksApi";
-
-const mockBookmark = {
-  created_at: "2024-06-15T11:15:26.997Z",
-  details: {
-    entity_token: "string",
-    entity_type: "user",
-    maybe_media_file_data: {
-      maybe_creator: {
-        default_avatar: {
-          color_index: 0,
-          image_index: 0,
-        },
-        display_name: "string",
-        gravatar_hash: "string",
-        user_token: "string",
-        username: "string",
-      },
-      media_type: "audio",
-      public_bucket_path: "string",
-    },
-    maybe_summary_text: "string",
-    maybe_thumbnail_url: "string",
-    maybe_weight_data: {
-      maybe_cover_image_public_bucket_path: "string",
-      maybe_creator: {
-        default_avatar: {
-          color_index: 0,
-          image_index: 0,
-        },
-        display_name: "string",
-        gravatar_hash: "string",
-        user_token: "string",
-        username: "string",
-      },
-      title: "string",
-      weight_category: "image_generation",
-      weight_type: "hifigan_tt2",
-    },
-    stats: {
-      bookmark_count: 0,
-      positive_rating_count: 0,
-    },
-  },
-  token: "string",
-  updated_at: "2024-06-15T11:15:26.997Z",
-};
+import { UserBookmarksApi } from "~/Classes/ApiManager/UserBookmarksApi";
 
 describe("UserBookmarksApi", () => {
   beforeAll(() => {
@@ -286,192 +235,4 @@ describe("UserBookmarksApi", () => {
     });
   });
 
-  describe("ListUserBookmarksByUser", () => {
-    it("no params", async () => {
-      const api = new UserBookmarksApi();
-      jest.spyOn(api, "fetch").mockResolvedValue({
-        pagination: {
-          current: 0,
-          total_page_count: 0,
-        },
-        results: [mockBookmark],
-        success: true,
-      });
-      const response = await api.ListUserBookmarksByUser({});
-      expect(api.fetch).toHaveBeenCalledWith(
-        "http://localhost:3000/v1/user_bookmarks/list/un1",
-        {
-          method: "GET",
-          query: {
-            maybe_scoped_entity_type: undefined,
-            maybe_scoped_media_file_type: undefined,
-            maybe_scoped_weight_type: undefined,
-            page_index: undefined,
-            page_size: undefined,
-            sort_ascending: undefined,
-          },
-        },
-      );
-      expect(response).toEqual({
-        success: true,
-        data: [mockBookmark],
-        pagination: {
-          current: 0,
-          total_page_count: 0,
-        },
-      });
-    });
-
-    it("all params", async () => {
-      const api = new UserBookmarksApi();
-      jest.spyOn(api, "fetch").mockResolvedValue({
-        pagination: {
-          current: 0,
-          total_page_count: 0,
-        },
-        results: [mockBookmark],
-        success: true,
-      });
-      const response = await api.ListUserBookmarksByUser({
-        username: "user1",
-        sort_ascending: true,
-        page_size: 76,
-        page_index: 2,
-        maybe_scoped_entity_type: [ScopedEntityTypes.MEDIA_FILE],
-        maybe_scoped_weight_type: [
-          ScopedWeightTypes.COMFY_UI,
-          ScopedWeightTypes.SDXL,
-        ],
-        maybe_scoped_media_file_type: [
-          ScopedMediaFileType.IMAGE_GENERATION,
-          ScopedMediaFileType.TEXT_TO_SPEECH,
-          ScopedMediaFileType.WORKFLOW_CONFIG,
-        ],
-      });
-      expect(api.fetch).toHaveBeenCalledWith(
-        "http://localhost:3000/v1/user_bookmarks/list/user1",
-        {
-          method: "GET",
-          query: {
-            maybe_scoped_entity_type: "media_file",
-            maybe_scoped_media_file_type:
-              "image_generation,text_to_speech,workflow_config",
-            maybe_scoped_weight_type: "comfy_ui,sdxl",
-            page_index: 2,
-            page_size: 76,
-            sort_ascending: true,
-          },
-        },
-      );
-      expect(response).toEqual({
-        success: true,
-        data: [mockBookmark],
-        pagination: {
-          current: 0,
-          total_page_count: 0,
-        },
-      });
-    });
-
-    it("exception", async () => {
-      const api = new UserBookmarksApi();
-      jest.spyOn(api, "fetch").mockRejectedValue(new Error("server error"));
-      const response = await api.ListUserBookmarksByUser({});
-      expect(api.fetch).toHaveBeenCalledWith(
-        "http://localhost:3000/v1/user_bookmarks/list/un1",
-        {
-          method: "GET",
-          query: {
-            maybe_scoped_entity_type: undefined,
-            maybe_scoped_media_file_type: undefined,
-            maybe_scoped_weight_type: undefined,
-            page_index: undefined,
-            page_size: undefined,
-            sort_ascending: undefined,
-          },
-        },
-      );
-      expect(response).toEqual({
-        success: false,
-        errorMessage: "server error",
-      });
-    });
-  });
-
-  describe("ListUserBookmarksByEntity", () => {
-    it("success", async () => {
-      const api = new UserBookmarksApi();
-      jest.spyOn(api, "fetch").mockResolvedValue({
-        success: true,
-        user_bookmarks: [
-          {
-            created_at: "2024-06-15T11:34:56.678Z",
-            token: "string",
-            updated_at: "2024-06-15T11:34:56.678Z",
-            user: {
-              default_avatar: {
-                color_index: 0,
-                image_index: 0,
-              },
-              display_name: "string",
-              gravatar_hash: "string",
-              user_token: "string",
-              username: "string",
-            },
-          },
-        ],
-      });
-      const response = await api.ListUserBookmarksByEntity({
-        entityType: "et1",
-        entityToken: "tok1",
-      });
-      expect(api.fetch).toHaveBeenCalledWith(
-        "http://localhost:3000/v1/user_bookmarks/list/et1/tok1",
-        {
-          method: "GET",
-          query: undefined,
-        },
-      );
-      expect(response).toEqual({
-        success: true,
-        data: [
-          {
-            created_at: "2024-06-15T11:34:56.678Z",
-            token: "string",
-            updated_at: "2024-06-15T11:34:56.678Z",
-            user: {
-              default_avatar: {
-                color_index: 0,
-                image_index: 0,
-              },
-              display_name: "string",
-              gravatar_hash: "string",
-              user_token: "string",
-              username: "string",
-            },
-          },
-        ],
-      });
-    });
-
-    it("exception", async () => {
-      const api = new UserBookmarksApi();
-      jest.spyOn(api, "fetch").mockRejectedValue(new Error("server error"));
-      const response = await api.ListUserBookmarksByEntity({
-        entityType: "et1",
-        entityToken: "tok1",
-      });
-      expect(api.fetch).toHaveBeenCalledWith(
-        "http://localhost:3000/v1/user_bookmarks/list/et1/tok1",
-        {
-          method: "GET",
-          query: undefined,
-        },
-      );
-      expect(response).toEqual({
-        success: false,
-        errorMessage: "server error",
-      });
-    });
-  });
 });

frontend/apps/artcraft/test/app/Classes/ApiManager/VoiceConversionApi.test.ts

@@ -1,52 +0,0 @@
-import { authentication } from "~/signals";
-import { UserInfo } from "~/models";
-import EnvironmentVariables from "~/Classes/EnvironmentVariables";
-import testUpdateDeleteEndpoints from "./utils/testUpdateDeleteEndpoints";
-import { VoiceConversionApi } from "~/Classes/ApiManager/VoiceConversionApi";
-
-EnvironmentVariables.initialize({ BASE_API: "http://localhost:3000" });
-
-describe("VoiceConversionApi", () => {
-  beforeAll(() => {
-    authentication.userInfo.value = {
-      user_token: "un1",
-      username: "un1",
-    } as UserInfo;
-  });
-  describe("run tests", () => {
-    const api = new VoiceConversionApi();
-    [
-      {
-        name: "PostAnalytics",
-        function: api.ConvertVoice.bind(api),
-        endpoint: "http://localhost:3000/v1/voice_conversion/inference",
-        method: "POST",
-        hasFailure: true,
-        paramsIn: {
-          autoPredictF0: true,
-          creatorSetVisibility: "public",
-          isStorytellerDemo: true,
-          overrideF0Method: "rmvpe",
-          sourceMediaUploadToken: "sourceToken123",
-          transpose: 2,
-          uuidIdempotencyToken: "uuid-1234-5678",
-          voiceConversionModelToken: "voiceModelToken123",
-        },
-        paramsTest: {
-          auto_predict_f0: true,
-          creator_set_visibility: "public",
-          is_storyteller_demo: true,
-          override_f0_method: "rmvpe",
-          source_media_upload_token: "sourceToken123",
-          transpose: 2,
-          uuid_idempotency_token: "uuid-1234-5678",
-          voice_conversion_model_token: "voiceModelToken123",
-        },
-        response: { inference_job_token: "ijt1" },
-        data: "ijt1",
-      },
-    ].forEach((testMethod) => {
-      testUpdateDeleteEndpoints(api, testMethod);
-    });
-  });
-});

frontend/apps/artcraft/test/app/Classes/ApiManager/VoiceDesignerApi.test.ts

@@ -1,93 +0,0 @@
-import { authentication } from "~/signals";
-import { UserInfo } from "~/models";
-import EnvironmentVariables from "~/Classes/EnvironmentVariables";
-import testUpdateDeleteEndpoints from "./utils/testUpdateDeleteEndpoints";
-import { VoiceDesignerApi } from "~/Classes/ApiManager/VoiceDesignerApi";
-import testListEndpoints from "./utils/testListEndpoints";
-
-const mockDataset = {
-  created_at: "2024-06-18T11:11:03.533Z",
-  creator: {
-    default_avatar: {
-      color_index: 3,
-      image_index: 1,
-    },
-    display_name: "JaneDoe",
-    gravatar_hash: "b1c967db4babc4eebc51abfa7a3e74d5",
-    user_token: "user-token-9876",
-    username: "janedoe",
-  },
-  creator_set_visibility: "private",
-  dataset_token: "dataset-token-456",
-  ietf_language_tag: "fr-FR",
-  ietf_primary_language_subtag: "fr",
-  title: "French Language Dataset",
-  updated_at: "2024-06-18T12:15:30.000Z",
-};
-
-EnvironmentVariables.initialize({ BASE_API: "http://localhost:3000" });
-
-describe("VoiceDesignerApi", () => {
-  beforeAll(() => {
-    authentication.userInfo.value = {
-      user_token: "un1",
-      username: "un1",
-    } as UserInfo;
-  });
-  describe("run tests", () => {
-    const api = new VoiceDesignerApi();
-    [
-      {
-        name: "PostAnalytics",
-        function: api.EnqueueTts.bind(api),
-        endpoint: "http://localhost:3000/v1/voice_designer/enqueue_tts",
-        method: "POST",
-        hasFailure: true,
-        paramsIn: {
-          text: "Sample text 1",
-          uuidIdempotencyToken: "uuid-1234-5678-abcdef",
-          voiceToken: "voice-token-1",
-        },
-        paramsTest: {
-          text: "Sample text 1",
-          uuid_idempotency_token: "uuid-1234-5678-abcdef",
-          voice_token: "voice-token-1",
-        },
-        response: { inference_job_token: "ijt1", voice_token: "vt1" },
-        data: { inference_job_token: "ijt1", voice_token: "vt1" },
-      },
-    ].forEach((testMethod) => {
-      testUpdateDeleteEndpoints(api, testMethod);
-    });
-  });
-
-  describe("run list tests", () => {
-    const api = new VoiceDesignerApi();
-    [
-      {
-        name: "ListWeightsByUser",
-        function: api.ListDatasetsByUser.bind(api),
-        tests: [
-          {
-            name: "no user",
-            endpoint: "http://localhost:3000/v1/voice_designer/user/un1/list",
-            query: {},
-            fetchQuery: undefined,
-            response: { datasets: [mockDataset] },
-            data: [mockDataset],
-          },
-          {
-            name: "user",
-            endpoint: "http://localhost:3000/v1/voice_designer/user/user1/list",
-            query: { username: "user1" },
-            fetchQuery: undefined,
-            response: { datasets: [mockDataset] },
-            data: [mockDataset],
-          },
-        ],
-      },
-    ].forEach((testMethod) => {
-      testListEndpoints(api, testMethod);
-    });
-  });
-});

frontend/libs/api/src/index.ts

@@ -3,7 +3,6 @@ export * from "./lib/enums/Job.js";
 export * from "./lib/models/Users.js";
 export * from "./lib/models/Job.js";
 export * from "./lib/models/Prompts.js";
-export * from "./lib/AnalyticsApi.js";
 export * from "./lib/BillingApi.js";
 export * from "./lib/CreditsApi.js";
 export * from "./lib/GenerationApi.js";

frontend/libs/api/src/lib/AnalyticsApi.ts

@@ -1,38 +0,0 @@
-import { ApiManager, ApiResponse } from "./ApiManager.js";
-
-export class AnalyticsApi extends ApiManager {
-  public PostAnalytics({
-    maybeLastAction,
-    maybeLogToken,
-  }: {
-    maybeLastAction: string;
-    maybeLogToken: string;
-  }): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/analytics/log_session`;
-
-    const body = {
-      maybe_last_action: maybeLastAction,
-      maybe_log_token: maybeLogToken,
-    };
-
-    return this.post<
-      {
-        maybe_last_action: string;
-        maybe_log_token: string;
-      },
-      {
-        success?: boolean;
-        log_token?: string;
-        BadInput?: string;
-      }
-    >({ endpoint, body })
-      .then((response) => ({
-        success: response.success ?? false,
-        data: response.log_token,
-        errorMessage: response.BadInput,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-}

frontend/libs/api/src/lib/EngineApi.ts

@@ -86,128 +86,4 @@ export class EngineApi extends ApiManager {
     return result;
   }
 
-  public async enqueueImageGeneration({
-    disableSystemPrompt,
-    prompt,
-    snapshotMediaToken,
-    additionalImages,
-  }: {
-    disableSystemPrompt: boolean;
-    prompt: string;
-    snapshotMediaToken: string;
-    additionalImages?: string[];
-  }): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/image_studio/prompt`;
-    
-    const uuidIdempotencyToken = crypto.randomUUID(); // Generate a new UUID
-    const body = {
-      uuid_idempotency_token: uuidIdempotencyToken,
-      disable_system_prompt: disableSystemPrompt,
-      prompt,
-      snapshot_media_token: snapshotMediaToken, // Changed from scene_media_token to snapshot_media_token
-      additional_images: additionalImages,
-    };
-
-    const postResponse = await this.post<
-      {
-        uuid_idempotency_token: string;
-        disable_system_prompt: boolean;
-        prompt: string;
-        snapshot_media_token: string;
-        additional_images?: string[];
-      },
-      { success?: boolean; job_token?: string; BadInput?: string }
-    >({
-      endpoint,
-      body,
-    });
-
-    // Check if the response is successful
-    const isSuccess = postResponse.success ?? false;
-
-    // Prepare the result object
-    const result = {
-      success: isSuccess,
-      data: isSuccess ? postResponse.job_token : undefined,
-      errorMessage: isSuccess ? undefined : postResponse.BadInput,
-    };
-
-    return result;
-  }
-
-  public async pollJobSession(jobToken: string): Promise<
-    ApiResponse<{
-      status: string;
-      result: {
-        generated_images?: string[];
-        error?: string;
-      };
-    }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/jobs/session/${jobToken}`;
-
-    const response = await this.get<{
-      success?: boolean;
-      status?: string;
-      result?: {
-        generated_images?: string[];
-        error?: string;
-      };
-      BadInput?: string;
-    }>({
-      endpoint,
-    });
-
-    const success = response.success ?? false;
-    const status = response.status ?? "";
-    const result = response.result ?? {
-      generated_images: [],
-      error: undefined,
-    };
-    const errorMessage = response.BadInput;
-
-    return {
-      success,
-      data: { status, result },
-      errorMessage,
-    };
-  }
-
-  public async pollStudioSessionJobs(jobToken: string): Promise<
-    ApiResponse<{
-      status: string;
-      result: {
-        generated_images?: string[];
-        error?: string;
-      };
-    }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/image_studio/session_jobs/${jobToken}`;
-
-    const response = await this.get<{
-      success?: boolean;
-      status?: string;
-      result?: {
-        generated_images?: string[];
-        error?: string;
-      };
-      BadInput?: string;
-    }>({
-      endpoint,
-    });
-
-    const success = response.success ?? false;
-    const status = response.status ?? "";
-    const result = response.result ?? {
-      generated_images: [],
-      error: undefined,
-    };
-    const errorMessage = response.BadInput;
-
-    return {
-      success,
-      data: { status, result },
-      errorMessage,
-    };
-  }
 }

frontend/libs/api/src/lib/FoldersApi.ts

@@ -296,6 +296,40 @@ export class FoldersApi extends ApiManager {
       .catch((err) => ({ success: false, errorMessage: err.message }));
   }
 
+  /**
+   * List the session user's media files that sit in no folder at all
+   * (memberships pointing at soft-deleted folders count as unfoldered).
+   * Newest first. Cursor-based — pass the previous response's `maybe_cursor`
+   * back as `cursor`; an absent cursor means the list is exhausted.
+   */
+  public ListMediaFilesWithoutFolder({
+    cursor,
+    limit,
+    filterMediaClass,
+  }: {
+    cursor?: string;
+    limit?: number;
+    /** Optional media class scope (image / video / audio / mesh / splat / ...). */
+    filterMediaClass?: string;
+  } = {}): Promise<ApiResponse<FolderMediaFileListItem[], FolderCursor>> {
+    const endpoint = `${this.getApiSchemeAndHost()}/v1/folders/media_files_without_folder`;
+    const query: Record<string, string | number> = {};
+    if (cursor) query.cursor = cursor;
+    if (limit) query.limit = limit;
+    if (filterMediaClass) query.filter_media_class = filterMediaClass;
+    return this.get<{
+      success: boolean;
+      media_files: FolderMediaFileListItem[];
+      maybe_cursor?: string | null;
+    }>({ endpoint, query })
+      .then((response) => ({
+        success: response.success,
+        data: response.media_files ?? [],
+        pagination: { maybe_cursor: response.maybe_cursor },
+      }))
+      .catch((err) => ({ success: false, errorMessage: err.message }));
+  }
+
   /**
    * Add media files to a folder. Idempotent (INSERT IGNORE); tokens that don't
    * exist or are soft-deleted are silently skipped — returns the accepted tokens.

frontend/libs/api/src/lib/PromptsApi.ts

@@ -3,57 +3,6 @@ import { Prompts } from "./models/Prompts.js";
 import { FetchProxy as fetch } from "@storyteller/tauri-utils";
 
 export class PromptsApi extends ApiManager {
-  public async enqueueImageGeneration({
-    disableSystemPrompt,
-    prompt,
-    snapshotMediaToken,
-    additionalImages,
-  }: {
-    disableSystemPrompt: boolean;
-    prompt: string;
-    snapshotMediaToken: string;
-    additionalImages?: string[];
-  }): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/image_studio/prompt`;
-
-    const uuidIdempotencyToken = crypto.randomUUID(); // Generate a new UUID
-    const body = {
-      uuid_idempotency_token: uuidIdempotencyToken,
-      disable_system_prompt: disableSystemPrompt,
-      prompt,
-      snapshot_media_token: snapshotMediaToken, // Changed from scene_media_token to snapshot_media_token
-      additional_images: additionalImages,
-    };
-
-    const postResponse = await this.post<
-      {
-        uuid_idempotency_token: string;
-        disable_system_prompt: boolean;
-        prompt: string;
-        snapshot_media_token: string;
-        additional_images?: string[];
-      },
-      { success?: boolean; job_token?: string; BadInput?: string }
-    >({
-      endpoint,
-      body,
-    });
-
-    // Check if the response is successful
-    const isSuccess = postResponse.success ?? false;
-    // Prepare the result object
-    console.log("postResponse FOR ENQUEUE IMAGE GENERATION");
-    console.log(postResponse);
-
-    const result = {
-      success: isSuccess,
-      data: isSuccess ? postResponse.job_token : undefined,
-      errorMessage: isSuccess ? undefined : postResponse.BadInput,
-    };
-
-    return result;
-  }
-
   public async pollJobSession(
     jobToken: string,
     thumbnailWidth = 256
@@ -130,44 +79,6 @@ export class PromptsApi extends ApiManager {
     };
   }
 
-  public async pollStudioSessionJobs(jobToken: string): Promise<
-    ApiResponse<{
-      status: string;
-      result: {
-        generated_images?: string[];
-        error?: string;
-      };
-    }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/image_studio/session_jobs/${jobToken}`;
-
-    const response = await this.get<{
-      success?: boolean;
-      status?: string;
-      result?: {
-        generated_images?: string[];
-        error?: string;
-      };
-      BadInput?: string;
-    }>({
-      endpoint,
-    });
-
-    const success = response.success ?? false;
-    const status = response.status ?? "";
-    const result = response.result ?? {
-      generated_images: [],
-      error: undefined,
-    };
-    const errorMessage = response.BadInput;
-
-    return {
-      success,
-      data: { status, result },
-      errorMessage,
-    };
-  }
-
   public GetPromptsByToken({
     token,
   }: {

frontend/libs/api/src/lib/UserBookmarksApi.ts

@@ -1,52 +1,5 @@
 import { ApiManager, ApiResponse } from "./ApiManager.js";
-import {
-  UserBookmarkBatch,
-  UserBookmarkByEntity,
-  UserBookmarkByUser,
-} from "./models/UserBookmark.js";
-import { Pagination } from "./models/Pagination.js";
-
-export enum ScopedEntityTypes {
-  USER = "user",
-  TTS_MODEL = "tts-model",
-  TTS_RESULT = "tts-result",
-  W2L_TEMPLATE = "w2l-template",
-  W2L_RESULT = "w2l-result",
-  MEDIA_FILE = "media_file",
-  MODEL_WEIGHT = "model_weight",
-  VOICE_CONVERSION_MODEL = "voice_conversion_model",
-  ZS_VOICE = "z_voice",
-}
-
-export enum ScopedWeightTypes {
-  HIFIGAN_TTl2 = "hifigan_tt2",
-  RVC_V2 = "rvc_v2",
-  SD_1_5 = "sd_1.5",
-  SDXL = "sdxl",
-  SO_VITS_SVC = "so_vits_svc",
-  TT2 = "tt2",
-  LORA = "loRA",
-  VALL_E = "vall_e",
-  COMFY_UI = "comfy_ui",
-}
-
-export enum ScopedMediaFileType {
-  IMAGE_GENERATION = "image_generation",
-  TEXT_TO_SPEECH = "text_to_speech",
-  VOCODER = "vocoder",
-  VOICE_CONVERSION = "voice_conversion",
-  WORKFLOW_CONFIG = "workflow_config",
-}
-
-interface ListUserBookmarksByUserRequest {
-  username: string;
-  sort_ascending?: boolean;
-  page_size?: number;
-  page_index?: number;
-  maybe_scoped_entity_type?: ScopedEntityTypes[];
-  maybe_scoped_weight_type?: ScopedWeightTypes[];
-  maybe_scoped_media_file_type?: ScopedMediaFileType[];
-}
+import { UserBookmarkBatch } from "./models/UserBookmark.js";
 
 export class UserBookmarksApi extends ApiManager {
   public CreateUserBookmark({
@@ -133,69 +86,4 @@ export class UserBookmarksApi extends ApiManager {
       });
   }
 
-  public ListUserBookmarksByUser({
-    username,
-    sort_ascending,
-    page_size,
-    page_index,
-    maybe_scoped_entity_type,
-    maybe_scoped_weight_type,
-    maybe_scoped_media_file_type,
-  }: ListUserBookmarksByUserRequest): Promise<
-    ApiResponse<UserBookmarkByUser[], Pagination>
-  > {
-    const user = username;
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/user_bookmarks/list/${user}`;
-
-    const query = {
-      sort_ascending,
-      page_size,
-      page_index,
-      maybe_scoped_entity_type: maybe_scoped_entity_type
-        ? maybe_scoped_entity_type.join(",")
-        : undefined,
-      maybe_scoped_weight_type: maybe_scoped_weight_type
-        ? maybe_scoped_weight_type.join(",")
-        : undefined,
-      maybe_scoped_media_file_type: maybe_scoped_media_file_type
-        ? maybe_scoped_media_file_type.join(",")
-        : undefined,
-    };
-
-    return this.get<{
-      success?: boolean;
-      pagination?: Pagination;
-      results: UserBookmarkByUser[];
-    }>({ endpoint, query })
-      .then((response) => ({
-        success: response.success ?? false,
-        data: response.results,
-        pagination: response.pagination,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-
-  public ListUserBookmarksByEntity({
-    entityType,
-    entityToken,
-  }: {
-    entityType: string;
-    entityToken: string;
-  }): Promise<ApiResponse<UserBookmarkByEntity[]>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/user_bookmarks/list/${entityType}/${entityToken}`;
-
-    return this.get<{
-      success: boolean;
-      user_bookmarks: UserBookmarkByEntity[];
-    }>({ endpoint })
-      .then((response) => ({
-        success: true,
-        data: response.user_bookmarks,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
 }

frontend/libs/api/src/lib/VoiceConversionApi.ts

@@ -1,53 +0,0 @@
-import { ApiManager, ApiResponse } from "./ApiManager.js";
-
-interface VoiceConversionParams {
-  autoPredictF0?: boolean;
-  creatorSetVisibility?: string;
-  isStorytellerDemo?: boolean;
-  overrideF0Method?: string;
-  sourceMediaUploadToken: string;
-  transpose?: number;
-  uuidIdempotencyToken: string;
-  voiceConversionModelToken: string;
-}
-
-interface VoiceConversionRequest {
-  auto_predict_f0: boolean;
-  creator_set_visibility: string;
-  is_storyteller_demo: boolean;
-  override_f0_method: string;
-  source_media_upload_token: string;
-  transpose: number;
-  uuid_idempotency_token: string;
-  voice_conversion_model_token: string;
-}
-
-export class VoiceConversionApi extends ApiManager {
-  public ConvertVoice(
-    params: VoiceConversionParams,
-  ): Promise<ApiResponse<string>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/voice_conversion/inference`;
-
-    const body = this.parseBodyValues<
-      VoiceConversionParams,
-      VoiceConversionRequest
-    >(params);
-
-    return this.post<
-      VoiceConversionRequest,
-      {
-        success?: boolean;
-        inference_job_token?: string;
-        BadInput?: string;
-      }
-    >({ endpoint, body })
-      .then((response) => ({
-        success: response.success ?? false,
-        data: response.inference_job_token,
-        errorMessage: response.BadInput,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-}

frontend/libs/api/src/lib/VoiceDesignerApi.ts

@@ -1,77 +0,0 @@
-import { ApiManager, ApiResponse } from "./ApiManager.js";
-import { Pagination } from "./models/Pagination.js";
-import { ZsDataset } from "./models/Dataset.js";
-
-interface VoiceDesignerParams {
-  text: string;
-  uuidIdempotencyToken: string;
-  voiceToken: string;
-}
-
-interface VoiceDesignerRequest {
-  text: string;
-  uuid_idempotency_token: string;
-  voice_token: string;
-}
-
-export class VoiceDesignerApi extends ApiManager {
-  public EnqueueTts(
-    params: VoiceDesignerParams,
-  ): Promise<
-    ApiResponse<{ inference_job_token?: string; voice_token?: string }>
-  > {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/voice_designer/enqueue_tts`;
-
-    const body = this.parseBodyValues<
-      VoiceDesignerParams,
-      VoiceDesignerRequest
-    >(params);
-
-    return this.post<
-      VoiceDesignerRequest,
-      {
-        success?: boolean;
-        inference_job_token?: string;
-        voice_token: string;
-        BadInput?: string;
-      }
-    >({ endpoint, body })
-      .then((response) => ({
-        success: response.success ?? false,
-        ...(response.success
-          ? {
-              data: {
-                inference_job_token: response.inference_job_token,
-                voice_token: response.voice_token,
-              },
-            }
-          : {}),
-        errorMessage: response.BadInput,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-
-  public ListDatasetsByUser({
-    username,
-  }: {
-    username: string;
-  }): Promise<ApiResponse<ZsDataset[]>> {
-    const user = username;
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/voice_designer/user/${user}/list`;
-
-    return this.get<{
-      success: boolean;
-      datasets: ZsDataset[];
-      pagination: Pagination;
-    }>({ endpoint })
-      .then((response) => ({
-        success: true,
-        data: response.datasets,
-      }))
-      .catch((err) => {
-        return { success: false, errorMessage: err.message };
-      });
-  }
-}

frontend/libs/api/src/lib/WeightsApi.ts

@@ -274,7 +274,7 @@ export class WeightsApi extends ApiManager {
     weightToken: string;
     coverImageMediaFileToken: string;
   }): Promise<ApiResponse<undefined>> {
-    const endpoint = `${this.getApiSchemeAndHost()}/v1/weights/${weightToken}/cover_image`;
+    const endpoint = `${this.getApiSchemeAndHost()}/v1/weights/weight/${weightToken}/cover_image`;
 
     const body = {
       cover_image_media_file_token: coverImageMediaFileToken,

frontend/libs/api/src/lib/models/UserBookmark.ts

@@ -4,72 +4,3 @@ export interface UserBookmarkBatch {
   is_bookmarked: boolean;
   maybe_bookmark_token: string;
 }
-
-interface DefaultAvatar {
-  color_index: number;
-  image_index: number;
-}
-
-interface User {
-  default_avatar: DefaultAvatar;
-  display_name: string;
-  gravatar_hash: string;
-  user_token: string;
-  username: string;
-}
-
-export interface UserBookmarkByEntity {
-  created_at: string;
-  token: string;
-  updated_at: string;
-  user: User;
-}
-
-interface DefaultAvatar {
-  color_index: number;
-  image_index: number;
-}
-
-interface Creator {
-  default_avatar: DefaultAvatar;
-  display_name: string;
-  gravatar_hash: string;
-  user_token: string;
-  username: string;
-}
-
-interface MediaFileData {
-  maybe_creator: Creator;
-  media_type: string; // Adjust type as per your specific schema
-  public_bucket_path: string;
-}
-
-interface WeightData {
-  maybe_cover_image_public_bucket_path: string;
-  maybe_creator: Creator;
-  title: string;
-  weight_category: string; // Adjust type as per your specific schema
-  weight_type: string; // Adjust type as per your specific schema
-}
-
-interface Stats {
-  bookmark_count: number;
-  positive_rating_count: number;
-}
-
-interface Details {
-  entity_token: string;
-  entity_type: string; // Adjust type as per your specific schema
-  maybe_media_file_data?: MediaFileData;
-  maybe_summary_text?: string;
-  maybe_thumbnail_url?: string;
-  maybe_weight_data?: WeightData;
-  stats: Stats;
-}
-
-export interface UserBookmarkByUser {
-  created_at: string;
-  details: Details;
-  token: string;
-  updated_at: string;
-}

frontend/libs/components/gallery-modal/src/lib/GalleryItemMenuItems.tsx

@@ -13,6 +13,7 @@ import {
 import { twMerge } from "tailwind-merge";
 import { GalleryItem } from "./gallery-modal";
 import { GalleryFolder } from "./GalleryDraggableItem";
+import { compareFolders } from "./folderUtils";
 
 // Touch-first devices have no hover and narrow viewports — the folder submenu
 // expands inline (accordion) instead of flying out past the screen edge.
@@ -213,7 +214,9 @@ const FolderList = ({
   closeAll: () => void;
 }) => (
   <>
-    {folders.map((folder) => (
+    {/* Same ordering as the sidebar / folder chips: starred first, then
+        alphabetical. */}
+    {[...folders].sort(compareFolders).map((folder) => (
       <button
         key={folder.id}
         type="button"

frontend/libs/components/gallery-modal/src/lib/gallery-modal.tsx

@@ -3057,7 +3057,9 @@ export const GalleryModal = React.memo(
                               No folders yet
                             </div>
                           ) : (
-                            folders.map((folder) => (
+                            // Same ordering as the folder chips: starred
+                            // first, then alphabetical.
+                            [...folders].sort(compareFolders).map((folder) => (
                               <button
                                 key={folder.id}
                                 type="button"