LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Fix #367: import copies and verifies files on several threads
Claude86deb5b0046f
diff --git a/crates/engine/src/import.rs b/crates/engine/src/import.rsindex 5df949887..5ab462a1f 100644--- a/crates/engine/src/import.rs+++ b/crates/engine/src/import.rs@@ -365,7 +365,7 @@ fn probe_all(probe: Option<&crate::media::FileProbe>, paths: &[String], progress};#[cfg(not(target_arch = "wasm32"))]{- let n = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(4).clamp(1, 8).min(paths.len().max(1));+ let n = workers(paths.len());if n > 1 {let mut results: Vec<Option<Result<ProbeInfo, String>>> = vec![None; paths.len()];let next = std::sync::atomic::AtomicUsize::new(0);@@ -404,18 +404,16 @@ fn probe_all(probe: Option<&crate::media::FileProbe>, paths: &[String], progress.collect()}-/// Copy `src` into `root`/`folders` as `name` (default: its own name), made unique with -1, -2…;-/// returns the new path. The copy is verified ([`crate::import_move::copy_new`]: a new file,-/// synced and checked against `probe_hash`, the content hash the probe computed — or compared-/// byte for byte with the source when there is none); a bad one is removed and the photo-/// reported as failed.-fn copy_into(root: &Path, src: &str, folders: &[String], name: Option<&str>, probe_hash: Option<&str>) -> Result<String, String> {- let dir = folders.iter().fold(root.to_path_buf(), |d, f| d.join(f));+/// Copy `src` into `dir` as `name` (default: its own name), made unique with -1, -2…; returns the+/// new path. The copy is verified ([`crate::import_move::copy_new`]: a new file, synced and+/// checked against `probe_hash`, the content hash the probe computed — or compared byte for byte+/// with the source when there is none); a bad one is removed and the photo reported as failed.+fn copy_into(dir: &Path, src: &str, name: Option<&str>, probe_hash: Option<&str>) -> Result<String, String> {let name = name.map(str::to_string).unwrap_or_else(|| Path::new(src).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "photo".into()));let expect = probe_hash.and_then(lightcraft_preview::Hash128::parse);- crate::import_move::copy_new(Path::new(src), &dir, &name, expect).map(|p| p.to_string_lossy().to_string())+ crate::import_move::copy_new(Path::new(src), dir, &name, expect).map(|p| p.to_string_lossy().to_string())}/// What a [`scan`] needs from the session, so it can run on another thread (a folder on a network@@ -699,8 +697,9 @@ impl ImportJob {}/// The file-system half of importing `paths`: expand folders, skip known paths, probe, skip- /// duplicates by content, read sidecars, copy or place (Move) the files. Nothing in the- /// catalog changes. Stops before the next file once `cancel` is set.+ /// duplicates by content, read sidecars, copy or place (Move) the files — several at once,+ /// with the names and outcomes of one after another. Nothing in the catalog changes. Stops+ /// before the next file once `cancel` is set.pub fn prepare(&mut self, paths: &[String], cancel: &std::sync::atomic::AtomicBool) -> Prepared {let files = self.expand(paths);self.prepare_files(files, cancel)@@ -750,24 +749,39 @@ impl ImportJob {let probed: Vec<Result<ProbeInfo, String>> =cached.into_iter().map(|c| c.map(Ok).unwrap_or_else(|| fresh.next().unwrap_or_else(|| Err("not probed".into())))).collect();crate::memory::release();+ // Files are planned one by one, in order (duplicates, sidecars, names, folders); their+ // copies or moves — the slow part, reading and writing every byte and verifying it — are+ // collected and run on several threads (issue #367), then their outcomes take their places.+ let mut plan = Plan::default();for (path, info) in todo.into_iter().zip(probed) {if cancel.load(Relaxed) {break;}- self.done.fetch_add(1, Relaxed);let mut info = match info {Ok(i) => i,Err(e) => {log::warn!("import {path}: {e}");- out.items.push(PreparedItem::Failed(path, e));+ self.done.fetch_add(1, Relaxed);+ plan.slots.push(Slot::Item(PreparedItem::Failed(path, e)));continue;}};+ // a copy of a file whose transfer is still pending: a duplicate only if that one succeeds+ if !opts.local+ && let Some(h) = &info.content_hash+ && plan.transfers.iter().any(|t| t.info.content_hash.as_ref() == Some(h))+ {+ self.run_plan(&mut plan, &mut out, cancel);+ if cancel.load(Relaxed) {+ break;+ }+ }if let Some(h) = &info.content_hash&& !opts.local&& let Some(existing) = self.by_hash.get(h){- out.items.push(PreparedItem::Duplicate { path, existing: *existing, reason: "content", hash: Some(h.clone()) });+ self.done.fetch_add(1, Relaxed);+ plan.slots.push(Slot::Item(PreparedItem::Duplicate { path, existing: *existing, reason: "content", hash: Some(h.clone()) }));continue;}// the XMP sidecar (or a raw's embedded XMP), read before copying: its capture time files@@ -786,7 +800,6 @@ impl ImportJob {if info.captured.is_none() {info.captured = sidecar.as_ref().and_then(|sc| sc.captured.clone());}- let mut placed = None;let stored = match (mode, &self.copy_root) {(ImportMode::Copy | ImportMode::Move, Some(root))if !crate::import_move::inside(Path::new(&path), root)@@ -803,37 +816,35 @@ impl ImportJob {n});let folders = opts.organize.folders(&q);- if mode == ImportMode::Move && !crate::import_move::is_symlink(Path::new(&path)) {- let dir = folders.iter().fold(root.to_path_buf(), |d, f| d.join(f));- let name = name.unwrap_or(own);- match crate::import_move::place(Path::new(&path), &dir, &name) {- Ok(pl) => {- let dst = pl.dst.to_string_lossy().to_string();- placed = Some(pl);- dst- }- Err(e) => {- out.items.push(PreparedItem::Failed(path, e));- continue;- }+ let dir = folders.iter().fold(root.to_path_buf(), |d, f| d.join(f));+ // the name this file gets depends on what a pending transfer of a like-named file+ // into the same folder ends up with: that one goes first+ let as_named = name.as_deref().unwrap_or(if own.is_empty() { "photo" } else { own.as_str() });+ let family = (dir.to_string_lossy().to_lowercase(), name_family(as_named));+ if plan.transfers.iter().any(|t| t.family == family) {+ self.run_plan(&mut plan, &mut out, cancel);+ if cancel.load(Relaxed) {+ break;}+ }+ let how = if mode == ImportMode::Move && !crate::import_move::is_symlink(Path::new(&path)) {+ How::Place { name: name.unwrap_or(own) }} else {if mode == ImportMode::Move {let reason = "a symbolic link: the file it points to was copied, the link and its target stay";- out.items.push(PreparedItem::Kept(Kept { path: path.clone(), reason: reason.into() }));- }- match copy_into(root, &path, &folders, name.as_deref(), info.content_hash.as_deref()) {- Ok(p) => p,- Err(e) => {- out.items.push(PreparedItem::Failed(path, e));- continue;- }+ plan.slots.push(Slot::Item(PreparedItem::Kept(Kept { path: path.clone(), reason: reason.into() })));}- }+ How::Copy { name }+ };+ // Copy as DNG: the copied raw becomes a DNG (the copy is ours to replace)+ let dng = opts.convert_dng && mode == ImportMode::Copy && raw && !info.format.eq_ignore_ascii_case("DNG");+ plan.slots.push(Slot::Transfer);+ plan.transfers.push(Transfer { path, info, sidecar, dir, how, dng, family });+ continue;}(ImportMode::Move, _) => {let reason = "already inside the destination or the library: added where it is";- out.items.push(PreparedItem::Kept(Kept { path: path.clone(), reason: reason.into() }));+ plan.slots.push(Slot::Item(PreparedItem::Kept(Kept { path: path.clone(), reason: reason.into() })));path.clone()}_ => path.clone(),@@ -841,27 +852,199 @@ impl ImportJob {if let Some(h) = &info.content_hash {self.by_hash.insert(h.clone(), None);}- // Copy as DNG: the copied raw becomes a DNG (the copy is ours to replace)- let mut stored = stored;- if opts.convert_dng- && mode == ImportMode::Copy- && stored != path- && info.kind == MediaKind::Raw- && !info.format.eq_ignore_ascii_case("DNG")+ self.done.fetch_add(1, Relaxed);+ plan.slots.push(Slot::Item(PreparedItem::Ready(Box::new(ReadyFile { path, stored, info, sidecar, placed: None }))));+ }+ self.run_plan(&mut plan, &mut out, cancel);+ out+ }++ /// Run the transfers `plan` collected (on several threads) and append its items to `out` in+ /// file order. Transfers not started because `cancel` was set leave no item.+ fn run_plan(&mut self, plan: &mut Plan, out: &mut Prepared, cancel: &std::sync::atomic::AtomicBool) {+ let mut done = run_transfers(std::mem::take(&mut plan.transfers), self.file_bytes.as_ref(), cancel, &self.done).into_iter();+ for slot in std::mem::take(&mut plan.slots) {+ let item = match slot {+ Slot::Item(it) => it,+ Slot::Transfer => match done.next().flatten() {+ Some(it) => it,+ None => continue,+ },+ };+ if let PreparedItem::Ready(r) = &item+ && let Some(h) = &r.info.content_hash{- match crate::cmd::convert::write_dng_with(self.file_bytes.as_ref(), &stored, String::new()) {- Ok(dng) => {- let _ = std::fs::remove_file(&stored);- stored = dng;- info.format = "DNG".into();+ self.by_hash.insert(h.clone(), None);+ }+ out.items.push(item);+ }+ }+}++/// A batch's items in file order while its transfers are pending ([`ImportJob::run_plan`]).+#[derive(Default)]+struct Plan {+ slots: Vec<Slot>,+ transfers: Vec<Transfer>,+}++enum Slot {+ Item(PreparedItem),+ /// The outcome of the next of [`Plan::transfers`].+ Transfer,+}++/// A file to copy or move into `dir`, planned in order and run on any thread ([`run_transfer`]).+struct Transfer {+ path: String,+ info: ProbeInfo,+ sidecar: Option<crate::sidecar::SidecarData>,+ dir: PathBuf,+ how: How,+ /// Copy as DNG.+ dng: bool,+ /// The folder (lowercase) and [`name_family`]: transfers of one family can take each other's+ /// names, so they never run at the same time.+ family: (String, String),+}++enum How {+ /// A verified copy, under `name` (default: the file's own).+ Copy { name: Option<String> },+ /// Move: placed (linked or copied) without touching the source.+ Place { name: String },+}++/// The names a file called `name` could end up with, as one key: the transfers number a taken name+/// `IMG-1.JPG`, `IMG-2.JPG`…, and Copy as DNG names its DNG `IMG.dng`, `IMG-2.dng`…, so `IMG.JPG`,+/// `IMG-1.jpg` and `img.dng` are all `img` (case-insensitive: so are some file systems).+fn name_family(name: &str) -> String {+ let mut stem = match name.rsplit_once('.') {+ Some((s, _)) if !s.is_empty() => s,+ _ => name,+ };+ while let Some((head, tail)) = stem.rsplit_once('-')+ && !head.is_empty()+ && !tail.is_empty()+ && tail.bytes().all(|b| b.is_ascii_digit())+ {+ stem = head;+ }+ stem.to_lowercase()+}++/// Threads for `jobs` file reads (probes, copies) at once.+#[cfg(not(target_arch = "wasm32"))]+fn workers(jobs: usize) -> usize {+ std::thread::available_parallelism().map(|n| n.get()).unwrap_or(4).clamp(1, 8).min(jobs.max(1))+}++/// Files per batch for a caller that prepares an import in batches ([`ImportJob::prepare_files`]):+/// enough to keep every probe and copy thread busy (a batch waits for its slowest file), few+/// enough that each batch soon joins the catalog.+pub fn batch_size() -> usize {+ #[cfg(not(target_arch = "wasm32"))]+ {+ workers(usize::MAX).saturating_mul(2).clamp(8, 16)+ }+ #[cfg(target_arch = "wasm32")]+ {+ 8+ }+}++/// Run `transfers` (several at once where threads exist); their outcomes in order, `None` for one+/// not started because `cancel` was set. `done` counts each one finished.+fn run_transfers(+ transfers: Vec<Transfer>,+ file_bytes: Option<&crate::merge::ByteReader>,+ cancel: &std::sync::atomic::AtomicBool,+ done: &std::sync::atomic::AtomicUsize,+) -> Vec<Option<PreparedItem>> {+ use std::sync::atomic::Ordering::Relaxed;+ let one = |t: Transfer| {+ if cancel.load(Relaxed) {+ return None;+ }+ let path = t.path.clone();+ // last-resort guard: a panic is this file's failure, not the import's+ let item = crate::guard::catch("import", || run_transfer(t, file_bytes)).unwrap_or_else(|e| PreparedItem::Failed(path, e));+ done.fetch_add(1, Relaxed);+ Some(item)+ };+ #[cfg(not(target_arch = "wasm32"))]+ {+ let n = workers(transfers.len());+ if n > 1 {+ let mut results: Vec<Option<PreparedItem>> = std::iter::repeat_with(|| None).take(transfers.len()).collect();+ let queue = std::sync::Mutex::new(transfers.into_iter().enumerate());+ let out = std::sync::Mutex::new(&mut results);+ // (the tests' injected faults hold for the workers too)+ #[cfg(test)]+ let fault = crate::import_move::injected_fault();+ let work = &|| {+ #[cfg(test)]+ crate::import_move::inject(fault);+ loop {+ let next = queue.lock().unwrap_or_else(std::sync::PoisonError::into_inner).next();+ let Some((i, t)) = next else { break };+ let r = one(t);+ if let Some(slot) = out.lock().unwrap_or_else(std::sync::PoisonError::into_inner).get_mut(i) {+ *slot = r;+ }+ }+ };+ std::thread::scope(|sc| {+ let handles: Vec<_> =+ (0..n).filter_map(|i| std::thread::Builder::new().name(format!("lc-import-copy-{i}")).spawn_scoped(sc, work).ok()).collect();+ if handles.is_empty() {+ // no thread to be had: copy here, one after another+ work();+ }+ for h in handles {+ if h.join().is_err() {+ log::error!("import: a copy worker stopped unexpectedly");}- Err(e) => log::warn!("import {path}: copy as DNG: {e}"),}+ });+ return results;+ }+ }+ transfers.into_iter().map(one).collect()+}++/// Copy or move one planned file (and Copy as DNG); its item.+fn run_transfer(t: Transfer, file_bytes: Option<&crate::merge::ByteReader>) -> PreparedItem {+ let Transfer { path, mut info, sidecar, dir, how, dng, .. } = t;+ let mut placed = None;+ let mut stored = match how {+ How::Place { name } => match crate::import_move::place(Path::new(&path), &dir, &name) {+ Ok(pl) => {+ let dst = pl.dst.to_string_lossy().to_string();+ placed = Some(pl);+ dst+ }+ Err(e) => return PreparedItem::Failed(path, e),+ },+ How::Copy { name } => match copy_into(&dir, &path, name.as_deref(), info.content_hash.as_deref()) {+ Ok(p) => p,+ Err(e) => return PreparedItem::Failed(path, e),+ },+ };+ if dng {+ // decoding the raw twice and encoding it takes several times the file's size in memory+ let weight = usize::try_from(info.file_size).unwrap_or(usize::MAX).saturating_mul(6);+ let _permit = crate::memory::work_gate().acquire(weight);+ match crate::cmd::convert::write_dng_with(file_bytes, &stored, String::new()) {+ Ok(dng) => {+ let _ = std::fs::remove_file(&stored);+ stored = dng;+ info.format = "DNG".into();}- out.items.push(PreparedItem::Ready(Box::new(ReadyFile { path, stored, info, sidecar, placed })));+ Err(e) => log::warn!("import {path}: copy as DNG: {e}"),}- out}+ PreparedItem::Ready(Box::new(ReadyFile { path, stored, info, sidecar, placed }))}/// The catalog half of an import: add the photos [`ImportJob::prepare`] readied (one undoable op;diff --git a/crates/engine/src/import_move.rs b/crates/engine/src/import_move.rsindex 3465eaa7f..db4421369 100644--- a/crates/engine/src/import_move.rs+++ b/crates/engine/src/import_move.rs@@ -56,6 +56,9 @@ pub(crate) enum Fault {Corrupt,/// Removing the source fails (as on a read-only card).FailRemove,+ /// Each copy takes a little longer and notes the thread it ran on ([`copy_threads`]), to see+ /// an import's copies run side by side.+ Slow,}#[cfg(test)]@@ -69,6 +72,21 @@ pub(crate) fn inject(f: Fault) {FAULT.with(|c| c.set(f));}+/// The calling thread's injected fault (tests only), for the workers it starts to inherit.+#[cfg(test)]+pub(crate) fn injected_fault() -> Fault {+ FAULT.with(|c| c.get())+}++/// The threads copies made under [`Fault::Slow`] ran on (tests only).+#[cfg(test)]+static COPY_THREADS: std::sync::Mutex<Vec<std::thread::ThreadId>> = std::sync::Mutex::new(Vec::new());++#[cfg(test)]+pub(crate) fn copy_threads() -> Vec<std::thread::ThreadId> {+ COPY_THREADS.lock().unwrap_or_else(std::sync::PoisonError::into_inner).clone()+}+fn injected(f: Fault) -> bool {#[cfg(test)]{@@ -284,6 +302,11 @@ pub(crate) fn copy_verified(src: &Path, dst: &Path, expect: Option<lightcraft_prreturn Err(io::Error::other("write failed (injected)"));}io::copy(&mut inp, &mut out)?;+ #[cfg(test)]+ if injected(Fault::Slow) {+ COPY_THREADS.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(std::thread::current().id());+ std::thread::sleep(std::time::Duration::from_millis(30));+ }if injected(Fault::Corrupt) {out.write_all(b"!")?;}diff --git a/crates/engine/src/tests_import_move.rs b/crates/engine/src/tests_import_move.rsindex 76ea0a3d6..6a19a5e5a 100644--- a/crates/engine/src/tests_import_move.rs+++ b/crates/engine/src/tests_import_move.rs@@ -433,3 +433,70 @@ fn write_policy_timing() {println!("copy {n} × {} MB: byte compare with the source {bytewise:?}, probe hash {hashed:?}", size >> 20);let _ = std::fs::remove_dir_all(&base);}++/// Issue #367: Import → Copy wrote and verified one file after another on one thread. The copies+/// now run side by side, with the names, order, duplicates and reports a one-by-one copy gives:+/// like-named files take -1, -2… in file order (also against a file already there and a literal+/// `IMG_1-1`), and a file with the content of one copied earlier in the batch is its duplicate+/// (also while that copy is still under way).+#[test]+fn copies_run_side_by_side_with_the_same_outcome() {+ let base = temp_dir("parallel-copy");+ let (card, dest) = (base.join("card"), base.join("out"));+ write_png(&card.join("a/IMG_1.png"), 1);+ write_png(&card.join("a/IMG_2.png"), 2);+ write_png(&card.join("b/IMG_1.png"), 3);+ write_png(&card.join("b/IMG_1-1.png"), 4);+ write_png(&card.join("c/IMG_1.png"), 5);+ for i in 0..8u8 {+ write_png(&card.join(format!("d/p{i}.png")), 10 + i);+ }+ // the content of a file whose copy is still under way+ std::fs::create_dir_all(card.join("e")).unwrap();+ std::fs::copy(card.join("d/p3.png"), card.join("e/dup.png")).unwrap();+ std::fs::create_dir_all(&dest).unwrap();+ std::fs::write(dest.join("IMG_2.png"), b"someone else's file").unwrap();++ let mut s = session();+ inject(Fault::Slow);+ let r = s+ .execute(+ "library.import",+ &json!({"paths": [card.to_string_lossy()], "mode": "copy", "destination": dest.to_string_lossy(), "organize": "flat"}),+ )+ .unwrap();+ inject(Fault::None);+ let threads: std::collections::HashSet<_> = crate::import_move::copy_threads().into_iter().collect();+ if std::thread::available_parallelism().map_or(1, |n| n.get()) > 1 {+ assert!(threads.len() > 1, "copies ran on {} thread(s)", threads.len());+ }++ assert_eq!(len(&r, "imported"), 13, "{r}");+ assert_eq!(len(&r, "failed"), 0, "{r}");+ assert_eq!(len(&r, "duplicates"), 1, "{r}");+ assert_eq!(r["duplicates"][0]["reason"], "content");+ assert!(r["duplicates"][0]["path"].as_str().unwrap().ends_with("dup.png"), "{r}");+ // the order of a one-by-one copy (files in name order), each verified+ let expect = [+ ("a/IMG_1.png", "IMG_1.png"),+ ("a/IMG_2.png", "IMG_2-1.png"),+ ("b/IMG_1-1.png", "IMG_1-1.png"),+ ("b/IMG_1.png", "IMG_1-2.png"),+ ("c/IMG_1.png", "IMG_1-3.png"),+ ];+ for (src, dst) in expect {+ assert_eq!(std::fs::read(dest.join(dst)).unwrap(), std::fs::read(card.join(src)).unwrap(), "{src} → {dst}");+ }+ for i in 0..8 {+ assert_eq!(std::fs::read(dest.join(format!("p{i}.png"))).unwrap(), std::fs::read(card.join(format!("d/p{i}.png"))).unwrap());+ }+ assert_eq!(std::fs::read(dest.join("IMG_2.png")).unwrap(), b"someone else's file");+ assert_eq!(files_under(&dest).len(), 14, "{:?}", files_under(&dest));+ // the duplicate names the photo copied from the same content (d/p3); ids follow the file order+ let ids: Vec<u64> = r["imported"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();+ assert!(ids.windows(2).all(|w| w[0] < w[1]), "{ids:?}");+ assert_eq!(r["duplicates"][0]["existing"], ids[8], "{r}");+ let first = s.catalog.photo(lightcraft_catalog::PhotoId(ids[0])).unwrap();+ assert_eq!(first.file_name, "IMG_1.png");+ let _ = std::fs::remove_dir_all(&base);+}diff --git a/crates/ui-egui/src/headless.rs b/crates/ui-egui/src/headless.rsindex 787e0d1ce..4411c35ac 100644--- a/crates/ui-egui/src/headless.rs+++ b/crates/ui-egui/src/headless.rs@@ -1635,8 +1635,9 @@ mod tests {let _ = std::fs::remove_dir_all(&base);let (src, dest) = (base.join("card"), base.join("out"));std::fs::create_dir_all(&src).unwrap();- for i in 0..10u8 {- let img = lightcraft_raster::Rgba8 { width: 8, height: 8, data: vec![[i * 20, 3, 9, 255]; 64] };+ // more files than a batch holds (see `batch_size`)+ for i in 0..20u8 {+ let img = lightcraft_raster::Rgba8 { width: 8, height: 8, data: vec![[i * 12, 3, 9, 255]; 64] };let png = lightcraft_codecs::encode_png(&lightcraft_codecs::EncodeImage::rgba8(&img), &lightcraft_codecs::EncodeMeta::default()).unwrap();std::fs::write(src.join(format!("IMG_{i:02}.png")), png).unwrap();}@@ -1651,7 +1652,7 @@ mod tests {h.settle(SETTLE);h.step_until(SETTLE, |h| matches!(h.app.ui.dialog, Some(crate::state::Dialog::Import { .. })));let Some(crate::state::Dialog::Import { opts }) = &h.app.ui.dialog else { panic!("no import review") };- assert_eq!(opts.candidates.len(), 10);+ assert_eq!(opts.candidates.len(), 20);for id in ["button:importCopy", "button:importDest"] {let r = h.request("ui.clickWidget", json!({"id": id}), t);assert_eq!(r["ok"], true, "{id}: {r}");@@ -1670,8 +1671,8 @@ mod tests {assert!(h.app.import.is_none(), "finished");let mut names: Vec<String> = std::fs::read_dir(&dest).unwrap().flatten().map(|e| e.file_name().to_string_lossy().to_string()).collect();names.sort();- let want: Vec<String> = (1..=10).map(|i| format!("Trip-{i:02}.png")).collect();- assert_eq!(names, want, "numbered across batches of {}", crate::import::BATCH);+ let want: Vec<String> = (1..=20).map(|i| format!("Trip-{i:02}.png")).collect();+ assert_eq!(names, want, "numbered across batches of {}", lightcraft_engine::import::batch_size());let _ = std::fs::remove_dir_all(&base);}diff --git a/crates/ui-egui/src/import.rs b/crates/ui-egui/src/import.rsindex 0e330722d..143947d55 100644--- a/crates/ui-egui/src/import.rs+++ b/crates/ui-egui/src/import.rs@@ -18,8 +18,10 @@ use crate::render::Slot;use crate::theme::Tokens;use crate::widgets::register;-/// Files per batch (each batch joins the catalog as it is ready, so the progress window updates).-pub(crate) const BATCH: usize = 8;+/// Files per batch in the browser build (each batch joins the catalog as it is ready, so the+/// progress window updates); the desktop's worker uses [`lightcraft_engine::import::batch_size`].+#[cfg(target_arch = "wasm32")]+const BATCH: usize = 8;/// The review dialog's first size (points). It can be resized; the photo grid takes the height.pub(crate) const DIALOG_SIZE: [f32; 2] = [960.0, 720.0];@@ -273,7 +275,7 @@ impl ImportRun {let ctx = ctx.clone();let work = move || {let files = job.expand(&queue);- for chunk in files.chunks(BATCH) {+ for chunk in files.chunks(lightcraft_engine::import::batch_size()) {if cancel.load(Ordering::Relaxed) {break;}