From f2e5d3f8fa42f9d26b2bbfa273718f85c6b27615 Mon Sep 17 00:00:00 2001 From: yoriswind Date: Mon, 2 Nov 2026 15:12:13 -0800 Subject: [PATCH] Bound staged browser Load Actions selections before reading --- apps/photocraft-web/src/picked_file.rs | 60 ++++++++++++++++++++ apps/photocraft-web/src/web.rs | 31 +++++------ crates/ui-egui/src/dialogs.rs | 8 ++- crates/ui-egui/src/dialogs/filter_dialog.rs | 2 +- crates/ui-egui/src/dialogs/stack_dialog.rs | 15 +++-- crates/ui-egui/src/file_dialog.rs | 7 ++- crates/ui-egui/src/file_dialog/tests.rs | 4 +- crates/ui-egui/src/panels/actions.rs | 26 ++++++++- crates/ui-egui/src/panels/actions/tests.rs | 61 ++++++++++++++++++++- crates/ui-egui/src/smart_svg_ui.rs | 1 + 10 files changed, 183 insertions(+), 32 deletions(-) diff --git a/apps/photocraft-web/src/picked_file.rs b/apps/photocraft-web/src/picked_file.rs index ad183cbc6c..64479576f6 100644 --- a/apps/photocraft-web/src/picked_file.rs +++ b/apps/photocraft-web/src/picked_file.rs @@ -15,6 +15,27 @@ where Ok((name, read().await)) } +/// Preflight every immutable browser size before creating the future that reads any selection. +/// The optional staging budget is separate from the per-file cap enforced by [`read`]. +pub async fn read_contents(sizes: impl IntoIterator, max: Option, read: F) -> Result)>, String> +where + F: FnOnce() -> Fut, + Fut: Future)>, String>>, +{ + if let Some(max) = max { + let total = sizes.into_iter().try_fold(0u64, |sum, size| { + if !size.is_finite() || size < 0.0 || size.fract() != 0.0 || size >= u64::MAX as f64 { + return None; + } + sum.checked_add(size as u64) + }); + if total.is_none_or(|total| total > max) { + return Err(format!("the selected files are larger than {max} bytes or their total size is invalid")); + } + } + read().await +} + #[cfg(test)] mod tests { use super::*; @@ -53,4 +74,43 @@ mod tests { } } } + + /// Check all metadata before even creating the read future, including a late excess and + /// overflowing totals. Huge sizes here are numbers only; the reader returns four tiny bytes. + #[test] + fn contents_budget_preflights_the_entire_selection_before_any_read() { + let cases = [ + (vec![2.0, 2.0], Some(4), true), + (vec![2.0, 3.0], Some(4), false), + (vec![0.0, 0.0], Some(0), true), + (vec![], Some(0), true), + (vec![(512u64 << 20) as f64], Some(512 << 20), true), + (vec![(512u64 << 20) as f64, 1.0], Some(512 << 20), false), + (vec![2f64.powi(63), 2f64.powi(63)], Some(u64::MAX), false), + (vec![2f64.powi(64)], Some(u64::MAX), false), + (vec![f64::NAN], Some(4), false), + (vec![f64::INFINITY], Some(4), false), + (vec![-1.0], Some(4), false), + (vec![0.5], Some(4), false), + (vec![f64::NAN, f64::INFINITY], None, true), + ]; + for (sizes, max, allowed) in cases { + let called = Cell::new(false); + let files = vec![("first.atn".into(), vec![1, 2]), ("last.atn".into(), vec![3, 4])]; + let future = read_contents(sizes, max, || { + assert!(allowed, "no file can be read from a refused selection"); + called.set(true); + std::future::ready(Ok(files.clone())) + }); + let mut future = std::pin::pin!(future); + let Poll::Ready(result) = future.as_mut().poll(&mut Context::from_waker(Waker::noop())) else { panic!("an immediate read") }; + assert_eq!(called.get(), allowed); + assert_eq!(result.is_ok(), allowed); + if allowed { + assert_eq!(result.unwrap(), files, "selection order and payloads are unchanged"); + } else { + assert!(result.unwrap_err().contains("selected files")); + } + } + } } diff --git a/apps/photocraft-web/src/web.rs b/apps/photocraft-web/src/web.rs index c320b67f1a..a28cbddc60 100644 --- a/apps/photocraft-web/src/web.rs +++ b/apps/photocraft-web/src/web.rs @@ -419,7 +419,7 @@ fn services(inbox: Inbox, place_inbox: Inbox, cursor_pos: photocraft_ui_egui::Cu file_dialog: Some(Box::new(|request, _parent, reply| match request { // The browser's file picker hands over the files' contents, not paths. File › Open // asks for several files (`multiple`), each opened in its own tab. - FileDialogRequest::Open { multiple, extensions, max_bytes, .. } => wasm_bindgen_futures::spawn_local(async move { + FileDialogRequest::Open { multiple, extensions, max_bytes, max_contents_bytes, .. } => wasm_bindgen_futures::spawn_local(async move { let dialog = if let Some(exts) = extensions { rfd::AsyncFileDialog::new().add_filter("Supported Files", &exts) } else { @@ -428,24 +428,19 @@ fn services(inbox: Inbox, place_inbox: Inbox, cursor_pos: photocraft_ui_egui::Cu let picked = if multiple { dialog.pick_files().await } else { dialog.pick_file().await.map(|file| vec![file]) }; let answer = match picked { Some(picked) if !picked.is_empty() => { - let mut files = Vec::with_capacity(picked.len()); - let mut error = None; - for file in picked { - // File/Blob size is immutable; reject before rfd creates its ArrayBuffer/Vec. - match crate::picked_file::read(file.file_name(), file.inner().size(), max_bytes, || file.read()).await { - Ok(file) => files.push(file), - Err(why) => { - error = Some(why); - break; - } + let contents = crate::picked_file::read_contents(picked.iter().map(|file| file.inner().size()), max_contents_bytes, || async { + let mut files = Vec::with_capacity(picked.len()); + for file in &picked { + // File/Blob size is immutable; each cap precedes its ArrayBuffer/Vec. + files.push(crate::picked_file::read(file.file_name(), file.inner().size(), max_bytes, || file.read()).await?); } - } - if let Some(why) = error { - Some(FileDialogAnswer::Unavailable(why)) - } else if multiple { - Some(FileDialogAnswer::ContentsMany(files)) - } else { - files.pop().map(|(name, bytes)| FileDialogAnswer::Contents(name, bytes)) + Ok(files) + }) + .await; + match contents { + Err(why) => Some(FileDialogAnswer::Unavailable(why)), + Ok(files) if multiple => Some(FileDialogAnswer::ContentsMany(files)), + Ok(mut files) => files.pop().map(|(name, bytes)| FileDialogAnswer::Contents(name, bytes)), } } _ => None, diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 83ff29f105..a8cc332a59 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -26,7 +26,13 @@ fn browse_field(app: &mut PhotocraftApp, id: u64, fields: &serde_json::Map fill_field(app, id, &key, paths.remove(0)), _ => Err("Install Plug-in reads a .wasm file from disk".into()), diff --git a/crates/ui-egui/src/dialogs/filter_dialog.rs b/crates/ui-egui/src/dialogs/filter_dialog.rs index d052e5f3a5..d023966f7f 100644 --- a/crates/ui-egui/src/dialogs/filter_dialog.rs +++ b/crates/ui-egui/src/dialogs/filter_dialog.rs @@ -1099,7 +1099,7 @@ pub(crate) fn ask_displace_map(app: &mut PhotocraftApp, dialog: u64, command: St use crate::file_dialog::{FileDialogAnswer, FileDialogRequest}; let doc = app.active_doc_id()?; let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files); - app.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions: None, max_bytes: None }, move |app, answer| { + app.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions: None, max_bytes: None, max_contents_bytes: None }, move |app, answer| { let path = match answer { FileDialogAnswer::Paths(paths) => paths.into_iter().next().ok_or("no displacement map was chosen")?, FileDialogAnswer::Unavailable(e) => return Err(e), diff --git a/crates/ui-egui/src/dialogs/stack_dialog.rs b/crates/ui-egui/src/dialogs/stack_dialog.rs index cdbd800633..80eb14502d 100644 --- a/crates/ui-egui/src/dialogs/stack_dialog.rs +++ b/crates/ui-egui/src/dialogs/stack_dialog.rs @@ -98,12 +98,15 @@ fn browse(app: &mut PhotocraftApp, id: u64, folder: bool) { }) } else { let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files); - app.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None }, move |app, answer| { - let FileDialogAnswer::Paths(paths) = answer else { return Err("Load Files into Stack reads files from disk".into()) }; - let d = app.ui.dialog_mut(id).ok_or("the dialog was closed")?; - add(&mut d.fields, paths); - Ok(Value::Null) - }) + app.ask_file( + FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None, max_contents_bytes: None }, + move |app, answer| { + let FileDialogAnswer::Paths(paths) = answer else { return Err("Load Files into Stack reads files from disk".into()) }; + let d = app.ui.dialog_mut(id).ok_or("the dialog was closed")?; + add(&mut d.fields, paths); + Ok(Value::Null) + }, + ) }; if let Err(e) = r.map(|_| ()).or_else(|e| if e == crate::file_dialog::CANCELLED { Ok(()) } else { Err(e) }) { app.ui.status = e; diff --git a/crates/ui-egui/src/file_dialog.rs b/crates/ui-egui/src/file_dialog.rs index e93686642c..3351a56cb9 100644 --- a/crates/ui-egui/src/file_dialog.rs +++ b/crates/ui-egui/src/file_dialog.rs @@ -32,6 +32,9 @@ pub enum FileDialogRequest { extensions: Option>, /// Per-file limit: byte-producing services must check size before reading; consumers recheck. max_bytes: Option, + /// Aggregate staged contents limit; byte-producing services preflight before any read. + /// Path-producing services do not stage payloads and leave this to the contents consumer. + max_contents_bytes: Option, }, /// Which folder to read from. Starts in `initial_dir` when available. Folder { initial_dir: Option }, @@ -250,7 +253,7 @@ impl PhotocraftApp { ) -> Result { let initial_dir = last_used_dir(&self.ui.recent_files); let extensions = (!extensions.is_empty()).then(|| extensions.iter().map(|s| (*s).to_string()).collect()); - self.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions, max_bytes: max }, move |app, answer| { + self.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions, max_bytes: max, max_contents_bytes: None }, move |app, answer| { let (name, bytes) = read_picked(answer, max)?; then(app, name, bytes) }) @@ -259,7 +262,7 @@ impl PhotocraftApp { /// File › Open: opens every chosen file, reporting each failure (see [`Self::open_paths`]). pub fn open_dialog_file(&mut self) -> Result { let initial_dir = last_used_dir(&self.ui.recent_files); - self.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None }, |app, answer| { + self.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None, max_contents_bytes: None }, |app, answer| { match answer { FileDialogAnswer::Paths(paths) => { app.open_paths(&paths); diff --git a/crates/ui-egui/src/file_dialog/tests.rs b/crates/ui-egui/src/file_dialog/tests.rs index 418f899ac7..02076f8497 100644 --- a/crates/ui-egui/src/file_dialog/tests.rs +++ b/crates/ui-egui/src/file_dialog/tests.rs @@ -378,7 +378,7 @@ fn open_starts_in_the_last_used_folder() { menus::invoke(&mut app, &ctx, "file.open", json!({})).unwrap(); app.poll_file_dialog(&ctx, None); assert!( - matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { multiple: true, initial_dir: Some(dir), extensions: None, max_bytes: None }, _)] if dir == "/pics"), + matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { multiple: true, initial_dir: Some(dir), extensions: None, max_bytes: None, max_contents_bytes: None }, _)] if dir == "/pics"), "{:?}", open.borrow().first().map(|(r, _)| r.clone()) ); @@ -1516,7 +1516,7 @@ fn picked_file_limit_refuses_before_callback_and_keeps_other_callers_unchanged() app.pick_file_bytes_filtered(&["atn"], then).unwrap(); } app.poll_file_dialog(&ctx, None); - assert!(matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { max_bytes, .. }, _)] if *max_bytes == max)); + assert!(matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { max_bytes, max_contents_bytes: None, .. }, _)] if *max_bytes == max)); let bounded_path = max.is_some() && matches!(chosen, FileDialogAnswer::Paths(_)); answer(&open, Some(chosen)); app.poll_file_dialog(&ctx, None); diff --git a/crates/ui-egui/src/panels/actions.rs b/crates/ui-egui/src/panels/actions.rs index 6a55b211b1..01f8a0a5d0 100644 --- a/crates/ui-egui/src/panels/actions.rs +++ b/crates/ui-egui/src/panels/actions.rs @@ -558,10 +558,34 @@ fn load_source(app: &mut PhotocraftApp, name: &str, params: Value) -> Result Result { + load_dialog_with_limit(app, MAX_LOAD_CONTENTS_BYTES) +} + +/// Carry the selection budget through the producer and recheck byte-producing custom services. +fn load_dialog_with_limit(app: &mut PhotocraftApp, max_contents_bytes: u64) -> Result { let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files); - app.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: Some(vec!["atn".into()]), max_bytes: None }, |app, answer| { + let request = FileDialogRequest::Open { + multiple: true, + initial_dir, + extensions: Some(vec!["atn".into()]), + max_bytes: None, + max_contents_bytes: Some(max_contents_bytes), + }; + app.ask_file(request, move |app, answer| { + let total = match &answer { + FileDialogAnswer::Contents(_, bytes) => Some(bytes.len() as u64), + FileDialogAnswer::ContentsMany(files) => files.iter().try_fold(0u64, |sum, (_, bytes)| sum.checked_add(bytes.len() as u64)), + _ => Some(0), // Native paths are read one at a time, not staged as contents. + }; + if total.is_none_or(|total| total > max_contents_bytes) { + return Err(format!("the selected files are larger than {max_contents_bytes} bytes or their total size is invalid")); + } let files: Vec<_> = match answer { FileDialogAnswer::Paths(paths) => paths.into_iter().map(|name| (name, None)).collect(), FileDialogAnswer::Contents(name, bytes) => vec![(name, Some(bytes))], diff --git a/crates/ui-egui/src/panels/actions/tests.rs b/crates/ui-egui/src/panels/actions/tests.rs index 0baadd34fc..c2415dec70 100644 --- a/crates/ui-egui/src/panels/actions/tests.rs +++ b/crates/ui-egui/src/panels/actions/tests.rs @@ -26,7 +26,9 @@ fn bulk_load_imports_every_chosen_action_file() { load_dialog(&mut app).unwrap(); app.poll_file_dialog(&egui::Context::default(), None); assert_eq!(app.session.actions.list.iter().map(|a| a.name.as_str()).collect::>(), ["First", "Second"]); - assert!(matches!(asked.borrow().as_slice(), [FileDialogRequest::Open { multiple: true, extensions: Some(ext), .. }] if ext == &["atn"])); + assert!( + matches!(asked.borrow().as_slice(), [FileDialogRequest::Open { multiple: true, extensions: Some(ext), max_bytes: None, max_contents_bytes: Some(MAX_LOAD_CONTENTS_BYTES), .. }] if ext == &["atn"]) + ); assert!(!app.file_dialog_open()); assert!(!app.ui.status_error, "{}", app.ui.status); } @@ -2032,3 +2034,60 @@ fn bulk_load_summary_counts_unsupported_steps_of_surviving_sets() { assert_eq!(names, ["A", "B"]); assert!(app.session.actions.list[0].steps.iter().any(|(id, _)| id == "actions.photoshopStep")); } + +/// Byte-producing providers must stay within the whole-selection budget before the first +/// set is parsed or replaced; exact-size single and multiple selections still import normally. +#[test] +fn bulk_load_rechecks_total_contents_before_importing_any_set() { + use crate::file_dialog::{FileDialogAnswer, FileDialogRequest}; + let first = ("replacement.atn".to_string(), action_set_bytes("Shared", "Replacement")); + let last = ("later.atn".to_string(), action_set_bytes("Other", "Later")); + for multiple in [false, true] { + for allowed in [false, true] { + let total = first.1.len() as u64 + if multiple { last.1.len() as u64 } else { 0 }; + let max = total - u64::from(!allowed); + let answer = if multiple { + FileDialogAnswer::ContentsMany(vec![first.clone(), last.clone()]) + } else { + FileDialogAnswer::Contents(first.0.clone(), first.1.clone()) + }; + let (show, asked) = crate::file_dialog::fake(vec![Some(answer)]); + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services { file_dialog: Some(show), ..Default::default() }); + let mut original = Action::new("Original", vec![]); + original.set = Some("Shared".into()); + app.session.actions.list.push(original); + app.ui.actions.selected = Some(0); + let before = app.session.actions.clone(); + let panel = app.ui.actions.clone(); + let journal = app.session.journal.clone(); + load_dialog_with_limit(&mut app, max).unwrap(); + app.poll_file_dialog(&egui::Context::default(), None); + assert!(matches!(asked.borrow().as_slice(), [FileDialogRequest::Open { max_bytes: None, max_contents_bytes: Some(limit), .. }] if *limit == max)); + assert!(!app.file_dialog_open()); + assert_eq!(app.ui.status_error, !allowed, "{}", app.ui.status); + if allowed { + let names: Vec<_> = app.session.actions.list.iter().map(|a| a.name.as_str()).collect(); + assert_eq!(names, if multiple { vec!["Replacement", "Later"] } else { vec!["Replacement"] }); + } else { + assert!(app.ui.status.contains("selected files"), "{}", app.ui.status); + assert_eq!(app.session.actions, before, "not even the first same-set replacement may run"); + assert_eq!(app.ui.actions, panel); + assert_eq!(app.session.journal, journal); + } + } + } +} + +/// Native path services do not retain a whole selection's payloads in the picker. +#[test] +fn bulk_load_contents_budget_does_not_limit_native_paths() { + use crate::file_dialog::FileDialogAnswer; + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("native.atn"); + std::fs::write(&path, action_set_bytes("Native", "From disk")).unwrap(); + let mut app = disk_app(vec![Some(FileDialogAnswer::Paths(vec![path.to_string_lossy().into_owned()]))]); + load_dialog_with_limit(&mut app, 0).unwrap(); + app.poll_file_dialog(&egui::Context::default(), None); + assert!(!app.ui.status_error, "{}", app.ui.status); + assert_eq!(app.session.actions.list[0].name, "From disk"); +} diff --git a/crates/ui-egui/src/smart_svg_ui.rs b/crates/ui-egui/src/smart_svg_ui.rs index f48d539c25..d783fa0429 100644 --- a/crates/ui-egui/src/smart_svg_ui.rs +++ b/crates/ui-egui/src/smart_svg_ui.rs @@ -227,6 +227,7 @@ fn choose_program(app: &mut PhotocraftApp) -> Result { initial_dir: None, extensions: if cfg!(windows) { Some(vec!["exe".into()]) } else { None }, max_bytes: None, + max_contents_bytes: None, }, move |app, answer| { let crate::file_dialog::FileDialogAnswer::Paths(paths) = answer else { return Err("Choose a local editor executable".into()) };