Merge latest upstream main and resolve GNOME Wayland control conflicts

apps/effectcraft-web/src/app.rs

@@ -87,6 +87,17 @@ pub struct WebApp {
 
 impl eframe::App for WebApp {
     fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
+        // Files dropped on the page are input: read them here, where the browser's drop event is
+        // still the current pass's, not from a later (possibly logic-only) tick.
+        //
+        // The list is *taken* out of the raw input: a hidden tab runs `logic` and eframe appends
+        // the same prepared raw input back for the next pass, so leaving the files there would
+        // import them again on every hidden logic tick.
+        let dropped_files = std::mem::take(&mut raw_input.dropped_files);
+        let dropped: Vec<web_sys::File> = dropped_files.iter().filter_map(|f| f.web_file().cloned()).collect();
+        if !dropped.is_empty() {
+            files::read_files(dropped, |paths| post(move |app| open_or_import(app, paths)));
+        }
         self.app.raw_input_hook(ctx, raw_input);
     }
 
@@ -95,18 +106,14 @@ impl eframe::App for WebApp {
         for f in actions {
             f(&mut self.app);
         }
-        // Files dropped on the page: read them, then open/import.
-        let dropped: Vec<web_sys::File> = ctx.input(|i| i.raw.dropped_files.iter().filter_map(|f| f.web_file().cloned()).collect());
-        if !dropped.is_empty() {
-            files::read_files(dropped, |paths| post(move |app| open_or_import(app, paths)));
-        }
-        self.app.logic(ctx, frame);
+        self.app.tick(ctx, frame);
         api::poll_replies();
         // Render Queue outputs written this frame (here or by a worker) → downloads.
         files::flush_downloads();
         // What a reload comes back to.
         if self.persist {
-            persist::snapshot(&self.app.session, ctx.input(|i| i.time), 1.0);
+            // The app's monotonic clock: `ctx.input(|i| i.time)` is stale in a logic-only tick.
+            persist::snapshot(&self.app.session, self.app.now(), 1.0);
         }
         api::set_info("gpu", json!({"compositor": self.app.gpu_adapter(), "viewerOnGpu": self.app.viewer_on_gpu()}));
         api::set_info("frameWorkers", frames::stats());
@@ -114,6 +121,7 @@ impl eframe::App for WebApp {
         let d = &self.app.session.prefs.disk;
         diskcache::configure(d.disk_cache_enabled, d.disk_cache_max_gb, storage::quota());
         api::set_info("diskCache", diskcache::stats());
+        self.app.finish_ime_logic(ctx);
     }
 
     fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
@@ -195,7 +203,9 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
     let home = query_flag("home");
     // Browser storage: settings, recent projects, imported media, saved projects, auto-saves and
     // the last session come back.
-    let t0 = js_sys::Date::now();
+    // Monotonic (performance.now) rather than the wall clock: a system-time jump must not turn
+    // the storage-load report negative or huge.
+    let t0 = web_time::Instant::now();
     let stored = match persist::load(&query_value("storage").unwrap_or_default()).await {
         Ok(n) => n,
         Err(e) => {
@@ -203,7 +213,7 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
             0
         }
     };
-    api::set_info("storage", json!({"backend": persist::backend(), "entries": stored, "loadMs": js_sys::Date::now() - t0}));
+    api::set_info("storage", json!({"backend": persist::backend(), "entries": stored, "loadMs": t0.elapsed().as_secs_f64() * 1000.0}));
     audio::install_unlock();
     browse::restore();
     diskcache::init();
@@ -214,6 +224,7 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
             canvas,
             eframe::WebOptions::default(),
             Box::new(move |cc| {
+                EffectcraftApp::install_ime_reset_hooks(&cc.egui_ctx);
                 CTX.with(|c| *c.borrow_mut() = Some(cc.egui_ctx.clone()));
                 // The page owns this shared presentation device; worker devices retain their
                 // separate owned-device handlers. No browser error-scope future is blocked on.

apps/effectcraft-web/src/browse.rs

@@ -52,7 +52,7 @@ struct State {
 static STATE: LazyLock<Mutex<State>> = LazyLock::new(Mutex::default);
 
 fn state() -> std::sync::MutexGuard<'static, State> {
-    STATE.lock().unwrap_or_else(|e| e.into_inner())
+    STATE.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
 }
 
 /// The web app's Media Browser.

apps/effectcraft-web/src/files.rs

@@ -48,14 +48,14 @@ pub fn list() -> Vec<(String, usize)> {
 
 /// The next write of `path` goes to browser storage only (no download).
 pub fn save_quietly(path: &str) {
-    QUIET.lock().unwrap_or_else(|e| e.into_inner()).push(path.to_string());
+    QUIET.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(path.to_string());
 }
 
 /// A rendered file (from the page's exporter or a worker): kept in the table unpersisted and
 /// downloaded at the next [`flush_downloads`].
 pub fn add_output(path: &str, data: Arc<[u8]>) {
     STORE.put_file(path, data, false);
-    OUTPUTS.lock().unwrap_or_else(|e| e.into_inner()).push(path.to_string());
+    OUTPUTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(path.to_string());
 }
 
 /// The table path for a picked/dropped file name.
@@ -120,7 +120,7 @@ impl Services for WebServices {
     fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
         put(path, data.into());
         let quiet = {
-            let mut q = QUIET.lock().unwrap_or_else(|e| e.into_inner());
+            let mut q = QUIET.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
             let n = q.len();
             q.retain(|p| p != path);
             q.len() != n
@@ -184,7 +184,7 @@ pub fn export_sink() -> Arc<effectcraft_export::Sink> {
 
 /// Download the render outputs written since the last call.
 pub fn flush_downloads() {
-    let paths = std::mem::take(&mut *OUTPUTS.lock().unwrap_or_else(|e| e.into_inner()));
+    let paths = std::mem::take(&mut *OUTPUTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner));
     let mut out: Vec<(String, Arc<[u8]>)> = paths.into_iter().filter_map(|p| get(&p).map(|d| (file_name(&p).to_string(), d))).collect();
     out.sort_by(|a, b| a.0.cmp(&b.0));
     out.dedup_by(|a, b| a.0 == b.0);

apps/effectcraft-web/src/store.rs

@@ -181,7 +181,7 @@ impl Default for Store {
 
 impl Store {
     pub fn lock(&self) -> std::sync::MutexGuard<'_, Mirror> {
-        self.mirror.lock().unwrap_or_else(|e| e.into_inner())
+        self.mirror.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
     }
 
     fn now(&self) -> f64 {

apps/effectcraft/Cargo.toml

@@ -15,7 +15,7 @@ effectcraft-host = { workspace = true }
 effectcraft-ui-egui = { workspace = true }
 egui = { workspace = true }
 # `links`: links (Help menu, Discord, Settings) open in the system browser.
-eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "links", "wayland", "x11"] }
+eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "clipboard", "links", "wayland", "x11"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 # The window's monitors, size and position (src/window.rs), and macOS event-loop options (no app
@@ -51,3 +51,6 @@ objc2-app-kit = { version = "0.3", default-features = false, features = ["std",
 # PhotoCraft and PdfCraft) registers the handler (Objective-C interop needs unsafe, which our
 # workspace forbids) behind a safe API. Pinned exactly: review the diff before bumping.
 fmv-macos-events = "=0.1.0"
+
+[target.'cfg(windows)'.dependencies]
+craft-update = { workspace = true }

apps/effectcraft/src/main.rs

@@ -50,7 +50,7 @@ fn app_icon() -> egui::IconData {
 fn is_project_file(path: &str) -> bool {
     std::path::Path::new(path)
         .extension()
-        .and_then(|ext| ext.to_str())
+        .and_then(std::ffi::OsStr::to_str)
         .is_some_and(|ext| ext.eq_ignore_ascii_case("ecproj") || ext.eq_ignore_ascii_case("ecprojx"))
 }
 
@@ -139,6 +139,11 @@ fn install_file_dialogs(app: &mut EffectcraftApp, ctx: &egui::Context) {
 }
 
 fn main() -> eframe::Result {
+    // Windows: the update helper is a copy of this program started with `--finish-update`.
+    #[cfg(windows)]
+    if let Some(result) = craft_update::self_update::finish(&craft_update::suite::EFFECTCRAFT, &std::env::args_os().skip(1).collect::<Vec<_>>()) {
+        std::process::exit(i32::from(result.is_err()));
+    }
     // First, so the panic hook and every start-up warning are recorded. Records go to stderr
     // and the session log; Help ▸ Enable Logging writes through this logger too, and warnings
     // feed the compatibility report.
@@ -203,6 +208,7 @@ fn main() -> eframe::Result {
         "EffectCraft",
         options,
         Box::new(move |cc| {
+            EffectcraftApp::install_ime_reset_hooks(&cc.egui_ctx);
             match &cc.wgpu_render_state {
                 Some(rs) => log::info!("graphics: {:?}", rs.adapter.get_info()),
                 None => log::info!("graphics: no wgpu device"),
@@ -263,6 +269,7 @@ fn main() -> eframe::Result {
             // reported in a toast and forgotten).
             let _ = session.execute("window.restoreScriptPanels", json!({}));
             let mut app = EffectcraftApp::new(session);
+            app.set_startup_update_check(true);
             app.set_gpu_failure_bridge(gpu_failures);
             app.ui.start_screen = show_home;
             if let Some(n) = notice {
@@ -434,7 +441,8 @@ impl eframe::App for Desktop {
     fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         #[cfg(target_os = "macos")]
         self.menu.update(&mut self.app, ctx);
-        self.app.logic(ctx, frame);
+        self.app.tick(ctx, frame);
+        self.app.finish_ime_logic(ctx);
     }
 
     fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {