LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Merge branch 'worktree-agent-a69dcec0f0c61bc39'
Brandon Thomas9886d4982365
diff --cc apps/lightcraft-web/src/bench.rsindex 90b85af84,efbb71e9c..b1b976bfa--- a/apps/lightcraft-web/src/bench.rs+++ b/apps/lightcraft-web/src/bench.rs@@@ -65,10 -65,10 +65,10 @@@ impl Benchif self.first_frame_ms.is_none() && self.frames > 1 {self.first_frame_ms = Some(now - self.start_ms);}- let idle = app.renderer.queued() == 0;+ let idle = app.renderer.queued() == 0 && app.renderer.in_flight() == 0;match self.phase {Phase::Idle => {- let thumbs = app.renderer.textures.keys().filter(|s| matches!(s, Slot::Thumb(_))).count();+ let thumbs = app.renderer.textures.keys().filter(|s| matches!(s, Slot::Thumb(_) | Slot::ThumbQuick(_))).count();if idle && thumbs > 0 && self.frames > 3 {self.thumbs_done_ms = Some(now - self.start_ms);let first = app.session.visible().first().copied();diff --cc apps/lightcraft-web/src/workers.rsindex 27539f23d,000000000..9f282c164mode 100644,000000..100644--- a/apps/lightcraft-web/src/workers.rs+++ b/apps/lightcraft-web/src/workers.rs@@@ -1,392 -1,0 +1,399 @@@+//! Render workers: dedicated Web Workers, each running a second instance of this wasm module+//! (`worker.js` → [`worker_main`]). The main thread compiles the module once and posts the+//! compiled `WebAssembly.Module` to every worker, so a worker starts in a few milliseconds.+//!+//! This doesn't need wasm threads (shared memory, `+atomics`, a nightly `build-std`), only+//! module workers: the main thread posts a [`WireJob`] as JSON, the worker renders it and+//! transfers the RGBA bytes back (no copy across the boundary).+//!+//! Main side: [`Workers`] implements the UI's [`RenderOffload`]: one job per worker at a time,+//! with affinity (a photo goes back to the worker that already decoded it), the rendered-+//! thumbnail memory cache checked before dispatch, and the thumbnail storage index+//! ([`ThumbIndex`]) kept and pruned here. If no worker comes up, jobs run inline.++use std::cell::RefCell;+use std::collections::HashMap;+use std::rc::Rc;+use std::sync::Arc;++use js_sys::{Array, Object, Reflect, Uint8Array, Uint32Array};+use lightcraft_engine::catalog::PhotoId;+use lightcraft_engine::media::{DISK_CACHE_BYTES, RenderJob, RenderResult, SourceLevel};+use lightcraft_engine::pipeline::Rendered;+use lightcraft_preview::{Hash128, PreviewCache};+use lightcraft_raster::{Histogram, Rgba8};+use lightcraft_ui_egui::render::{RenderOffload, Slot};+use wasm_bindgen::JsCast;+use wasm_bindgen::prelude::*;++use crate::backend::Backend;+use crate::wire::{ThumbIndex, WireJob, WorkerCore, thumb_storage_key};++/// Storage key of the thumbnail index.+pub const THUMB_INDEX: &str = "thumbs/index.json";++fn set(o: &Object, k: &str, v: &JsValue) {+ let _ = Reflect::set(o, &k.into(), v);+}++fn get(o: &JsValue, k: &str) -> JsValue {+ Reflect::get(o, &k.into()).unwrap_or(JsValue::UNDEFINED)+}++fn now() -> f64 {+ let perf = get(&js_sys::global(), "performance");+ let f = get(&perf, "now");+ f.dyn_ref::<js_sys::Function>().and_then(|f| f.call0(&perf).ok()).and_then(|v| v.as_f64()).unwrap_or(0.0)+}++// ---------------------------------------------------------------------------------------------+// worker side++thread_local! {+ static CORE: RefCell<WorkerCore> = RefCell::new(WorkerCore::default());+}++/// Entry point of a render worker (called by `worker.js` after instantiating the module).+/// `store` is the backend kind the page uses ("opfs", "idb" or "memory").+#[wasm_bindgen]+pub fn worker_main(store: String) {+ eframe::WebLogger::init(log::LevelFilter::Info).ok();+ let scope: web_sys::DedicatedWorkerGlobalScope = js_sys::global().unchecked_into();+ // The main thread sends jobs only after "ready", i.e. once storage is open, and one at a time.+ wasm_bindgen_futures::spawn_local(async move {+ let backend = match store.as_str() {+ "memory" => None,+ _ => Backend::open(store == "idb").await.map_err(|e| log::warn!("render worker: no storage ({e})")).ok(),+ };+ let s = scope.clone();+ let onmessage = Closure::<dyn FnMut(web_sys::MessageEvent)>::new(move |e: web_sys::MessageEvent| {+ let (s, b) = (s.clone(), backend.clone());+ wasm_bindgen_futures::spawn_local(async move { handle(&s, b, e.data()).await });+ });+ scope.set_onmessage(Some(onmessage.as_ref().unchecked_ref()));+ onmessage.forget();+ let ready = Object::new();+ set(&ready, "ready", &true.into());+ let _ = scope.post_message(&ready);+ });+}++/// Run one job message and post the result.+async fn handle(scope: &web_sys::DedicatedWorkerGlobalScope, backend: Option<Backend>, msg: JsValue) {+ let id = get(&msg, "id");+ let t0 = now();+ let out = Object::new();+ set(&out, "id", &id);+ let job: Result<WireJob, String> =+ get(&msg, "job").as_string().ok_or("no job".to_string()).and_then(|j| serde_json::from_str(&j).map_err(|e| e.to_string()));+ let mut transfer = Array::new();+ let result: Result<(Rendered, u32), String> = async {+ let job = job?;+ let mut cache_miss = false;+ // cached thumbnail?+ if job.thumb_cached+ && let (Some(b), Some(key)) = (&backend, job.thumb_key())+ {+ match b.read(&key).await.ok().flatten().and_then(|bytes| lightcraft_preview::decode_jpeg(&bytes)) {+ Some(image) => {+ let histogram = Histogram::of_srgb8(&image);+ return Ok((Rendered { image, histogram }, 0));+ }+ None => cache_miss = true,+ }+ }+ set(&out, "cacheMiss", &cache_miss.into());+ let original = match CORE.with(|c| c.borrow_mut().needs_original(&job)) {+ Some(hash) => match &backend {+ Some(b) => b.read(&crate::store::storage_key(&hash)).await?,+ None => None,+ },+ None => None,+ };+ let rendered = CORE.with(|c| c.borrow_mut().render(&job, original.as_deref()))?;+ let mut stored = 0;+ if let (Some(b), Some(key)) = (&backend, job.thumb_key())+ && let Some(jpeg) = lightcraft_preview::encode_jpeg(&rendered.image)+ {+ match b.write(&key, &jpeg).await {+ Ok(()) => stored = jpeg.len() as u32,+ Err(e) => log::warn!("thumbnail cache write: {e}"),+ }+ }+ Ok((rendered, stored))+ }+ .await;+ match result {+ Ok((r, stored)) => {+ let rgba = Uint8Array::from(r.image.as_bytes().as_ref());+ let h = &r.histogram;+ let hist = Uint32Array::new_with_length(4 * 256 + 1);+ for (i, ch) in [&h.r, &h.g, &h.b, &h.luma].into_iter().enumerate() {+ hist.subarray((i * 256) as u32, ((i + 1) * 256) as u32).copy_from(ch);+ }+ hist.set_index(1024, h.total);+ set(&out, "ok", &true.into());+ set(&out, "w", &(r.image.width as u32).into());+ set(&out, "h", &(r.image.height as u32).into());+ set(&out, "rgba", &rgba);+ set(&out, "hist", &hist);+ set(&out, "stored", &stored.into());+ transfer = Array::of2(&rgba.buffer(), &hist.buffer());+ }+ Err(e) => {+ set(&out, "ok", &false.into());+ set(&out, "err", &e.into());+ }+ }+ set(&out, "ms", &(now() - t0).into());+ if let Err(e) = scope.post_message_with_transfer(&out, &transfer) {+ log::error!("render worker: post: {e:?}");+ }+}++// ---------------------------------------------------------------------------------------------+// main side++struct Busy {+ id: u32,+ slot: Slot,+ photo: PhotoId,+ level: SourceLevel,+ key: u64,+ cache: Option<(Arc<PreviewCache>, Hash128)>,+}++struct W {+ worker: web_sys::Worker,+ ready: bool,+ dead: bool,+ busy: Option<Busy>,+}++struct Inner {+ workers: Vec<W>,+ done: Vec<(Slot, RenderResult, f64)>,+ next_id: u32,+ /// (photo, level) → worker that last decoded it.+ affinity: HashMap<(PhotoId, SourceLevel), usize>,+ index: ThumbIndex,+ backend: Option<Backend>,+ ctx: egui::Context,+ /// Jobs finished by workers / inline (for diagnostics).+ remote_done: u64,+ inline_done: u64,+ inline_this_frame: bool,+}++/// The main thread's handle on the render workers.+#[derive(Clone)]+pub struct Workers(Rc<RefCell<Inner>>);++impl Workers {+ /// Start `n` workers (none: every job runs inline). `store` is the backend kind for workers.+ pub fn start(n: usize, store: &str, backend: Option<Backend>, index: ThumbIndex, ctx: egui::Context) -> Workers {+ let w = Workers(Rc::new(RefCell::new(Inner {+ workers: Vec::new(),+ done: Vec::new(),+ next_id: 0,+ affinity: HashMap::new(),+ index,+ backend,+ ctx,+ remote_done: 0,+ inline_done: 0,+ inline_this_frame: false,+ })));+ let module = get(&js_sys::global(), "lightcraftModule");+ if module.is_undefined() {+ log::warn!("render workers: no compiled module on the page (window.lightcraftModule); rendering on the main thread");+ return w;+ }+ for i in 0..n {+ let opts = web_sys::WorkerOptions::new();+ opts.set_type(web_sys::WorkerType::Module);+ opts.set_name(&format!("lightcraft-render-{i}"));+ let worker = match web_sys::Worker::new_with_options("./worker.js", &opts) {+ Ok(x) => x,+ Err(e) => {+ log::warn!("render worker {i}: {e:?}");+ continue;+ }+ };+ let me = w.clone();+ let onmessage = Closure::<dyn FnMut(web_sys::MessageEvent)>::new(move |e: web_sys::MessageEvent| me.on_message(i, e.data()));+ worker.set_onmessage(Some(onmessage.as_ref().unchecked_ref()));+ onmessage.forget();+ let me = w.clone();+ let onerror = Closure::<dyn FnMut(JsValue)>::new(move |e: JsValue| me.on_error(i, e));+ worker.set_onerror(Some(onerror.as_ref().unchecked_ref()));+ onerror.forget();+ let init = Object::new();+ set(&init, "module", &module);+ set(&init, "store", &store.into());+ if let Err(e) = worker.post_message(&init) {+ log::warn!("render worker {i}: {e:?}");+ continue;+ }+ w.0.borrow_mut().workers.push(W { worker, ready: false, dead: false, busy: None });+ }+ w+ }++ fn on_error(&self, i: usize, e: JsValue) {+ let msg = get(&e, "message").as_string().unwrap_or_else(|| format!("{e:?}"));+ log::error!("render worker {i} failed: {msg}");+ let mut g = self.0.borrow_mut();+ if let Some(w) = g.workers.get_mut(i) {+ w.dead = true;+ w.worker.terminate();+ if let Some(b) = w.busy.take() {- let r = RenderResult { photo: b.photo, level: b.level, key: b.key, rendered: Err(msg), loaded: None };++ let r = RenderResult { photo: b.photo, level: b.level, key: b.key, rendered: Err(msg), loaded: None, quick: None };+ g.done.push((b.slot, r, 0.0));+ }+ }+ g.ctx.request_repaint();+ }++ fn on_message(&self, i: usize, data: JsValue) {+ let mut g = self.0.borrow_mut();+ let g = &mut *g;+ g.ctx.request_repaint();+ let Some(w) = g.workers.get_mut(i) else { return };+ if get(&data, "ready").is_truthy() {+ w.ready = true;+ return;+ }+ let id = get(&data, "id").as_f64().unwrap_or(-1.0) as u32;+ let Some(b) = w.busy.take_if(|b| b.id == id) else { return };+ let ms = get(&data, "ms").as_f64().unwrap_or(0.0);+ let rendered = if get(&data, "ok").is_truthy() {+ let (wd, ht) = (get(&data, "w").as_f64().unwrap_or(0.0) as usize, get(&data, "h").as_f64().unwrap_or(0.0) as usize);+ let rgba = Uint8Array::new(&get(&data, "rgba")).to_vec();+ let hist = Uint32Array::new(&get(&data, "hist")).to_vec();+ match Rgba8::from_bytes(wd, ht, &rgba) {+ Some(image) if hist.len() == 1025 => {+ let ch = |k: usize| hist[k * 256..(k + 1) * 256].to_vec();+ let histogram = Histogram { r: ch(0), g: ch(1), b: ch(2), luma: ch(3), total: hist[1024] };+ Ok(Rendered { image, histogram })+ }+ _ => Err("render worker: bad image".to_string()),+ }+ } else {+ Err(get(&data, "err").as_string().unwrap_or_else(|| "render worker failed".into()))+ };+ if let Ok(r) = &rendered+ && let Some((cache, key)) = &b.cache+ {+ cache.put(*key, Arc::new(r.image.clone()));+ let hex = key.to_string();+ let stored = get(&data, "stored").as_f64().unwrap_or(0.0) as u64;+ if get(&data, "cacheMiss").is_truthy() {+ g.index.remove(&hex);+ }+ if stored > 0 {+ g.index.insert(&hex, stored);+ let gone = g.index.prune(DISK_CACHE_BYTES);+ if !gone.is_empty()+ && let Some(be) = g.backend.clone()+ {+ log::info!("thumbnail cache: pruning {} files", gone.len());+ wasm_bindgen_futures::spawn_local(async move {+ for k in gone {+ let _ = be.remove(&thumb_storage_key(&k)).await;+ }+ });+ }+ }+ }+ g.affinity.insert((b.photo, b.level), i);+ g.remote_done += 1;- g.done.push((b.slot, RenderResult { photo: b.photo, level: b.level, key: b.key, rendered, loaded: None }, ms));++ g.done.push((b.slot, RenderResult { photo: b.photo, level: b.level, key: b.key, rendered, loaded: None, quick: None }, ms));+ }++ /// The thumbnail index as JSON if it changed since the last call (the host saves it).+ pub fn take_index_if_dirty(&self) -> Option<Vec<u8>> {+ let mut g = self.0.borrow_mut();+ if !g.index.dirty {+ return None;+ }+ g.index.dirty = false;+ Some(g.index.to_json())+ }++ /// (workers alive, workers ready, jobs done remotely, jobs done inline).+ pub fn stats(&self) -> (usize, usize, u64, u64) {+ let g = self.0.borrow();+ let alive = g.workers.iter().filter(|w| !w.dead).count();+ let ready = g.workers.iter().filter(|w| w.ready && !w.dead).count();+ (alive, ready, g.remote_done, g.inline_done)+ }+}++impl RenderOffload for Workers {+ fn try_start(&mut self, slot: Slot, job: RenderJob) -> Option<RenderJob> {+ let mut g = self.0.borrow_mut();+ let g = &mut *g;+ // rendered thumbnail in memory: no worker needed+ if let Some((cache, key)) = &job.cache+ && let Some(img) = cache.get(*key)+ {+ let image = Arc::unwrap_or_clone(img);+ let histogram = Histogram::of_srgb8(&image);- let r = RenderResult { photo: job.photo, level: job.level, key: job.key, rendered: Ok(Rendered { image, histogram }), loaded: None };++ let r = RenderResult {++ photo: job.photo,++ level: job.level,++ key: job.key,++ rendered: Ok(Rendered { image, histogram }),++ loaded: None,++ quick: None,++ };+ g.done.push((slot, r, 0.0));+ return None;+ }+ if g.workers.iter().all(|w| w.dead) {+ // no workers: render here, one job per frame (as without workers)+ if g.inline_this_frame {+ return Some(job);+ }+ g.inline_this_frame = true;+ let t0 = now();+ let r = job.run();+ g.inline_done += 1;+ g.done.push((slot, r, now() - t0));+ return None;+ }+ let free = |w: &W| w.ready && !w.dead && w.busy.is_none();+ let pick = match g.affinity.get(&(job.photo, job.level)) {+ // a decoded preview-level source, or the loupe's stage cache, is worth waiting for; a+ // thumbnail isn't+ Some(&i) if g.workers.get(i).is_some_and(free) => Some(i),+ Some(&i) if (job.level == SourceLevel::Preview || job.stages.is_some()) && g.workers.get(i).is_some_and(|w| !w.dead) => None,+ _ => g.workers.iter().position(free),+ };+ let Some(i) = pick else { return Some(job) };+ // decided here, so the next job for this photo follows even before this one finishes+ g.affinity.insert((job.photo, job.level), i);+ let thumb_cached = job.cache.as_ref().is_some_and(|(_, k)| g.index.touch(&k.to_string()));+ let wire = WireJob::from_job(&job, thumb_cached, &format!("{slot:?}"));+ let Ok(text) = serde_json::to_string(&wire) else { return Some(job) };+ g.next_id = g.next_id.wrapping_add(1);+ let id = g.next_id;+ let msg = Object::new();+ set(&msg, "id", &id.into());+ set(&msg, "job", &text.into());+ let w = &mut g.workers[i];+ if let Err(e) = w.worker.post_message(&msg) {+ log::warn!("render worker {i}: {e:?}");+ return Some(job);+ }+ w.busy = Some(Busy { id, slot, photo: job.photo, level: job.level, key: job.key, cache: job.cache });+ None+ }++ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {+ let mut g = self.0.borrow_mut();+ g.inline_this_frame = false;+ std::mem::take(&mut g.done)+ }+}diff --cc crates/engine/src/media.rsindex 1c0a40704,e506c384b..b1b561e70--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@@ -325,7 -402,59 +411,71 @@@ impl crate::Sessionlet k = Hasher128::new().str(&content_key(&p)).u64(settings.hash64()).u64(b as u64).u64(RENDER_CACHE_VERSION).finish();(self.media.rendered.clone(), k)});- Some(RenderJob { photo: id, level, source, origin: p.source.clone(), info: source_info(&p), settings, request, key, cache, stages: None })- Some(RenderJob { photo: id, level, source, info: source_info(&p), settings, request, key, cache, stages: None, view_cache: None })++ Some(RenderJob {++ photo: id,++ level,++ source,++ origin: p.source.clone(),++ info: source_info(&p),++ settings,++ request,++ key,++ cache,++ stages: None,++ view_cache: None,++ })+ }++ /// Size-independent cache key of a photo's view render (loupe) for its current settings.+ fn view_key(p: &Photo, apply_crop: bool) -> Hash128 {+ Hasher128::new().str(&content_key(p)).str("view").u64(p.develop.hash64()).u64(apply_crop as u64).u64(RENDER_CACHE_VERSION).finish()+ }++ /// The loupe's render job: like [`Self::render_job`], and a full-quality result is kept as the+ /// photo's view preview (memory, and disk with a library) for [`Self::quick_view_job`].+ pub fn loupe_job(&mut self, id: PhotoId, max_w: usize, max_h: usize, apply_crop: bool) -> Option<RenderJob> {+ let mut job = self.render_job(id, max_w, max_h, false, apply_crop)?;+ let p = self.catalog.photo(id)?;+ job.view_cache = Some((self.media.rendered.clone(), Self::view_key(p, apply_crop)));+ Some(job)+ }++ /// The embedded preview of an unedited raw (path, loader), when the app installed a loader.+ fn embedded_of(&self, p: &Photo) -> Option<(String, PreviewLoader)> {+ match (&p.source, &self.media.preview_loader) {+ (Source::File { path }, Some(l)) if p.kind == MediaKind::Raw && crate::import::has_import_look(p) => Some((path.clone(), l.clone())),+ _ => None,+ }+ }++ /// Something to show in the loupe right away for `id` (see [`QuickJob`]): its cached view+ /// render, else the embedded preview of an unedited raw, else a cached or fresh thumbnail.+ pub fn quick_view_job(&mut self, id: PhotoId, max_edge: usize, apply_crop: bool) -> Option<QuickJob> {+ let p = self.catalog.photo(id)?.clone();+ let small = self.thumb_job(id, THUMB_SIZES[THUMB_SIZES.len() - 1])?;+ // (the thumbnail job itself starts with the cached thumbnail, after the sharper embedded preview)+ let cached = vec![(self.media.rendered.clone(), Self::view_key(&p, apply_crop))];+ let h = Hasher128::new().str(&content_key(&p)).str("quick").u64(p.develop.hash64()).u64(apply_crop as u64).finish();+ let key = h.0 as u64;+ let embedded = self.embedded_of(&p).map(|(path, l)| (path, l, max_edge.clamp(1, SourceLevel::Preview.max_edge())));+ Some(QuickJob { photo: id, key, cached, embedded, small: apply_crop.then(|| Box::new(small)) })+ }++ /// A first grid thumbnail for an unedited raw: the cached render for `job` (the real+ /// thumbnail job, from [`Self::thumb_job`]) if there is one — then the result carries+ /// [`QuickSource::Cached`] and `job.key` and is final — else its embedded preview. `None` for+ /// other photos (render them directly).+ pub fn quick_thumb_job(&mut self, job: &RenderJob) -> Option<QuickJob> {+ let p = self.catalog.photo(job.photo)?.clone();+ let (path, l) = self.embedded_of(&p)?;+ let edge = job.request.max_w.max(job.request.max_h);+ Some(QuickJob {+ photo: job.photo,+ key: job.key,+ cached: job.cache.clone().into_iter().collect(),+ embedded: Some((path, l, edge)),+ small: None,+ })}/// Accept a finished job's loaded source into the cache.diff --cc crates/ui-egui/src/render.rsindex 99815866d,e7f052f5c..3703dcb82--- a/crates/ui-egui/src/render.rs+++ b/crates/ui-egui/src/render.rs@@@ -4,9 -4,13 +4,15 @@@//! image…). Requests are deduplicated per slot (a newer request replaces a queued older one) and//! prioritised (loupe first, then on-screen thumbnails, then prefetch); thumbnails scrolled far//! out of view are dropped from the queue. Thumbnail jobs hit the engine's preview cache (memory +-//! disk) before rendering. On wasm the jobs run inline, one per frame.+//! disk) before rendering. On wasm the jobs run inline, one per frame, unless the host installs a+//! [`RenderOffload`] (the browser build's Web Workers): then queued jobs are handed to it as it has+//! room, and its results are collected every frame.+ //!+ //! Stand-ins ([`QuickJob`]s, once per photo and settings): [`Slot::Preview`] holds what the loupe+ //! shows until [`Slot::Main`] has the photo's render (cached view render, embedded camera JPEG or+ //! a thumbnail render); [`Slot::ThumbQuick`] holds a raw's embedded preview in the grid until its+ //! rendered thumbnail arrives (a cached thumbnail found by the quick job becomes the+ //! [`Slot::Thumb`] texture directly).use std::collections::HashMap;@@@ -131,20 -109,41 +152,53 @@@ impl Rendererself.pool.submit(slot, key, priority, Box::new(move || job.run()));}+ /// Request a stand-in for `slot` (once per job key).+ pub fn request_quick(&mut self, slot: Slot, job: QuickJob, priority: u32) {+ if self.quick_tried.get(&slot) == Some(&job.key) {+ return;+ }+ self.quick_tried.insert(slot, job.key);+ self.pending.insert(slot, (job.key, priority));+ let key = job.key;+ self.pool.submit(slot, key, priority, Box::new(move || job.run()));+ }++ /// Prepare a photo in the background (a [`Slot::Prefetch`] job runs once per key; a newer one+ /// replaces it while queued). Memory stays bounded by the engine's source caches.+ pub fn prefetch(&mut self, slot: Slot, job: RenderJob, priority: u32) {+ if self.prefetched.get(&slot) == Some(&job.key) {+ return;+ }+ self.prefetched.insert(slot, job.key);+ self.pending.insert(slot, (job.key, priority));+ let key = job.key;+ self.pool.submit(slot, key, priority, Box::new(move || job.run()));+ }++ /// Is a request for `slot` queued or running?+ pub fn is_pending(&self, slot: Slot) -> bool {+ self.pending.contains_key(&slot)+ }++ /// The texture to show for a grid/filmstrip thumbnail: the rendered one, else its stand-in.+ pub fn thumb(&self, id: PhotoId) -> Option<&Tex> {+ self.textures.get(&Slot::Thumb(id)).or_else(|| self.textures.get(&Slot::ThumbQuick(id)))+ }+pub fn queued(&self) -> usize {- self.pool.queued()+ self.pool.queued() + self.queue.len()+ }++ /// Hand queued jobs to the offload (best first) while it has room.+ fn dispatch(&mut self) {+ let Some(off) = self.offload.as_mut() else { return };+ while let Some(i) = self.queue.iter().enumerate().max_by_key(|(_, q)| (q.priority, q.seq)).map(|(i, _)| i) {+ let q = self.queue.swap_remove(i);+ if let Some(job) = off.try_start(q.slot, q.job) {+ self.queue.push(Queued { job, ..q });+ break;+ }+ }}/// Requests queued or running.@@@ -168,16 -167,9 +222,16 @@@};#[cfg(not(target_arch = "wasm32"))]let inline_ms = 0.0;- let mut changed = false;+ let mut finished = Vec::new();while let Some(done) = self.pool.try_recv() {- let (mut slot, r, ms) = (done.slot, done.result, if done.ms > 0.0 { done.ms } else { inline_ms });+ finished.push((done.slot, done.result, if done.ms > 0.0 { done.ms } else { inline_ms }));+ }+ if let Some(off) = self.offload.as_mut() {+ finished.extend(off.finished());+ }+ self.dispatch();+ let mut changed = false;- for (slot, r, ms) in finished {++ for (mut slot, r, ms) in finished {session.accept(&r);self.completed += 1;if self.pending.get(&slot).is_some_and(|p| p.0 == r.key) {@@@ -233,16 -250,9 +312,17 @@@});for s in dropped {self.pending.remove(&s);+ self.quick_tried.remove(&s);}+ let pending = &mut self.pending;+ self.queue.retain(|q| match q.slot {+ Slot::Thumb(id) if !keep.contains(&id) && q.priority <= 10 => {+ pending.remove(&q.slot);+ false+ }+ _ => true,+ });- let thumbs = self.textures.keys().filter(|s| matches!(s, Slot::Thumb(_))).count();+ let thumbs = self.thumb_textures();if thumbs <= max {return;}