Edit photos by describing the change, on your own GPU. A free, open-source alternative to Nano Banana and ChatGPT image editing: photos stay on your computer, no daily limit. One installer for Windows, Mac and Linux sets up the best open model (Qwen-Image 2.1). MCP server for AI agents.
TypeScript ai-photo-editorcomfyui-alternativegenerative-fillimage-editingimage-generationinpaintinglinuxlocal-aimacosmcpmcp-servernano-banana-alternativeofflinephoto-editorprivacyqwen-imageqwen-image-2-1stable-diffusion-cppvulkanwindows
Projects shared by every device: kokon-service keeps the list (projects.json)
Gabriele Lozupone9f3c159e0fc8
diff --git a/crates/qls-core/src/engine.rs b/crates/qls-core/src/engine.rsindex cb5f545..740e4e6 100644--- a/crates/qls-core/src/engine.rs+++ b/crates/qls-core/src/engine.rs@@ -110,6 +110,8 @@ pub enum Event {Job { job: Box<JobView> },Server { state: ServerState, owned: bool, error: Option<AppError> },Gallery { id: String, change: &'static str },+ /// A project changed (`rev`) or was removed: the other devices reload it.+ Projects { id: String, rev: u64, deleted: bool },}pub struct Engine {@@ -119,6 +121,8 @@ pub struct Engine {/// Private mode: records in memory, files under `private_dir`; wiped by `clear_private`,/// at start and at exit. Never listed in the gallery.pub private_store: Arc<Store>,+ /// The project list every device shares (`projects.rs`).+ pub projects: crate::projects::ProjectStore,/// Measured speed of this machine, for time estimates.speed: crate::speed::SpeedBook,data_dir: PathBuf,@@ -239,6 +243,7 @@ impl Engine {server: ServerManager::new(data_dir.to_path_buf()),store,private_store,+ projects: if cfg!(test) { crate::projects::ProjectStore::in_memory() } else { crate::projects::ProjectStore::open(data_dir) },speed: if cfg!(test) { crate::speed::SpeedBook::in_memory() } else { crate::speed::SpeedBook::open(data_dir) },data_dir: data_dir.to_path_buf(),private_dir,@@ -443,6 +448,26 @@ impl Engine {if self.store.get_input(id).is_err() && self.private_store.get_input(id).is_ok() { &self.private_store } else { &self.store }}+ /// The records of project `id`'s versions (see [`crate::projects::Records`]), from either+ /// store; `None` for an unknown project.+ pub fn project_records(&self, id: &str) -> Option<crate::projects::Records> {+ let p = self.projects.get(id)?;+ let mut out = crate::projects::Records::default();+ for i in &p.items {+ if let Some(g) = &i.gen_id+ && let Ok(r) = self.gen_store(g).get_generation(g)+ {+ out.generations.insert(g.clone(), r);+ }+ if let Some(r) = &i.input_id+ && let Ok(rec) = self.input_store(r).get_input(r)+ {+ out.inputs.insert(r.clone(), rec);+ }+ }+ Some(out)+ }+/// Where a generation's image file may be deleted from: the output folder, or the/// private folder for private results.pub fn output_root(&self, id: &str) -> PathBuf {@@ -550,6 +575,12 @@ impl Engine {v}+ pub fn emit_projects(&self, changes: Vec<crate::projects::Change>) {+ for c in changes {+ let _ = self.events.send(Event::Projects { id: c.id, rev: c.rev, deleted: c.deleted });+ }+ }+fn emit_job(&self, id: &str) {if let Some(v) = self.job(id) {let _ = self.events.send(Event::Job { job: Box::new(v) });@@ -1240,12 +1271,20 @@ impl Engine {}records.push(rec);}+ let gen_ids: Vec<String> = records.iter().map(|r| r.id.clone()).collect();self.update(id, |j| {j.view.status = JobStatus::Done;j.view.results = records;j.view.finished_at = Some(now_rfc3339());j.view.stage = None;});+ // The project waiting for it gets its images even with no app open to add them.+ if !request.private {+ match self.projects.job_done(id, &gen_ids, now_ms()) {+ Ok(changes) => self.emit_projects(changes),+ Err(e) => tracing::warn!("job {id}: project list not updated: {e}"),+ }+ }Ok(())}@@ -1700,6 +1739,11 @@ pub fn encode_output(img: &image::RgbaImage, format: OutputFormat, rec: &Generat}}+/// Milliseconds since 1970, as the UI's `Date.now()`.+pub fn now_ms() -> f64 {+ std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as f64).unwrap_or(0.0)+}+pub fn write_atomic(path: &Path, bytes: &[u8]) -> AppResult<()> {let tmp = path.with_extension(format!("{}.part", path.extension().map(|e| e.to_string_lossy().into_owned()).unwrap_or_default()));std::fs::write(&tmp, bytes).map_err(|e| AppError::io("write the image", &tmp, e))?;@@ -2230,6 +2274,48 @@ mod tests {assert!(reused_seed_note(4001, 5, 2).contains("made a reference image"));}+ #[test]+ fn project_records_come_in_one_answer() {+ let dir = tempfile::tempdir().unwrap();+ // SAFETY: test-only env override, single-threaded setup.+ unsafe { std::env::set_var("QLS_CONFIG_DIR", dir.path().join("cfg")) };+ let mut cfg = AppConfig::default();+ cfg.sdcpp_dir = dir.path().join("sdcpp");+ cfg.normalize();+ let e = Engine::new(cfg, dir.path()).unwrap();+ let png = imaging::encode_png(&image::RgbaImage::from_pixel(8, 8, image::Rgba([1, 2, 3, 255])), &[], None, true).unwrap();+ let input = e.store.put_input(&png, Some("a.png"), None).unwrap();+ e.store.insert_generation(&test_record("g1", 1, "g1.png")).unwrap();+ // Made in private mode: in the other store.+ e.private_store.insert_generation(&test_record("p1", 2, "p1.png")).unwrap();+ let item = |key: &str, kind: &str, gen_id: Option<&str>, input_id: Option<&str>| crate::projects::Item {+ key: key.into(),+ kind: kind.into(),+ gen_id: gen_id.map(Into::into),+ input_id: input_id.map(Into::into),+ job_id: None,+ extra: Default::default(),+ };+ let items = vec![+ item("i", "input", None, Some(&input.id)),+ item("a", "gen", Some("g1"), None),+ item("b", "gen", Some("p1"), None),+ item("gone", "gen", Some("deleted"), None),+ item("j", "job", None, None),+ ];+ let meta = crate::projects::Meta { id: "p".into(), title: "t".into(), named: None, updated_at: 1.0, cover: None, count: 0 };+ let project = crate::projects::Project { meta, items, selected: None, loras: None, rev: 0, extra: Default::default() };+ e.projects.put("p", project, &Default::default()).unwrap();+ let r = e.project_records("p").unwrap();+ let mut gens: Vec<_> = r.generations.keys().cloned().collect();+ gens.sort();+ assert_eq!(gens, ["g1", "p1"], "a deleted version is left out");+ assert_eq!(r.generations["p1"].seed, 2);+ assert_eq!(r.inputs.len(), 1);+ assert_eq!(r.inputs[&input.id].original_name.as_deref(), Some("a.png"));+ assert!(e.project_records("nope").is_none());+ }+#[test]fn reference_seeds_come_from_metadata_and_gallery() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/qls-core/src/lib.rs b/crates/qls-core/src/lib.rsindex c87d53f..ed5f22f 100644--- a/crates/qls-core/src/lib.rs+++ b/crates/qls-core/src/lib.rs@@ -18,6 +18,7 @@ pub mod paths;pub mod pipeline;pub mod planner;pub mod process;+pub mod projects;pub mod remote;pub mod sdcpp;pub mod speed;diff --git a/crates/qls-core/src/projects.rs b/crates/qls-core/src/projects.rsnew file mode 100644index 0000000..347839b--- /dev/null+++ b/crates/qls-core/src/projects.rs@@ -0,0 +1,590 @@+//! The project list, shared by every device that uses this Kokon (the desktop app, a phone's+//! browser). Before 0.11 each app kept it in its own browser storage; each one now sends that+//! copy once (`import`) and from then on reads and saves here.+//!+//! A project is the UI's: a title and its versions in order (`items`), each one a gallery image,+//! an imported image or a job still running. Two devices can change the same project at once+//! (an edit made on the phone while the computer has it open), so a save is merged, not+//! overwritten: the saving device sends the versions it knew (`known`), and versions it did not+//! know (added elsewhere since) are kept, while versions it knew and left out were removed by it.+//! Removed projects leave a tombstone, so a device that had not heard yet cannot bring them back.+//! Stored in `<data>/projects.json`.++use std::collections::{HashMap, HashSet};+use std::path::{Path, PathBuf};+use std::sync::Mutex;++use serde::{Deserialize, Serialize};+use serde_json::{Map, Value};++use crate::error::{AppError, AppResult, ErrorCode};++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]+#[serde(rename_all = "camelCase")]+pub struct Item {+ pub key: String,+ /// "gen", "input" or "job".+ pub kind: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub gen_id: Option<String>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub input_id: Option<String>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub job_id: Option<String>,+ /// Fields of newer apps, kept as they are (the request of a running job among them).+ #[serde(flatten)]+ pub extra: Map<String, Value>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]+#[serde(rename_all = "camelCase")]+pub struct Meta {+ pub id: String,+ pub title: String,+ /// The title was typed by the user (otherwise it follows the first prompt).+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub named: Option<bool>,+ /// Milliseconds since 1970: the list is sorted by it.+ pub updated_at: f64,+ #[serde(default)]+ pub cover: Option<String>,+ #[serde(default)]+ pub count: u32,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]+#[serde(rename_all = "camelCase")]+pub struct Project {+ pub meta: Meta,+ #[serde(default)]+ pub items: Vec<Item>,+ #[serde(default)]+ pub selected: Option<String>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub loras: Option<Vec<String>>,+ /// Bumped by every change here; a device ignores news of a revision it already has.+ #[serde(default)]+ pub rev: u64,+ #[serde(flatten)]+ pub extra: Map<String, Value>,+}++#[derive(Default, Serialize, Deserialize)]+struct File {+ #[serde(default)]+ projects: HashMap<String, Project>,+ /// Removed project id → when (ms).+ #[serde(default)]+ deleted: HashMap<String, f64>,+}++/// The gallery and input records of a project's versions, sent in one answer to a browser+/// opening it (one request per version is slow on a phone). A version whose record is gone+/// (deleted from the gallery) is left out.+#[derive(Debug, Default, Serialize)]+pub struct Records {+ pub generations: HashMap<String, crate::store::GenerationRecord>,+ pub inputs: HashMap<String, crate::store::InputRecord>,+}++/// What a change did, for the event the other devices hear.+#[derive(Debug, Clone, PartialEq)]+pub struct Change {+ pub id: String,+ pub rev: u64,+ pub deleted: bool,+}++pub struct ProjectStore {+ path: Option<PathBuf>,+ data: Mutex<File>,+}++fn source(i: &Item) -> Option<String> {+ i.gen_id+ .as_ref()+ .map(|g| format!("gen:{g}"))+ .or_else(|| i.input_id.as_ref().map(|r| format!("input:{r}")))+}++/// The cover (the latest image) and the number of versions, as the UI computes them.+fn refresh_meta(p: &mut Project) {+ p.meta.cover = p.items.iter().rev().find_map(source);+ p.meta.count = p.items.iter().filter(|i| i.kind != "job").count() as u32;+}++/// Merges a device's save into the stored copy (see the module comment). Pure, for the tests.+pub fn merge(stored: Option<&Project>, incoming: Project, known: &HashSet<String>) -> Project {+ let Some(stored) = stored else {+ let mut p = incoming;+ p.rev = 1;+ refresh_meta(&mut p);+ return p;+ };+ let mut items = incoming.items.clone();+ // Versions added elsewhere since this device last heard: each goes back after the version+ // it followed there (or at the end).+ let mut anchor: Option<String> = None;+ for it in &stored.items {+ if items.iter().any(|x| x.key == it.key) {+ anchor = Some(it.key.clone());+ continue;+ }+ if known.contains(&it.key) {+ continue;+ }+ let at = anchor+ .as_ref()+ .and_then(|a| items.iter().position(|x| &x.key == a))+ .map(|k| k + 1)+ .unwrap_or(items.len());+ items.insert(at, it.clone());+ anchor = Some(it.key.clone());+ }+ // A running job whose images arrived (here or on another device) is no longer pending.+ let finished: HashSet<String> = items+ .iter()+ .filter(|i| i.kind != "job")+ .filter_map(|i| i.job_id.clone())+ .collect();+ items.retain(|i| i.kind != "job" || !i.job_id.as_ref().is_some_and(|j| finished.contains(j)));++ let mut meta = incoming.meta.clone();+ // A name typed on another device is kept over a title this device made up from a prompt.+ if stored.meta.named == Some(true) && incoming.meta.named != Some(true) {+ meta.title = stored.meta.title.clone();+ meta.named = Some(true);+ }+ meta.updated_at = meta.updated_at.max(stored.meta.updated_at);+ let has = |k: &Option<String>| {+ k.as_ref()+ .is_some_and(|k| items.iter().any(|i| &i.key == k))+ };+ let selected = if has(&incoming.selected) {+ incoming.selected.clone()+ } else if has(&stored.selected) {+ stored.selected.clone()+ } else {+ items.last().map(|i| i.key.clone())+ };+ let mut p = Project {+ meta,+ items,+ selected,+ loras: incoming.loras.clone(),+ rev: stored.rev + 1,+ extra: incoming.extra,+ };+ refresh_meta(&mut p);+ p+}++impl ProjectStore {+ /// Loads `<data_dir>/projects.json` (missing: an empty list).+ pub fn open(data_dir: &Path) -> Self {+ let path = data_dir.join("projects.json");+ let data = match std::fs::read_to_string(&path) {+ Ok(t) => serde_json::from_str(&t).unwrap_or_else(|e| {+ // Unreadable: kept aside instead of being overwritten by the next save.+ tracing::warn!("projects.json is unreadable ({e}); kept as projects.json.bad");+ let _ = std::fs::rename(&path, path.with_extension("json.bad"));+ File::default()+ }),+ Err(_) => File::default(),+ };+ Self {+ path: Some(path),+ data: Mutex::new(data),+ }+ }++ /// Not persisted (tests).+ pub fn in_memory() -> Self {+ Self {+ path: None,+ data: Mutex::new(File::default()),+ }+ }++ fn save(&self, f: &File) -> AppResult<()> {+ let Some(path) = &self.path else {+ return Ok(());+ };+ let text = serde_json::to_vec(f).map_err(AppError::internal)?;+ let tmp = path.with_extension("json.part");+ std::fs::write(&tmp, text).map_err(|e| AppError::io("save the project list", &tmp, e))?;+ std::fs::rename(&tmp, path).map_err(|e| AppError::io("save the project list", path, e))+ }++ /// Every project, most recent first.+ pub fn list(&self) -> Vec<Project> {+ let mut v: Vec<Project> = self+ .data+ .lock()+ .unwrap()+ .projects+ .values()+ .cloned()+ .collect();+ v.sort_by(|a, b| b.meta.updated_at.total_cmp(&a.meta.updated_at));+ v+ }++ pub fn get(&self, id: &str) -> Option<Project> {+ self.data.lock().unwrap().projects.get(id).cloned()+ }++ /// Saves a device's copy of project `id`, merged with what is stored. A removed project+ /// stays removed (NotFound).+ pub fn put(+ &self,+ id: &str,+ mut incoming: Project,+ known: &HashSet<String>,+ ) -> AppResult<(Project, Change)> {+ let mut f = self.data.lock().unwrap();+ if f.deleted.contains_key(id) {+ return Err(AppError::new(+ ErrorCode::NotFound,+ "This project was removed on another device.",+ ));+ }+ incoming.meta.id = id.to_string();+ let merged = merge(f.projects.get(id), incoming, known);+ f.projects.insert(id.to_string(), merged.clone());+ self.save(&f)?;+ let change = Change {+ id: id.to_string(),+ rev: merged.rev,+ deleted: false,+ };+ Ok((merged, change))+ }++ pub fn delete(&self, id: &str, now_ms: f64) -> AppResult<Change> {+ let mut f = self.data.lock().unwrap();+ f.projects.remove(id);+ f.deleted.insert(id.to_string(), now_ms);+ self.save(&f)?;+ Ok(Change {+ id: id.to_string(),+ rev: 0,+ deleted: true,+ })+ }++ /// A device's list from before 0.11 (its browser storage). Projects not here are added,+ /// ones here are merged (nothing of either copy is lost), removed ones stay removed.+ /// Sending the same list again changes nothing.+ pub fn import(&self, list: Vec<Project>) -> AppResult<Vec<Change>> {+ let mut f = self.data.lock().unwrap();+ let mut changes = Vec::new();+ for p in list {+ let id = p.meta.id.clone();+ if id.is_empty() || f.deleted.contains_key(&id) {+ continue;+ }+ let stored = f.projects.get(&id);+ let merged = merge(stored, p, &HashSet::new());+ if stored.is_some_and(|s| merged.items == s.items && merged.meta.title == s.meta.title)+ {+ continue;+ }+ changes.push(Change {+ id: id.clone(),+ rev: merged.rev,+ deleted: false,+ });+ f.projects.insert(id, merged);+ }+ if !changes.is_empty() {+ self.save(&f)?;+ }+ Ok(changes)+ }++ /// Job `job_id` finished: in every project waiting for it, its images replace the pending+ /// version (keys "r-<image id>", the same the apps use, so a device doing it too adds nothing).+ pub fn job_done(+ &self,+ job_id: &str,+ gen_ids: &[String],+ now_ms: f64,+ ) -> AppResult<Vec<Change>> {+ let mut f = self.data.lock().unwrap();+ let mut changes = Vec::new();+ for p in f.projects.values_mut() {+ let Some(k) = p+ .items+ .iter()+ .position(|i| i.kind == "job" && i.job_id.as_deref() == Some(job_id))+ else {+ continue;+ };+ let results: Vec<Item> = gen_ids+ .iter()+ .map(|g| Item {+ key: format!("r-{g}"),+ kind: "gen".into(),+ gen_id: Some(g.clone()),+ input_id: None,+ job_id: Some(job_id.to_string()),+ extra: Map::new(),+ })+ .filter(|r| !p.items.iter().any(|i| i.key == r.key))+ .collect();+ let pending = p.items[k].key.clone();+ let first = results.first().map(|r| r.key.clone());+ p.items.splice(k..k + 1, results);+ if p.selected.as_deref() == Some(pending.as_str()) {+ p.selected = first.or_else(|| p.items.last().map(|i| i.key.clone()));+ }+ p.meta.updated_at = p.meta.updated_at.max(now_ms);+ p.rev += 1;+ refresh_meta(p);+ changes.push(Change {+ id: p.meta.id.clone(),+ rev: p.rev,+ deleted: false,+ });+ }+ if !changes.is_empty() {+ self.save(&f)?;+ }+ Ok(changes)+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn img(key: &str) -> Item {+ Item {+ key: key.into(),+ kind: "gen".into(),+ gen_id: Some(format!("g{key}")),+ input_id: None,+ job_id: None,+ extra: Map::new(),+ }+ }++ fn job(key: &str, job: &str) -> Item {+ Item {+ key: key.into(),+ kind: "job".into(),+ gen_id: None,+ input_id: None,+ job_id: Some(job.into()),+ extra: Map::new(),+ }+ }++ fn project(id: &str, items: Vec<Item>) -> Project {+ Project {+ meta: Meta {+ id: id.into(),+ title: "A prompt".into(),+ named: None,+ updated_at: 1.0,+ cover: None,+ count: 0,+ },+ selected: items.last().map(|i| i.key.clone()),+ items,+ loras: None,+ rev: 0,+ extra: Map::new(),+ }+ }++ fn keys(p: &Project) -> Vec<&str> {+ p.items.iter().map(|i| i.key.as_str()).collect()+ }++ fn known(k: &[&str]) -> HashSet<String> {+ k.iter().map(|s| s.to_string()).collect()+ }++ #[test]+ fn a_new_project_is_stored_with_its_cover_and_count() {+ let s = ProjectStore::in_memory();+ let (p, c) = s+ .put(+ "p",+ project("p", vec![img("a"), job("b", "j1")]),+ &known(&[]),+ )+ .unwrap();+ assert_eq!(+ c,+ Change {+ id: "p".into(),+ rev: 1,+ deleted: false+ }+ );+ assert_eq!(p.meta.cover.as_deref(), Some("gen:ga"));+ assert_eq!(p.meta.count, 1);+ }++ #[test]+ fn versions_added_on_two_devices_are_both_kept() {+ let s = ProjectStore::in_memory();+ s.put("p", project("p", vec![img("a")]), &known(&[]))+ .unwrap();+ // The phone adds b, the computer (which only knew a) adds c.+ s.put("p", project("p", vec![img("a"), img("b")]), &known(&["a"]))+ .unwrap();+ let (p, _) = s+ .put("p", project("p", vec![img("a"), img("c")]), &known(&["a"]))+ .unwrap();+ assert_eq!(keys(&p), ["a", "b", "c"]);+ assert_eq!(p.rev, 3);+ }++ #[test]+ fn a_version_removed_by_a_device_that_knew_it_stays_removed() {+ let s = ProjectStore::in_memory();+ s.put("p", project("p", vec![img("a"), img("b")]), &known(&[]))+ .unwrap();+ let (p, _) = s+ .put("p", project("p", vec![img("a")]), &known(&["a", "b"]))+ .unwrap();+ assert_eq!(keys(&p), ["a"]);+ }++ #[test]+ fn a_version_from_elsewhere_goes_back_after_the_one_it_followed() {+ let stored = project("p", vec![img("a"), img("x"), img("b")]);+ let p = merge(+ Some(&stored),+ project("p", vec![img("a"), img("b"), img("c")]),+ &known(&["a", "b"]),+ );+ assert_eq!(keys(&p), ["a", "x", "b", "c"]);+ }++ #[test]+ fn a_finished_job_replaces_its_pending_version_once() {+ let s = ProjectStore::in_memory();+ s.put(+ "p",+ project("p", vec![img("a"), job("k", "j1")]),+ &known(&[]),+ )+ .unwrap();+ let ch = s.job_done("j1", &["g1".into(), "g2".into()], 5.0).unwrap();+ assert_eq!(ch.len(), 1);+ let p = s.get("p").unwrap();+ assert_eq!(keys(&p), ["a", "r-g1", "r-g2"]);+ assert_eq!(p.selected.as_deref(), Some("r-g1"));+ assert_eq!(p.meta.count, 3);+ // The app that made it does the same with the same keys: no copies, no pending left.+ let (p, _) = s+ .put(+ "p",+ project(+ "p",+ vec![+ img("a"),+ job("k", "j1"),+ Item {+ key: "r-g1".into(),+ job_id: Some("j1".into()),+ ..img("r-g1")+ },+ ],+ ),+ &known(&["a", "k"]),+ )+ .unwrap();+ assert_eq!(keys(&p), ["a", "r-g1", "r-g2"]);+ assert!(s.job_done("j1", &["g1".into()], 6.0).unwrap().is_empty());+ }++ #[test]+ fn a_name_typed_elsewhere_beats_a_title_from_a_prompt() {+ let mut stored = project("p", vec![img("a")]);+ stored.meta.title = "Holiday".into();+ stored.meta.named = Some(true);+ let p = merge(Some(&stored), project("p", vec![img("a")]), &known(&["a"]));+ assert_eq!(p.meta.title, "Holiday");+ let mut renamed = project("p", vec![img("a")]);+ renamed.meta.title = "Trip".into();+ renamed.meta.named = Some(true);+ assert_eq!(+ merge(Some(&stored), renamed, &known(&["a"])).meta.title,+ "Trip"+ );+ }++ #[test]+ fn removed_projects_stay_removed() {+ let s = ProjectStore::in_memory();+ s.put("p", project("p", vec![img("a")]), &known(&[]))+ .unwrap();+ s.delete("p", 2.0).unwrap();+ assert!(+ s.put("p", project("p", vec![img("a")]), &known(&[]))+ .is_err()+ );+ assert!(+ s.import(vec![project("p", vec![img("a")])])+ .unwrap()+ .is_empty()+ );+ assert!(s.list().is_empty());+ }++ #[test]+ fn importing_merges_lists_and_twice_changes_nothing() {+ let s = ProjectStore::in_memory();+ s.put("p", project("p", vec![img("a")]), &known(&[]))+ .unwrap();+ let phone = vec![+ project("p", vec![img("a"), img("b")]),+ project("q", vec![img("c")]),+ ];+ assert_eq!(s.import(phone.clone()).unwrap().len(), 2);+ assert_eq!(keys(&s.get("p").unwrap()), ["a", "b"]);+ assert!(s.import(phone).unwrap().is_empty());+ assert_eq!(s.list().len(), 2);+ }++ #[test]+ fn the_list_survives_a_restart_and_keeps_unknown_fields() {+ let dir = tempfile::tempdir().unwrap();+ let s = ProjectStore::open(dir.path());+ let mut p = project("p", vec![img("a")]);+ p.items[0].extra.insert("future".into(), Value::from(1));+ s.put("p", p, &known(&[])).unwrap();+ let again = ProjectStore::open(dir.path());+ assert_eq!(+ again.get("p").unwrap().items[0].extra.get("future"),+ Some(&Value::from(1))+ );+ }++ #[test]+ fn the_stored_format_reads_what_the_app_saved_before() {+ // A project as 0.10's UI kept it in browser storage.+ let v: Project = serde_json::from_str(+ r#"{"meta":{"id":"p","title":"Cat","updatedAt":1700000000000,"cover":"gen:g1","count":1},+ "items":[{"key":"k1","kind":"gen","genId":"g1","jobId":"j"},{"key":"k2","kind":"job","jobId":"j2","request":{"prompt":"x"}}],+ "selected":"k1","loras":["l"]}"#,+ )+ .unwrap();+ assert_eq!(+ v.items[1]+ .extra+ .get("request")+ .and_then(|r| r.get("prompt")),+ Some(&Value::from("x"))+ );+ let back = serde_json::to_value(&v).unwrap();+ assert_eq!(back["items"][0]["genId"], "g1");+ assert_eq!(back["meta"]["updatedAt"], 1700000000000.0);+ }+}diff --git a/crates/qls-core/src/remote.rs b/crates/qls-core/src/remote.rsindex 9877fc9..f79bae6 100644--- a/crates/qls-core/src/remote.rs+++ b/crates/qls-core/src/remote.rs@@ -262,19 +262,20 @@ impl Sessions {pub fn browser_allowed(method: &str, path: &str) -> bool {let seg: Vec<&str> = path.trim_matches('/').split('/').collect();match (method, seg.as_slice()) {- ("GET", ["status" | "setup" | "models" | "upscalers" | "config" | "diagnostics" | "logs" | "jobs" | "events" | "gallery" | "loras" | "luts"]) => true,+ ("GET", ["status" | "setup" | "models" | "upscalers" | "config" | "diagnostics" | "logs" | "jobs" | "events" | "gallery" | "loras" | "luts" | "projects"]) => true,("GET", ["setup", "hardware" | "install" | "legacy-upscalers"]) => true,("GET", ["enhancer", "defaults"]) => true,("GET", ["jobs", _] | ["jobs", _, "wait"]) => true,("GET", ["inputs", _] | ["inputs", _, "image" | "thumb"]) => true,("GET", ["gallery", _] | ["gallery", _, "image" | "thumb" | "original"]) => true,("GET", ["luts", _, "preview"]) => true,+ ("GET" | "PUT" | "DELETE", ["projects", _]) => true,("PUT", ["config"]) => true,("POST", ["setup", "install" | "gpu"] | ["setup", "install", "cancel"]) => true,("POST", ["models", "use" | "vae"]) => true,("POST", ["upscalers", _, "download"]) => true,("POST", ["backend", "start" | "stop" | "restart"]) => true,- ("POST", ["plan" | "jobs" | "inputs" | "examples"]) => true,+ ("POST", ["plan" | "jobs" | "inputs" | "examples"] | ["projects", "import"]) => true,("POST", ["jobs", _, "cancel"]) => true,("POST", ["private", "clear"]) => true,("POST", ["luts", _, "apply"]) => true,@@ -454,6 +455,9 @@ mod tests {("PUT", "/config"),("POST", "/session/heartbeat"),("DELETE", "/gallery/abc"),+ ("GET", "/projects"),+ ("PUT", "/projects/abc"),+ ("POST", "/projects/import"),] {assert!(browser_allowed(m, p), "{m} {p}");}diff --git a/crates/qls-service/src/api.rs b/crates/qls-service/src/api.rsindex 1a7d55e..fea347e 100644--- a/crates/qls-service/src/api.rs+++ b/crates/qls-service/src/api.rs@@ -2,6 +2,7 @@//! engine adapts between the two). On loopback it takes the token (desktop app, MCP, scripts)//! or a signed-in browser; on the network listener only a signed-in browser (see `remote`).+use std::collections::HashSet;use std::convert::Infallible;use std::path::{Path, PathBuf};use std::sync::Arc;@@ -28,6 +29,7 @@ use qls_core::{modelfile::{self, FileInfo, Role, Slot},paths,planner::{GenerationRequest, InpaintAction, Mode, OutpaintSpec, Quality, UpscaleMethod, UpscaleSpec},+ projects::Project,store::{GenerationRecord, ListQuery},};use serde::Deserialize;@@ -115,6 +117,10 @@ pub fn router(state: Arc<AppState>, lan: bool) -> Router {.route("/luts/{name}/preview", get(luts_preview)).route("/luts/{name}/apply", post(luts_apply)).route("/examples", post(install_examples))+ .route("/projects", get(projects_list))+ .route("/projects/import", post(projects_import))+ .route("/projects/{id}", get(projects_get).put(projects_put).delete(projects_delete))+ .route("/projects/{id}/records", get(projects_records)).route("/session/heartbeat", post(heartbeat)).route("/session/release", post(release)).route("/shutdown", post(shutdown))@@ -1155,6 +1161,61 @@ async fn gallery_export(State(s): St, AxPath(id): AxPath<String>, Json(b): Json<}/// Adds the bundled example projects (first launch, or Settings) and lists them.+async fn projects_list(State(s): St) -> Json<Value> {+ Json(json!({ "projects": s.engine.projects.list() }))+}++async fn projects_get(State(s): St, AxPath(id): AxPath<String>) -> ApiResult<Json<Value>> {+ let p = s.engine.projects.get(&id).ok_or_else(|| AppError::new(ErrorCode::NotFound, "No such project."))?;+ Ok(Json(serde_json::to_value(p).unwrap()))+}++/// Every version's record in one answer (a browser opening the project).+async fn projects_records(State(s): St, AxPath(id): AxPath<String>) -> ApiResult<Json<Value>> {+ let engine = s.engine.clone();+ let r = tokio::task::spawn_blocking(move || engine.project_records(&id)).await.map_err(AppError::internal)?;+ let r = r.ok_or_else(|| AppError::new(ErrorCode::NotFound, "No such project."))?;+ Ok(Json(serde_json::to_value(r).unwrap()))+}++#[derive(Deserialize)]+struct ProjectPut {+ project: Project,+ /// The versions this device knew (see `projects.rs`).+ #[serde(default)]+ known: HashSet<String>,+}++/// Saves a device's copy of a project; answers with the merged one.+async fn projects_put(State(s): St, AxPath(id): AxPath<String>, Json(b): Json<ProjectPut>) -> ApiResult<Json<Value>> {+ let engine = s.engine.clone();+ let (p, change) = tokio::task::spawn_blocking(move || engine.projects.put(&id, b.project, &b.known)).await.map_err(AppError::internal)??;+ s.engine.emit_projects(vec![change]);+ Ok(Json(serde_json::to_value(p).unwrap()))+}++async fn projects_delete(State(s): St, AxPath(id): AxPath<String>) -> ApiResult<Json<Value>> {+ let engine = s.engine.clone();+ let key = id.clone();+ let change = tokio::task::spawn_blocking(move || engine.projects.delete(&key, qls_core::engine::now_ms())).await.map_err(AppError::internal)??;+ s.engine.emit_projects(vec![change]);+ Ok(Json(json!({ "deleted": id })))+}++#[derive(Deserialize)]+struct ProjectImport {+ projects: Vec<Project>,+}++/// A device's project list from before 0.11 (its browser storage), merged in once.+async fn projects_import(State(s): St, Json(b): Json<ProjectImport>) -> ApiResult<Json<Value>> {+ let engine = s.engine.clone();+ let changes = tokio::task::spawn_blocking(move || engine.projects.import(b.projects)).await.map_err(AppError::internal)??;+ let n = changes.len();+ s.engine.emit_projects(changes);+ Ok(Json(json!({ "changed": n, "projects": s.engine.projects.list() })))+}+async fn install_examples(State(s): St) -> ApiResult<Json<Value>> {let engine = s.engine.clone();let projects = tokio::task::spawn_blocking(move || engine.install_examples()).await.map_err(AppError::internal)??;diff --git a/docs/engineering-notes.md b/docs/engineering-notes.mdindex c0beb0c..57f808c 100644--- a/docs/engineering-notes.md+++ b/docs/engineering-notes.md@@ -29,6 +29,7 @@ Kokon.exe (Tauri 2 + React) kokon-mcp.exe (MCP, stdio) scripts| `speed.rs` | Per-machine speed calibration of time estimates || `diagnostics.rs` | GPU detection (nvidia-smi, DXGI, sysctl on macOS), readiness checks || `store.rs` | SQLite gallery + content-addressed inputs |+| `projects.rs` | The project list every device shares (`projects.json`): merged saves, tombstones, finished jobs || `paths.rs` | Path validation (no UNC/device/ADS/traversal, never overwrite) || `catalog.rs`, `installer.rs` | Pinned downloads (URLs, sizes, SHA-256), hardware presets, parallel resumable downloader || `config.rs` | Settings and model profiles: the official files (derived from folder + preset) and the user's own files, each recording its model and source |diff --git a/src/App.tsx b/src/App.tsxindex a556c55..c174781 100644--- a/src/App.tsx+++ b/src/App.tsx@@ -5,7 +5,7 @@ import { api, ApiError, configure, setSignedOutHandler } from "./lib/api";import { native } from "./lib/native";import { inBrowser, isNarrow } from "./lib/platform";import {- addExampleProjects, closeStarPrompt, dismissToast, getState, initStarPrompt, redoVersion, refreshLoras, refreshStatus, selectItem, setState, startEvents, startTour, submitComposer, toastError, toastInfo, undoVersion, useStore,+ addExampleProjects, closeStarPrompt, loadProjects, dismissToast, getState, initStarPrompt, redoVersion, refreshLoras, refreshStatus, selectItem, setState, startEvents, startTour, submitComposer, toastError, toastInfo, undoVersion, useStore,} from "./lib/store";import { Composer, importPaths, uploadFiles } from "./components/Composer";import { Login } from "./components/Login";@@ -146,6 +146,8 @@ export default function App() {setSignedOutHandler(() => location.reload());startBrowserHeartbeat();}+ // The project list (shared by every device) before anything adds to it.+ await loadProjects().catch(() => {});startEvents();const cfg = await api.config();const st = await refreshStatus();diff --git a/src/lib/api.ts b/src/lib/api.tsindex 22a09d2..eb54d15 100644--- a/src/lib/api.ts+++ b/src/lib/api.ts@@ -4,6 +4,7 @@// every change carries the CSRF header the service asks for.import { inBrowser } from "./platform";+import type { ProjectData } from "./store";import type {GpuBackend,AppConfig, AppErrorBody, GenerationRecord, GenerationRequest, HardwareReport, InputRecord, InstallStatus, JobView, LoraItem, LutEntry, ModelFileInfo, ModelScan, ModelSlot, ModelsStatus, Plan,@@ -164,6 +165,17 @@ export const api = {applyLut: (name: string, source: string, intensity: number, isPrivate: boolean) =>call<GenerationRecord>(`/luts/${encodeURIComponent(name)}/apply`, { method: "POST", body: json({ source, intensity, private: isPrivate }) }),exportGeneration: (id: string, path: string, original = false) => call<{ path: string }>(`/gallery/${id}/export`, { method: "POST", body: json({ path, overwrite: true, original }) }),+ /** The project list every device shares (crates/qls-core/src/projects.rs). */+ projects: () => call<{ projects: ProjectData[] }>("/projects"),+ project: (id: string) => call<ProjectData>(`/projects/${encodeURIComponent(id)}`),+ /** The records of every version of a project, in one answer; deleted versions are left out. */+ projectRecords: (id: string) =>+ call<{ generations: Record<string, GenerationRecord>; inputs: Record<string, InputRecord> }>(`/projects/${encodeURIComponent(id)}/records`),+ /** `known`: the version keys of the copy last heard from the service; answers with the merged project. */+ saveProject: (id: string, project: ProjectData, known: string[]) => call<ProjectData>(`/projects/${encodeURIComponent(id)}`, { method: "PUT", body: json({ project, known }) }),+ deleteProject: (id: string) => call<{ deleted: string }>(`/projects/${encodeURIComponent(id)}`, { method: "DELETE" }),+ /** This app's list from before 0.11 (browser storage), merged in once. */+ importProjects: (projects: ProjectData[]) => call<{ changed: number }>("/projects/import", { method: "POST", body: json({ projects }) }),/** Browser sign-in (see crates/qls-service/src/remote.rs). */session: () => call<{ signed_in: boolean; password_set: boolean }>("/auth/session"),login: (password: string) => call<{ signed_in: boolean }>("/auth/login", { method: "POST", body: json({ password }) }),diff --git a/src/lib/logic.ts b/src/lib/logic.tsindex db6b83b..1d880c0 100644--- a/src/lib/logic.ts+++ b/src/lib/logic.ts@@ -825,6 +825,33 @@ export function compareBase(g: GenerationRecord): CompareBase | null {return { inputId: r.input_id, rect: { x: 0, y: 0, w: 1, h: 1 } };}+/** Long side of the screen-sized copy kokon-service makes of an image for a browser's stage+ * (`PREVIEW_SIDE` in crates/qls-core/src/store.rs). */+export const PREVIEW_SIDE = 1280;++/** The stage may show the preview instead of the full image: drawn at `w`×`h` CSS px, the image+ * needs no more device pixels than the preview has (an iPhone: 390 CSS px × 3 = 1170). */+export function stageFitsPreview(w: number, h: number, dpr: number): boolean {+ return w > 0 && h > 0 && Math.max(w, h) * (dpr > 0 ? dpr : 1) <= PREVIEW_SIDE;+}++/** Versions to drop after loading a project's records in one answer: the ones the service knew+ * (their key was in its copy, `known`) but sent no record for, i.e. deleted from the gallery.+ * A version it did not know yet (added here, not saved) is looked up on its own instead. */+export function goneVersions(+ items: { key: string; kind: string; genId?: string; inputId?: string }[],+ records: { generations: Record<string, unknown>; inputs: Record<string, unknown> },+ known: string[],+): Set<string> {+ const knew = new Set(known);+ const gone = new Set<string>();+ for (const i of items) {+ const has = i.kind === "gen" && i.genId ? i.genId in records.generations : i.kind === "input" && i.inputId ? i.inputId in records.inputs : true;+ if (!has && knew.has(i.key)) gone.add(i.key);+ }+ return gone;+}+/** Per-pixel change between two equally sized RGBA buffers: the dimmed result in grey with* changed pixels in red (stronger = bigger change). Pixels the "before" does not cover* (alpha 0, e.g. expanded areas) count as changed. Returns the changed share of the image. */diff --git a/src/lib/store.ts b/src/lib/store.tsindex f80b8c3..e4e63a5 100644--- a/src/lib/store.ts+++ b/src/lib/store.ts@@ -9,7 +9,7 @@ import { inBrowser, isNarrow } from "./platform";import { useSyncExternalStore } from "react";import { markFresh } from "../components/Cocoon";import { api, ApiError, setPrivateInputs, subscribe } from "./api";-import { activeLoras, buildRequest, composing, emptyComposer, needsPrompt, newKey, pageOutdated, persistentAdvanced, refFromGen, refFromInput, reviewRequest, starPromptDue, timelineLinks, undoTarget, versionLabels, wantsPromptReview, type CompareMode, type Composer, type Ref } from "./logic";+import { activeLoras, buildRequest, composing, emptyComposer, goneVersions, needsPrompt, newKey, pageOutdated, persistentAdvanced, refFromGen, refFromInput, reviewRequest, starPromptDue, timelineLinks, undoTarget, versionLabels, wantsPromptReview, type CompareMode, type Composer, type Ref } from "./logic";import type { AppErrorBody, GenerationRecord, GenerationRequest, InputRecord, JobView, LoraItem, ServerState, StatusResponse } from "./types";export type Overlay = null | "gallery" | "settings" | "inpaint" | "expand" | "welcome" | "whats-new" | "prompt-tips" | "shortcuts";@@ -134,38 +134,129 @@ interface StoredItem {request?: GenerationRequest;}-interface ProjectData {+export interface ProjectData {meta: ProjectMeta;items: StoredItem[];selected: string | null;/** LoRAs switched on in the project (absent = the ones on by default). */loras?: string[];+ /** The service's revision of it (see crates/qls-core/src/projects.rs). */+ rev?: number;}-const projects: Record<string, ProjectData> = (() => {- try {- const p = JSON.parse(localStorage.getItem(PROJECTS_KEY) || "{}");- return p && typeof p === "object" ? p : {};- } catch {- return {};- }-})();+// The project list lives in kokon-service, shared by every device (0.11). Before, each app+// kept it in its own browser storage: `loadProjects` sends that copy once, then keeps it+// as a backup under BACKUP_KEY.+const projects: Record<string, ProjectData> = {};+const BACKUP_KEY = "qls.projects.v1.backup";const genCache = new Map<string, GenerationRecord>();const inputCache = new Map<string, InputRecord>();+/** Per project, the version keys of the last copy heard from the service: a save sends them,+ * so versions added elsewhere since are kept and the ones removed here are removed there. */+const serverKeys = new Map<string, string[]>();+/** Projects changed here and not saved yet; `edits` counts changes, so a save's answer is not+ * applied over a newer change made while it was on its way. */+const dirty = new Set<string>();+const edits = new Map<string, number>();let saveTimer: number | undefined;-function persistProjects() {++/** What other devices need to hear about (the selection alone is this device's own). */+const content = (p: ProjectData | undefined) => (p ? JSON.stringify([p.items.map((i) => i.key), p.meta.title, p.meta.named, p.loras]) : "");++function persistProjects(ids: string[]) {+ for (const id of ids) {+ dirty.add(id);+ edits.set(id, (edits.get(id) ?? 0) + 1);+ }window.clearTimeout(saveTimer);- saveTimer = window.setTimeout(() => {- const keep: Record<string, ProjectData> = {};- for (const [id, p] of Object.entries(projects)) if (p.items.length || p.meta.named) keep[id] = p;+ saveTimer = window.setTimeout(flushProjects, 300);+}++async function flushProjects() {+ for (const id of [...dirty]) {+ const p = projects[id];+ dirty.delete(id);+ if (!p || !(p.items.length || p.meta.named)) continue;+ const seq = edits.get(id);try {- localStorage.setItem(PROJECTS_KEY, JSON.stringify(keep));- } catch {- /* storage unavailable */+ const merged = await api.saveProject(id, p, serverKeys.get(id) ?? []);+ if (edits.get(id) === seq) await applyProject(merged);+ else serverKeys.set(id, merged.items.map((i) => i.key));+ } catch (e) {+ if (e instanceof ApiError && e.status === 404) dropProject(id);+ // Not reachable: saved again once the connection is back (startEvents).+ else dirty.add(id);}- }, 300);+ }+}++/** A copy from the service: into the list, and into the open project when its versions differ. */+async function applyProject(p: ProjectData) {+ const id = p.meta.id;+ serverKeys.set(id, p.items.map((i) => i.key));+ if (dirty.has(id)) return;+ const old = projects[id];+ projects[id] = { ...p, selected: old?.selected && p.items.some((i) => i.key === old.selected) ? old.selected : p.selected };+ if (id !== state.projectId || state.privateMode) {+ setState({ projects: projectList() });+ return;+ }+ const keys = state.session.map((i) => i.key);+ if (keys.length === p.items.length && keys.every((k, i) => k === p.items[i].key)) {+ setState({ projects: projectList() });+ return;+ }+ const seq = edits.get(id);+ const session = await hydrate(p.items, id);+ // Changed here meanwhile, or another project opened: that change is saved and merged instead.+ if (edits.get(id) !== seq || state.projectId !== id) return;+ const selected = session.some((i) => i.key === state.selected) ? state.selected : (session.at(-1)?.key ?? null);+ setState({ session, selected });+}++/** Removed on another device: out of the list; if it is open, a new project starts. */+function dropProject(id: string) {+ delete projects[id];+ serverKeys.delete(id);+ dirty.delete(id);+ if (id === state.projectId) setState((s) => ({ projectId: newKey(), session: [], selected: null, redo: [], composer: emptyComposer(s.composer), projects: projectList() }));+ else setState({ projects: projectList() });+}++/** Loads the list from the service; the first time, with this app's own list from before 0.11. */+export async function loadProjects() {+ try {+ const raw = localStorage.getItem(PROJECTS_KEY);+ const local = raw ? (JSON.parse(raw) as Record<string, ProjectData>) : null;+ if (local && typeof local === "object") {+ await api.importProjects(Object.values(local));+ localStorage.setItem(BACKUP_KEY, raw!);+ localStorage.removeItem(PROJECTS_KEY);+ }+ } catch {+ /* sent again next start (it stays in storage until the service has it) */+ }+ const { projects: list } = await api.projects();+ const ids = new Set(list.map((p) => p.meta.id));+ for (const id of Object.keys(projects)) if (!ids.has(id) && !dirty.has(id)) delete projects[id];+ for (const p of list) await applyProject(p);+ setState({ projects: projectList() });+}++/** News from the service: a project changed (on this or another device) or was removed. */+async function onProjectEvent(id: string, rev: number, deleted: boolean) {+ if (deleted) {+ if (projects[id] || serverKeys.has(id)) dropProject(id);+ return;+ }+ if ((projects[id]?.rev ?? 0) >= rev) return;+ try {+ await applyProject(await api.project(id));+ } catch {+ /* removed meanwhile: its own event follows */+ }}function projectList(): ProjectMeta[] {@@ -238,15 +329,33 @@ function syncProject(prev: State) {items,selected: state.selected,loras: state.composer.loras ?? undefined,+ rev: old?.rev,};+ // Saved (and heard by the other devices) only when something they show changed.+ if (content(projects[id]) !== content(old)) persistProjects([id]);+ else if (old) projects[id].meta.updatedAt = old.meta.updatedAt;state = { ...state, projects: projectList() };- persistProjects();}-/** Loads the records of a stored project. Versions deleted from the gallery are skipped. */-async function hydrate(items: StoredItem[]): Promise<SessionItem[]> {+/** Loads the records of a stored project. Versions deleted from the gallery are skipped.+ * All of them come in one request (one per version is slow on a phone); against a service+ * without it, or for versions it did not know yet, one request per version. */+async function hydrate(items: StoredItem[], projectId?: string): Promise<SessionItem[]> {+ let gone = new Set<string>();+ const missing = items.some((it) => (it.kind === "gen" && it.genId && !genCache.has(it.genId)) || (it.kind === "input" && it.inputId && !inputCache.has(it.inputId)));+ if (projectId && missing) {+ try {+ const r = await api.projectRecords(projectId);+ for (const g of Object.values(r.generations)) genCache.set(g.id, g);+ for (const i of Object.values(r.inputs)) inputCache.set(i.id, i);+ gone = goneVersions(items, r, serverKeys.get(projectId) ?? []);+ } catch {+ /* an older kokon-service: one request per version below */+ }+ }const out = await Promise.all(items.map(async (it): Promise<SessionItem | null> => {+ if (gone.has(it.key)) return null;try {if (it.kind === "gen" && it.genId) {const g = genCache.get(it.genId) ?? (await api.generation(it.genId));@@ -451,6 +560,7 @@ export function startEvents() {if (loaded) refreshStatus();}else if (ev.type === "gallery") setState((s) => ({ galleryVersion: s.galleryVersion + 1 }));+ else if (ev.type === "projects") onProjectEvent(ev.id, ev.rev, ev.deleted);},(ok) => {setState({ connected: ok });@@ -458,6 +568,8 @@ export function startEvents() {// Catch up on anything missed while disconnected.api.jobs().then((js) => js.forEach(onJob)).catch(() => {});refreshStatus();+ // Changes made elsewhere meanwhile, then this app's own that could not be saved.+ loadProjects().then(flushProjects, () => {});}},);@@ -485,7 +597,9 @@ function onJob(job: JobView) {setState((s) => {const jobs = { ...s.jobs, [job.id]: job };if (job.status !== "done") return { jobs };- const results = job.results.map((g): SessionItem => ({ key: newKey(), kind: "gen", gen: g, jobId: job.id }));+ // Keys from the image ids, the same the service gives them (projects.rs `job_done`), so a+ // result added by both, or by two devices, is one version.+ const results = job.results.map((g): SessionItem => ({ key: `r-${g.id}`, kind: "gen", gen: g, jobId: job.id }));// Replace the pending version with one version per result.const idx = s.session.findIndex((i) => i.jobId === job.id && i.kind === "job");if (idx >= 0) {@@ -512,8 +626,8 @@ function onJob(job: JobView) {const wasSelected = p.selected === p.items[k].key;p.items = [...p.items.slice(0, k), ...stored, ...p.items.slice(k + 1)];if (wasSelected && stored[0]) p.selected = stored[0].key;+ // Shown at once; the service made the same change and saves it (no save from here).p.meta = { ...p.meta, cover: lastCover(p.items), count: countOf(p.items), updatedAt: Date.now() };- persistProjects();return { jobs, projects: projectList() };}// A job from another client (e.g. MCP): track it but do not add it to a project.@@ -642,7 +756,7 @@ export function setProjectLoras(ids: string[]) {const p = projects[state.projectId];if (p && !state.privateMode) {p.loras = ids;- persistProjects();+ persistProjects([p.meta.id]);}}@@ -666,19 +780,22 @@ export async function addExampleProjects(): Promise<string | null> {const { projects: examples } = await api.installExamples();const now = Date.now();let first: string | null = null;+ const added: string[] = [];examples.forEach((ex, i) => {const have = Object.values(projects).find((p) => p.items.some((it) => it.genId === ex.generations[0]));if (have) {first ??= have.meta.id;return;}- const id = newKey();- const items: StoredItem[] = ex.generations.map((g) => ({ key: newKey(), kind: "gen", genId: g }));+ // Ids from the images: two devices adding them at once make the same projects.+ const id = `ex-${ex.generations[0]}`;+ const items: StoredItem[] = ex.generations.map((g) => ({ key: `ex-${g}`, kind: "gen", genId: g }));const updatedAt = now - 60_000 - i * 1000;projects[id] = { meta: { id, title: ex.title, named: true, updatedAt, cover: lastCover(items), count: items.length }, items, selected: items[items.length - 1].key };first ??= id;+ added.push(id);});- persistProjects();+ persistProjects(added);setState({ projects: projectList() });return first;}@@ -714,7 +831,7 @@ export function renameProject(id: string, name: string) {const auto = id === state.projectId ? titleOf(state.session) : null;p.meta = title ? { ...p.meta, title, named: true } : { ...p.meta, title: auto ?? p.meta.title ?? "Untitled", named: false };projects[id] = p;- persistProjects();+ persistProjects([id]);setState({ projects: projectList() });}@@ -725,8 +842,11 @@ export function deleteProject(id: string) {/** Removes projects from the list (their images stay in All images); the open one closes. */export function deleteProjects(ids: string[]) {- for (const id of ids) delete projects[id];- persistProjects();+ for (const id of ids) {+ delete projects[id];+ dirty.delete(id);+ if (serverKeys.delete(id)) api.deleteProject(id).catch(toastError);+ }if (ids.includes(state.projectId)) setState((s) => ({ projectId: newKey(), session: [], selected: null, composer: emptyComposer(s.composer), projects: projectList() }));else setState({ projects: projectList() });}@@ -774,12 +894,14 @@ export async function openGeneration(g: GenerationRecord) {/** A generation was deleted: drop it from every project. */export function forgetGeneration(id: string) {genCache.delete(id);+ const changed: string[] = [];for (const p of Object.values(projects)) {if (!p.items.some((i) => i.genId === id)) continue;p.items = p.items.filter((i) => i.genId !== id);p.meta = { ...p.meta, cover: lastCover(p.items), count: countOf(p.items) };+ changed.push(p.meta.id);}- persistProjects();+ persistProjects(changed);setState((s) => {const session = s.session.filter((i) => i.gen?.id !== id);const refs = s.composer.refs.filter((r) => r.source !== `gen:${id}`);diff --git a/src/lib/types.ts b/src/lib/types.tsindex aaaf8f2..43a3c9d 100644--- a/src/lib/types.ts+++ b/src/lib/types.ts@@ -436,4 +436,5 @@ export interface HardwareReport {export type ServiceEvent =| { type: "job"; job: JobView }| { type: "server"; state: ServerState; owned: boolean; error: AppErrorBody | null }- | { type: "gallery"; id: string; change: "added" | "updated" | "deleted" };+ | { type: "gallery"; id: string; change: "added" | "updated" | "deleted" }+ | { type: "projects"; id: string; rev: number; deleted: boolean };