EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
UI.9: retain shared docking across upstream workspace changes
skylar taylor-barrick83ae6218ef31
diff --cc ROADMAP.mdindex 560ced571,26c39b794..aa363bea5--- a/ROADMAP.md+++ b/ROADMAP.md@@@ -1,11 -1,130 +1,134 @@@- # Roadmap+ # EffectCraft Roadmap+ **Stage: alpha** · next: beta, ~30 points of "ready for real work" and ~350–620 h away++ > **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** major (full re-measure against After Effects 2026 26.5; standard progress-docs layout) · **Target:** Adobe After Effects 2026 (26.5.0.89)++ EffectCraft aims to do what After Effects does, with the same panels, menus and behaviour, written+ from scratch in Rust. This page is the one-page summary; the evidence is in+ [docs/target-app-parity.md](docs/target-app-parity.md), the work list in+ [docs/gaps.md](docs/gaps.md), and the plan in [docs/roadmap.md](docs/roadmap.md).++ ## Headline numbers++ | | Value | Kind |+ |---|---|---|+ | **Feature breadth** | **≈ 91%** | Estimated, weighted by area; the self-graded 92-item checklist says ≈ 99% |+ | **Ready for real work** | **≈ 45%** (40–50%) | Estimated; one live fidelity measurement so far |+ | **Mainstream practitioner** | **≈ 47%** | Estimated: the typical motion designer's weekly work ([how](docs/target-app-parity.md#mainstream-practitioner-and-essentials-user)) |+ | **Essentials user** | **≈ 52%** | Estimated: core features only ([how](docs/target-app-parity.md#essentials-user)) |+ | Remaining to **beta** | **≈ 350–620 Opus 5.5 agent-hours** | Estimated |+ | Remaining to **full parity** | **≈ 850–1,500 Opus 5.5 agent-hours** | Estimated; ≈ 70% parallelises |++ | Audience | Ready % | Hours to ~95% | Work that dominates |+ |---|---:|---:|---|+ | Full target | ≈ 45% | ≈ 850–1,500 h | `.aep`, fidelity corpus, bug backlog, performance, formats, hardware, localization |+ | Mainstream practitioner | ≈ 47% | ≈ 280–530 h | `.aep` exchange, stability, everyday fidelity and bugs, preview speed |+ | Essentials user | ≈ 52% | ≈ 150–300 h | Opening tutorial `.aep` files, start-up stability, core bugs, preview with sound |++ About 60–70% of these hours parallelise ([detail](docs/target-app-parity.md#readiness-by-audience)).++ Hours are one Opus 5.5 agent working sequentially, calibrated on this repository's history+ ([how](docs/target-app-parity.md#calibration-of-the-hours)).++ ### Stage++ **Alpha**, because all six core workflows of the [alpha gate](docs/roadmap.md#alpha-gate)+ (set up, animate, text and shapes, composite, preview, save and deliver) work end to end on macOS+ and the work saves and reopens, and ready for real work (≈ 45%) is above the ≈ 40% bar. But: After Effects projects (`.aep`) can't be opened, which+ alone rules out beta; fidelity against After Effects is measured for one narrow case (scalar ease,+ 168 samples); 134 issues are open, eight of them crash reports. Beta needs ≈ 75% ready and `.aep`+ opening reliably: the `.aep` owner decision and importer (80–160 h), the fidelity harness and+ P0/P1 corpus (60–100 h), the crash and bug backlog (40–80 h), performance (40–70 h),+ Linux/Windows reliability (30–50 h) and depth in animation, masks, effects and text (100–160 h).++ ## By dimension++ | Dimension | % | Hours | Doc |+ |---|---:|---:|---|+ | Features: breadth | 91% | — | [target-app-parity.md](docs/target-app-parity.md#by-feature-area) |+ | Features: ready for real work | 50% | 360–660 | [target-app-parity.md](docs/target-app-parity.md#by-feature-area) |+ | UI/UX fidelity | 65% | 60–120 | [ui-parity.md](docs/ui-parity.md) |+ | File formats | 50% | 130–230 | [file-format-parity.md](docs/file-format-parity.md) |+ | Hardware | 40% | 60–120 | [hardware-parity.md](docs/hardware-parity.md) |+ | Localization | 12% | 60–110 + review | [localization-parity.md](docs/localization-parity.md) |+ | Performance | 35% | 50–100 | [gaps.md](docs/gaps.md#g5-performance-at-real-world-scale) |+ | Stability | 45% | 40–80 | [gaps.md](docs/gaps.md#g3-stability-and-a-green-main) |+ | Platforms | 65% | 30–60 | [gaps.md](docs/gaps.md#g2-real-user-reliability-on-every-platform) |+ | Ecosystem and plug-ins | 20% | 40–80 | [plugins.md](docs/plugins.md), [scripting-parity.md](docs/scripting-parity.md) |+ | AI features | 35% | 40–80 | [gaps.md](docs/gaps.md) |+ | Agent control (beyond After Effects) | ahead | — | [agents.md](docs/agents.md) |++ ## Features++ | Area | Breadth | Ready | Hours |+ |---|---:|---:|---:|+ | Project, footage and import | 92% | 55% | 25–45 |+ | Compositions, layers and compositing | 98% | 60% | 30–55 |+ | Animation: keyframes, graph editor, motion paths, puppet | 97% | 55% | 35–60 |+ | Expressions and scripting ([detail](docs/scripting-parity.md)) | 93% | 65% | 20–40 |+ | Shapes, masks and roto | 93% | 45% | 30–50 |+ | Text and typography | 94% | 50% | 20–35 |+ | Effects and animation presets ([detail](docs/effects-parity.md)) | 85% | 40% | 70–130 |+ | 3D (Classic and Advanced) | 82% | 35% | 35–65 |+ | Tracking and AI-assisted tools | 80% | 35% | 35–70 |+ | Preview and cache | 92% | 40% | 25–50 |+ | Render queue and export | 85% | 55% | 25–45 |+ | Audio | 85% | 45% | 6–12 |++ Weights and evidence per row: [target-app-parity.md](docs/target-app-parity.md#by-feature-area).++ ## Languages++ UI strings translated out of ≈ 3,900 (detail: [localization-parity.md](docs/localization-parity.md)).++ | Language | Status | % |+ |---|---|---:|+ | English | full | 100% |+ | Simplified Chinese | partial (menus, part of the panels) | 28% |+ | Spanish | menus only | 16% |+ | Hindi | none | 0% |+ | Arabic | none | 0% |+ | French | none | 0% |+ | Portuguese (Brazil) | menus only | 16% |+ | Indonesian | none | 0% |+ | Japanese | partial (menus, part of the panels) | 26% |+ | German | none | 0% |+ | Korean | none | 0% |+ | Vietnamese | none | 0% |++ Also shipped: Traditional Chinese (partial, 28%) and Ukrainian (partial, 26%). No language has had+ native-speaker review.++ ## Upcoming++ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gaps.md).++ | | Next | Hours |+ |---|---|---:|+ | 1 | Fix the open crash reports; run `cargo xtask ci` on every pull request (G3) | 15–30 |+ | 2 | Fidelity harness against After Effects: rendered frames, a corpus case per P0/P1 feature (G1) | 60–100 |+ | 3 | Real-user reliability on Linux and Windows; the open mask, effect, text and 3D bugs (G2) | 100–190 |+ | 4 | `.aep` / `.aepx` import, after the owner's clean-room decision (G4) | 80–160 |+ | 5 | Performance: benchmarks at 1080p / 4K, real-time cached playback, hardware video (G5) | 50–100 |+ | 6 | Localization depth: effect names, all panels, French / German / Korean (G9) | 60–110 |++ Come tell us what matters most to you on [Discord](https://discord.gg/artcraft).++ ## Progress log++ - 2026-10-10: Full parity re-measure against After Effects 2026 26.5 (installed bundle, 26.2–26.5+ release notes, repository counts): breadth ≈ 91%, ready ≈ 45%, stage alpha. Progress docs+ follow the shared standard: `docs/parity.md` became `docs/target-app-parity.md`; new+ `docs/roadmap.md`, `localization-parity.md`, `file-format-parity.md`, `hardware-parity.md`,+ `ui-parity.md`, `effects-parity.md` and `scripting-parity.md`.+ - 2026-10-10: Spanish (#460) and Brazilian Portuguese (#217) menu translations.- 2026-10-10: Japanese now translates the interface below the menu bar too: `crates/ui-egui/src/i18n/ui.rs` has a Japanese table with the same 396 rows as the Chinese ones (panels, dialogs, buttons and tooltips; the shape test keeps the three catalogs listing the same source strings). Menus were already Japanese.- 2026-10-09: Ukrainian now covers all 396 current panel-catalog strings, including dialogs, buttons and tooltips, alongside its menu translation. The catalog keeps the same source keys and placeholder counts as the Chinese catalogs; missing or engine-generated text still falls back to English.++- UI.6: Viewer breadcrumbs use theme colors for readable active text. The bottom control row scrolls horizontally at compact widths; keyboard focus reveals the selected control while dropdowns, exposure adjustments and snapshot holds retain their behavior.+- UI.3: Shared docking transactions and pointer targets now handle panel moves, splits, tab ordering and floating groups, preserving accordion metadata and the saved workspace schema. Dock dividers use bounded shared geometry and keyboard-accessible resize handles. Tiny layouts no longer reach an invalid floating-point clamp; workspace trees and saved layouts are retained.+- 2026-10-09: Settings ▸ General ▸ Language now translates the interface below the menu bar as well: panels, dialogs, buttons and tooltips read their text through `crates/ui-egui/src/i18n/ui.rs`, keyed by the English source string. Simplified and Traditional Chinese are complete (384 strings); Japanese rows can follow in the same file. A test fails when a converted panel gains a hard-coded string, and another keeps the catalog free of unused rows.- 2026-10-08: `effectcraft-cli render --out` resolves a relative path against the working directory, like `--project` (it used the project's folder, which doubled a path that already named it). Render Queue outputs set in a project are unchanged.- 2026-10-08: Long-press a grouped toolbar button to choose its tools, including Horizontal/Vertical Type; releasing the hold keeps the menu open. Existing point/paragraph text creation is unchanged.diff --cc crates/ui-egui/src/dock.rsindex f2756938a,06b999827..3e8024875--- a/crates/ui-egui/src/dock.rs+++ b/crates/ui-egui/src/dock.rs@@@ -170,20 -168,14 +170,24 @@@ pub enum SplitSizeFixedB(f32),}+impl SplitSize {+ fn shared(self) -> SharedSplitSize {+ match self {+ Self::Ratio(value) => SharedSplitSize::Ratio(value),+ Self::FixedA(value) => SharedSplitSize::FixedFirst(value),+ Self::FixedB(value) => SharedSplitSize::FixedSecond(value),+ }+ }+}+- /// One panel in a [`DockNode::Stack`].- #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+ /// One frame in a [`DockNode::Stack`]: a header with one tab per panel (a panel dropped onto a+ /// stacked panel joins its frame as a tab, as in After Effects).+ #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+ #[serde(from = "StackEntryRepr")]pub struct StackEntry {- pub panel: PanelKind,+ pub panels: Vec<PanelKind>,+ /// The shown tab.+ pub active: usize,pub open: bool,/// Content height when open (set by dragging the gaps); `None` = share the remaining height.pub height: Option<f32>,@@@ -423,17 -462,42 +474,49 @@@ impl DockNode}/// Make `p` the active tab of its group. Returns false if not present.pub fn activate(&mut self, p: PanelKind) -> bool {- crate::dock_shared::apply_tree(self, craft_ui::docking::Action::Activate { panel: p })++ if !crate::dock_shared::valid_tree(self) {++ return false;++ }+ match self {+ DockNode::Split { a, b, .. } => a.activate(p) || b.activate(p),+ DockNode::Tabs { panels, active } => {+ if let Some(i) = panels.iter().position(|x| *x == p) {+ *active = i;+ true+ } else {+ false+ }+ }+ DockNode::Stack { entries } => match entries.iter_mut().find(|e| e.contains(p)) {+ Some(e) => {+ e.show(p);+ e.open = true;+ true+ }+ None => false,+ },+ }}- /// Expand or collapse a stacked panel. Returns false if `p` is not in a stack.+ /// Expand or collapse a stacked panel's frame (showing `p`). Returns false if `p` is not in+ /// a stack.pub fn toggle_stacked(&mut self, p: PanelKind) -> bool {- if crate::dock_shared::encode(self, &[]).is_err() {++ if !crate::dock_shared::valid_tree(self) {+ return false;+ }- let open = !self.is_visible(p);- crate::dock_shared::apply_tree(self, craft_ui::docking::Action::SetStackOpen { panel: p, open })+ match self {+ DockNode::Split { a, b, .. } => a.toggle_stacked(p) || b.toggle_stacked(p),+ DockNode::Tabs { .. } => false,+ DockNode::Stack { entries } => match entries.iter_mut().find(|e| e.contains(p)) {+ Some(e) => {+ e.show(p);+ e.open = !e.open;+ true+ }+ None => false,+ },+ }}+pub fn is_visible(&self, p: PanelKind) -> bool {match self {DockNode::Split { a, b, .. } => a.is_visible(p) || b.is_visible(p),@@@ -443,29 -507,81 +526,87 @@@}/// Close a panel (remove its tab; empty groups collapse their split).pub fn close(&mut self, p: PanelKind) {- crate::dock_shared::close_tree(self, p);++ if !crate::dock_shared::valid_for_close(self) {++ return;++ }+ if let DockNode::Split { a, b, .. } = self {+ a.close(p);+ b.close(p);+ let empty = |n: &DockNode| match n {+ DockNode::Tabs { panels, .. } => panels.is_empty(),+ DockNode::Stack { entries } => entries.is_empty(),+ DockNode::Split { .. } => false,+ };+ if empty(a) {+ *self = (**b).clone();+ } else if empty(b) {+ *self = (**a).clone();+ }+ } else if let DockNode::Tabs { panels, active } = self {+ let shown = panels.get(*active).copied();+ panels.retain(|x| *x != p);+ *active = shown.and_then(|shown| panels.iter().position(|x| *x == shown)).unwrap_or((*active).min(panels.len().saturating_sub(1)));+ } else if let DockNode::Stack { entries } = self {+ for e in entries.iter_mut() {+ let shown = e.shown();+ e.panels.retain(|x| *x != p);+ e.active = shown.and_then(|shown| e.panels.iter().position(|x| *x == shown)).unwrap_or(e.active.min(e.panels.len().saturating_sub(1)));+ }+ entries.retain(|e| !e.panels.is_empty());+ }}/// Add a panel as a tab next to `near` (or into the first group).pub fn open_near(&mut self, p: PanelKind, near: PanelKind) {- if crate::dock_shared::encode(self, &[]).is_err() {++ if !crate::dock_shared::valid_tree(self) {+ return;+ }- let anchor = [near, PanelKind::EffectsPresets, PanelKind::Project].into_iter().find(|panel| self.contains(*panel));- fn in_stack(node: &DockNode, panel: PanelKind) -> bool {- match node {- DockNode::Split { a, b, .. } => in_stack(a, panel) || in_stack(b, panel),- DockNode::Stack { entries } => entries.iter().any(|entry| entry.panel == panel),- DockNode::Tabs { .. } => false,+ if self.contains(p) {+ self.activate(p);+ return;+ }+ fn add(n: &mut DockNode, p: PanelKind, near: PanelKind) -> bool {+ match n {+ DockNode::Split { a, b, .. } => add(a, p, near) || add(b, p, near),+ DockNode::Tabs { panels, active } => {+ if panels.contains(&near) {+ panels.push(p);+ *active = panels.len() - 1;+ true+ } else {+ false+ }+ }+ DockNode::Stack { entries } => match entries.iter().position(|e| e.contains(near)) {+ Some(i) => {+ entries.insert(i + 1, StackEntry::new(p, true, None));+ true+ }+ None => false,+ },}}- // Accordion entries open immediately after their anchor; ordinary tab groups append.- let action = match anchor {- Some(anchor) if !self.contains(p) && in_stack(self, anchor) => {- craft_ui::docking::Action::OpenAt { panel: p, anchor, placement: craft_ui::docking::Placement::Split(craft_ui::docking::Zone::Center) }+ fn add_first(n: &mut DockNode, p: PanelKind) -> bool {+ match n {+ DockNode::Split { a, b, .. } => add_first(a, p) || add_first(b, p),+ DockNode::Tabs { panels, active } if !panels.is_empty() => {+ panels.push(p);+ *active = panels.len() - 1;+ true+ }+ DockNode::Stack { entries } if !entries.is_empty() => {+ entries.push(StackEntry::new(p, true, None));+ true+ }+ _ => false,}- _ => craft_ui::docking::Action::Open { panel: p, anchor },- };- crate::dock_shared::apply_tree(self, action);+ }+ if self.panel_count() == 0 {+ // Every panel was closed: there is no anchor, so the panel becomes the whole dock.+ *self = tabs(&[p], 0);+ } else if !add(self, p, near) && !add(self, p, PanelKind::EffectsPresets) && !add(self, p, PanelKind::Project) {+ // None of the anchors is docked (e.g. Minimal with Timeline closed): use the first group.+ add_first(self, p);+ }}}@@@ -531,16 -645,96 +672,99 @@@ pub struct Floatingimpl DockNode {/// Insert panel `p` relative to the group that holds `anchor`: as a tab next to it- /// (Center) or in a new group split off to one side. `p` is removed from its old place- /// first. Returns false (tree unchanged) if `anchor` isn't docked or is `p` itself alone.+ /// (Center) or in a new group split off to one side. In a stack, the group is `anchor`'s+ /// frame: Center adds a tab to that frame and Top / Bottom add a frame above or below it+ /// (#302); Left / Right split the column. `p` is removed from its old place first. Returns+ /// false (tree unchanged) if `anchor` isn't docked or is `p` itself alone.pub fn dock_panel(&mut self, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {- crate::dock_shared::move_in_tree(self, p, anchor, craft_ui::docking::Placement::Split(zone.shared()))- if p == anchor || !self.contains(anchor) {++ if !crate::dock_shared::valid_tree(self) || p == anchor || !self.contains(anchor) {+ return false;+ }+ let before = self.clone();+ self.close(p);+ fn rec(n: &mut DockNode, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {+ let here = match n {+ DockNode::Split { a, b, .. } => return rec(a, p, anchor, zone) || rec(b, p, anchor, zone),+ DockNode::Tabs { panels, .. } => panels.contains(&anchor),+ DockNode::Stack { entries } => entries.iter().any(|e| e.contains(anchor)),+ };+ if !here {+ return false;+ }+ match (zone, &mut *n) {+ (Zone::Center, DockNode::Tabs { panels, active }) => {+ let i = panels.iter().position(|x| *x == anchor).map_or(panels.len(), |i| i + 1);+ panels.insert(i, p);+ *active = i;+ }+ (Zone::Center, DockNode::Stack { entries }) => {+ let Some(e) = entries.iter_mut().find(|e| e.contains(anchor)) else { return false };+ let i = e.panels.iter().position(|x| *x == anchor).map_or(e.panels.len(), |i| i + 1);+ e.panels.insert(i, p);+ e.active = i;+ e.open = true;+ }+ (Zone::Top | Zone::Bottom, DockNode::Stack { entries }) => {+ let Some(i) = entries.iter().position(|e| e.contains(anchor)) else { return false };+ let at = if zone == Zone::Top { i } else { i + 1 };+ entries.insert(at, StackEntry::new(p, true, None));+ }+ (z, node) => {+ let new = tabs(&[p], 0);+ let old = std::mem::replace(node, tabs(&[], 0));+ let vertical = matches!(z, Zone::Top | Zone::Bottom);+ let (a, b) = if matches!(z, Zone::Left | Zone::Top) { (new, old) } else { (old, new) };+ *node = DockNode::Split { vertical, size: SplitSize::Ratio(0.5), a: Box::new(a), b: Box::new(b) };+ }+ }+ true+ }+ if rec(self, p, anchor, zone) {+ true+ } else {+ *self = before;+ false+ }}/// Move panel `p` into the group that holds `anchor` as a tab before `before` (one of that/// group's panels) or last, and show it. False (tree unchanged) if `anchor` isn't docked.pub fn insert_tab(&mut self, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {- crate::dock_shared::move_in_tree(self, p, anchor, craft_ui::docking::Placement::Tab { before })++ if !crate::dock_shared::valid_tree(self) {++ return false;++ }+ if p == anchor || !self.contains(anchor) {+ return false;+ }+ let saved = self.clone();+ self.close(p);+ fn rec(n: &mut DockNode, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {+ match n {+ DockNode::Split { a, b, .. } => rec(a, p, anchor, before) || rec(b, p, anchor, before),+ DockNode::Tabs { panels, active } if panels.contains(&anchor) => {+ let i = before.and_then(|b| panels.iter().position(|x| *x == b)).unwrap_or(panels.len());+ panels.insert(i, p);+ *active = i;+ true+ }+ DockNode::Stack { entries } => {+ // A tab of the anchor's frame.+ let Some(e) = entries.iter_mut().find(|e| e.contains(anchor)) else { return false };+ let i = before.and_then(|b| e.panels.iter().position(|x| *x == b)).unwrap_or(e.panels.len());+ e.panels.insert(i, p);+ e.active = i;+ e.open = true;+ true+ }+ _ => false,+ }+ }+ if rec(self, p, anchor, before) {+ true+ } else {+ *self = saved;+ false+ }}/// Path of the group containing `p` (as in [`Group::path`]; stacks add `sN`).@@@ -572,38 -766,94 +796,44 @@@ pub struct Layout}impl Layout {- /// Undock `p` into a floating group at `rect` (no-op if it is the last docked panel).- pub fn float(&mut self, p: PanelKind, rect: [f32; 4]) -> bool {- if self.root.contains(p) {- if self.root.panel_count() <= 1 {- return false;- }- self.root.close(p);- } else if !self.unfloat(p) {- return false;+ /// Apply a shared transaction without replacing the persisted app schema.+ pub fn apply(&mut self, action: craft_ui::docking::Action<PanelKind>) -> Result<(), String> {+ crate::dock_shared::encode(&self.root, &self.floating)?.validate().map_err(|error| error.to_string())?;+ let moving_to_float = match &action {+ craft_ui::docking::Action::Float { panel, .. } => Some(*panel),+ craft_ui::docking::Action::Move { panel, anchor, .. } if self.floating.iter().any(|group| group.panels.contains(anchor)) => Some(*panel),+ _ => None,+ };+ if moving_to_float.is_some_and(|panel| self.root.contains(panel) && self.root.panel_count() <= 1) {+ return Err("the last docked panel must remain in the workspace".into());}- self.floating.push(Floating { panels: vec![p], active: 0, rect });- true+ crate::dock_shared::apply(self, action)+ }++ /// Undock an existing panel; the final docked panel stays in the workspace.+ pub fn float(&mut self, p: PanelKind, rect: [f32; 4]) -> bool {+ self.apply(craft_ui::docking::Action::Float { panel: p, rect }).is_ok()}- /// Remove `p` from the floating groups (dropping emptied groups). True if it was floating.+ /// Close an existing floating panel and collapse its empty group.pub fn unfloat(&mut self, p: PanelKind) -> bool {- let mut found = false;- for f in &mut self.floating {- if let Some(i) = f.panels.iter().position(|x| *x == p) {- let shown = f.panels.get(f.active).copied();- f.panels.remove(i);- f.active = shown.and_then(|shown| f.panels.iter().position(|x| *x == shown)).unwrap_or(f.active.min(f.panels.len().saturating_sub(1)));- found = true;- }- }- self.floating.retain(|f| !f.panels.is_empty());- found+ crate::dock_shared::unfloat(self, p)}- /// Move `p` (docked or floating) into the group of `anchor` (docked or floating) as a tab- /// before `before` or last: where a tab dragged onto a tab strip lands.+ /// Move or reorder a docked/floating tab through the shared transaction.pub fn insert_tab(&mut self, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {- if p == anchor || before == Some(p) {- return false;- }- if self.floating.iter().any(|f| f.panels.contains(&anchor)) {- if self.root.contains(p) {- if self.root.panel_count() <= 1 {- return false;- }- self.root.close(p);- } else {- self.unfloat(p);- }- // (Removing `p` may have dropped an emptied group: look the anchor up again.)- let Some(f) = self.floating.iter_mut().find(|f| f.panels.contains(&anchor)) else { return false };- let i = before.and_then(|b| f.panels.iter().position(|x| *x == b)).unwrap_or(f.panels.len());- f.panels.insert(i, p);- f.active = i;- return true;- }- if !self.root.contains(anchor) {++ if !crate::dock_shared::valid_tree(&self.root) {+ return false;+ }- // A floating panel isn't in the tree, so insert_tab's removal is a no-op for it.- self.unfloat(p);- self.root.insert_tab(p, anchor, before)+ self.apply(craft_ui::docking::Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Tab { before } }).is_ok()}- /// Dock `p` (docked or floating) next to `anchor`; `anchor` may be floating too (then Center- /// adds a tab to that floating group).+ /// Dock a panel beside an anchor; floating destinations accept tabs only.pub fn dock(&mut self, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {- if p == anchor {- return false;- }- if self.floating.iter().any(|f| f.panels.contains(&anchor)) {- if zone != Zone::Center {- return false;- }- if self.root.contains(p) {- if self.root.panel_count() <= 1 {- return false;- }- self.root.close(p);- } else {- self.unfloat(p);- }- let Some(f) = self.floating.iter_mut().find(|f| f.panels.contains(&anchor)) else { return false };- f.panels.push(p);- f.active = f.panels.len() - 1;- return true;- }- if !self.root.contains(anchor) {++ if !crate::dock_shared::valid_tree(&self.root) {+ return false;+ }- // A floating panel isn't in the tree, so dock_panel's removal is a no-op for it.- self.unfloat(p);- self.root.dock_panel(p, anchor, zone)+ self.apply(craft_ui::docking::Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Split(zone.shared()) }).is_ok()}pub fn contains(&self, p: PanelKind) -> bool {@@@ -745,13 -963,7 +975,15 @@@ fn layout_innery = r.max.y + g;}if let Some((above, below, d)) = drag {- resize_stacked(entries, &bodies, above, below, d);+ let mut proposed = entries.clone();+ resize_stacked(&mut proposed, &bodies, above, below, d);+ for (before, after) in entries.iter().zip(proposed) {- if before.height != after.height {- actions.push(craft_ui::docking::Action::ResizeStack { panel: after.panel, height: after.height });++ if before.height != after.height++ && let Some(panel) = after.shown()++ {++ actions.push(craft_ui::docking::Action::ResizeStack { panel, height: after.height });+ }+ }}}DockNode::Split { vertical, size, a, b } => {@@@ -830,6 -1052,27 +1062,29 @@@ fn stack_bodies(entries: &[StackEntry].collect()}+ /// `v` held to `lo..=hi`, never panicking: when the room is too small for both minimums+ /// (`hi < lo`), `lo` wins; a non-finite `v` gives `lo`.++#[cfg(test)]+ fn clamp_ordered(v: f32, lo: f32, hi: f32) -> f32 {+ let lo = if lo.is_finite() { lo } else { 0.0 };+ let hi = if hi.is_finite() { hi.max(lo) } else { lo };+ if v.is_finite() { v.max(lo).min(hi) } else { lo }+ }++ /// The size of a split's first side in `avail` points (both sides keep 20 pt when there is room).+ /// `f32::clamp` panics when its bounds cross, which a split shorter than 40 pt did (#306).++#[cfg(test)]+ fn split_first(size: SplitSize, avail: f32) -> f32 {+ let avail = if avail.is_finite() { avail.max(0.0) } else { 0.0 };+ let first = match size {+ SplitSize::Ratio(r) => avail * r,+ SplitSize::FixedA(px) => px.min(avail - 20.0),+ SplitSize::FixedB(px) => avail - px.min(avail - 20.0),+ };+ let lo = 20.0_f32.min(avail);+ clamp_ordered(first, lo, avail - 20.0).min(avail)+ }+/// Drag the gap between the open stacked panels `above` and `below` (laid out at `bodies`) by/// `d` points: one grows as much as the other shrinks, neither below [`STACK_MIN`]. The new sizes/// become the panels' heights, except that the last panel without one keeps sharing the rest@@@ -1018,9 -1256,10 +1273,11 @@@ pub fn draw_group_chrome(ui: &mut egui:out.actions.push(DockAction::PanelMenu(*p, mr.left_bottom()));}}+ crate::widgets::focus_outline(ui, &resp, t);if resp.clicked() {- if g.stacked.is_some() {+ // A stacked frame's shown tab expands / collapses it; another tab shows that+ // panel (expanding the frame).+ if g.stacked.is_some() && (k == ai || entries.len() == 1) {out.actions.push(DockAction::ToggleStacked(*p));} else {out.actions.push(activate(e));@@@ -1052,32 -1306,24 +1324,50 @@@ pub fn placeholder(ui: &mut egui::Ui, rmod tests {use super::*;+ /// The original split clamp panicked whenever 0 < available < 40. Run the actual dock+ /// layout without the app's last-resort panic guard so that regression cannot be hidden.+ #[test]+ fn tiny_split_layouts_stay_inside_their_parent() {+ let ctx = egui::Context::default();+ let tokens = Tokens::for_kind(crate::theme::ThemeKind::Dark);+ for extent in [20.0, 0.0, 1.0, 5.0, 15.0, 35.0, 39.9, 40.0, 80.0] {+ for vertical in [false, true] {+ for size in [SplitSize::Ratio(0.5), SplitSize::FixedA(300.0), SplitSize::FixedB(300.0)] {+ let rect = Rect::from_min_size(egui::Pos2::ZERO, egui::Vec2::splat(extent));+ let mut node =+ DockNode::Split { vertical, size, a: Box::new(tabs(&[PanelKind::Project], 0)), b: Box::new(tabs(&[PanelKind::Composition], 0)) };+ let mut groups = vec![];+ let mut registry = crate::automation::Registry::default();+ let mut output = ctx.run_ui(egui::RawInput::default(), |ui| layout(ui, &mut node, rect, &tokens, "", &mut groups, &mut registry));+ output.textures_delta.clear();+ assert_eq!(groups.len(), 2);+ for group in groups {+ assert!(rect.contains_rect(group.rect), "{extent}, {vertical}: {:?}", group.rect);+ assert!(group.rect.width() >= 0.0 && group.rect.height() >= 0.0);+ }+ }+ }+ }+ }++ #[test]+ fn open_near_in_an_empty_dock_makes_the_panel_the_dock() {+ for p in [PanelKind::Composition, PanelKind::Timeline, PanelKind::Project] {+ let mut d = tabs(&[], 0);+ d.open_near(p, PanelKind::EffectsPresets);+ assert!(d.is_visible(p));+ assert_eq!(d.panel_count(), 1);+ }+ }++ #[test]+ fn open_near_without_any_anchor_uses_the_first_group() {+ let mut d = tabs(&[PanelKind::Composition], 0);+ d.open_near(PanelKind::Timeline, PanelKind::EffectsPresets);+ assert!(d.is_visible(PanelKind::Timeline));+ assert_eq!(d.panel_count(), 2);+ }+#[test]fn stacked_panels_toggle_open_close() {use PanelKind::*;diff --cc crates/ui-egui/src/dock_shared.rsindex 4370bd615,000000000..4f090e219mode 100644,000000..100644--- a/crates/ui-egui/src/dock_shared.rs+++ b/crates/ui-egui/src/dock_shared.rs@@@ -1,165 -1,0 +1,312 @@@+//! Convert the persisted workspace schema to shared docking transactions.++use craft_ui::docking::{Action, Floating as SharedFloating, Layout as SharedLayout, Node, Placement, StackEntry as SharedStackEntry};+use craft_ui::layout::{SplitAxis, SplitSize as SharedSplitSize};++use crate::dock::{DockNode, Floating, Layout, PanelKind, SplitSize, StackEntry};++const MAX_DEPTH: usize = 32;+const MAX_NODES: usize = 4096;+const MAX_PANELS: usize = 128;++fn encode_node(node: &DockNode, depth: usize, count: &mut usize) -> Result<Node<PanelKind>, String> {+ *count = count.saturating_add(1);+ if depth > MAX_DEPTH || *count > MAX_NODES {+ return Err("workspace dock tree exceeds supported limits".into());+ }+ Ok(match node {+ DockNode::Tabs { panels, active } => {+ if panels.len() > MAX_PANELS {+ return Err("too many workspace tabs".into());+ }+ Node::Tabs { panels: panels.clone(), active: *active }+ }+ DockNode::Stack { entries } => {+ if entries.len() > MAX_PANELS {+ return Err("too many workspace stack entries".into());+ }- Node::Stack { entries: entries.iter().map(|entry| SharedStackEntry { panel: entry.panel, open: entry.open, height: entry.height }).collect() }++ if entries.iter().any(|entry| entry.panels.is_empty() || entry.active >= entry.panels.len() || entry.panels.len() > MAX_PANELS) {++ return Err("invalid stacked tab selection".into());++ }++ Node::Stack {++ entries: entries++ .iter()++ .flat_map(|entry| entry.panels.iter().map(move |panel| SharedStackEntry { panel: *panel, open: entry.open, height: entry.height }))++ .collect(),++ }+ }+ DockNode::Split { vertical, size, a, b } => Node::Split {+ axis: if *vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal },+ size: match *size {+ SplitSize::Ratio(value) => SharedSplitSize::Ratio(value),+ SplitSize::FixedA(value) => SharedSplitSize::FixedFirst(value),+ SplitSize::FixedB(value) => SharedSplitSize::FixedSecond(value),+ },+ first: Box::new(encode_node(a, depth.saturating_add(1), count)?),+ second: Box::new(encode_node(b, depth.saturating_add(1), count)?),+ },+ })+}++fn decode_node(node: Node<PanelKind>) -> DockNode {+ match node {+ Node::Tabs { panels, active } => DockNode::Tabs { panels, active },+ Node::Stack { entries } => {- DockNode::Stack { entries: entries.into_iter().map(|entry| StackEntry { panel: entry.panel, open: entry.open, height: entry.height }).collect() }++ DockNode::Stack { entries: entries.into_iter().map(|entry| StackEntry::new(entry.panel, entry.open, entry.height)).collect() }+ }+ Node::Split { axis, size, first, second } => DockNode::Split {+ vertical: axis == SplitAxis::Vertical,+ size: match size {+ SharedSplitSize::Ratio(value) => SplitSize::Ratio(value),+ SharedSplitSize::FixedFirst(value) => SplitSize::FixedA(value),+ SharedSplitSize::FixedSecond(value) => SplitSize::FixedB(value),+ },+ a: Box::new(decode_node(*first)),+ b: Box::new(decode_node(*second)),+ },+ }+}++pub(crate) fn encode(root: &DockNode, floating: &[Floating]) -> Result<SharedLayout<PanelKind>, String> {+ if floating.len() > MAX_PANELS || floating.iter().any(|group| group.panels.len() > MAX_PANELS) {+ return Err("too many floating workspace panels".into());+ }+ let root = if matches!(root, DockNode::Tabs { panels, active: 0 } if panels.is_empty()) { None } else { Some(encode_node(root, 0, &mut 0)?) };+ Ok(SharedLayout {+ root,+ floating: floating.iter().map(|group| SharedFloating { panels: group.panels.clone(), active: group.active, rect: group.rect }).collect(),+ })+}++pub(crate) fn decode(layout: SharedLayout<PanelKind>) -> Layout {+ Layout {+ root: layout.root.map(decode_node).unwrap_or_else(|| DockNode::Tabs { panels: vec![], active: 0 }),+ floating: layout.floating.into_iter().map(|group| Floating { panels: group.panels, active: group.active, rect: group.rect }).collect(),+ }+}+++/// Restore app-owned accordion tab frames after shared validation/transactions.++/// The shared model represents individual stack panels; grouping stays in the persisted app schema.++fn restore_frames(node: &mut DockNode, original: &DockNode) {++ fn collect(node: &DockNode, out: &mut Vec<StackEntry>) {++ match node {++ DockNode::Split { a, b, .. } => {++ collect(a, out);++ collect(b, out);++ }++ DockNode::Stack { entries } => out.extend(entries.iter().cloned()),++ DockNode::Tabs { .. } => {}++ }++ }++ fn restore(node: &mut DockNode, frames: &[StackEntry]) {++ match node {++ DockNode::Split { a, b, .. } => {++ restore(a, frames);++ restore(b, frames);++ }++ DockNode::Stack { entries } => {++ let mut result: Vec<StackEntry> = Vec::new();++ for entry in std::mem::take(entries) {++ let Some(panel) = entry.shown() else { continue };++ let old = frames.iter().find(|frame| frame.contains(panel));++ if let Some(last) = result.last_mut()++ && old.is_some_and(|frame| last.panels.iter().all(|p| frame.contains(*p)))++ {++ last.panels.push(panel);++ if old.and_then(StackEntry::shown) == Some(panel) {++ last.active = last.panels.len().saturating_sub(1);++ }++ } else {++ result.push(entry);++ }++ }++ for entry in &mut result {++ if let Some(old) = frames.iter().find(|frame| entry.panels.iter().all(|panel| frame.contains(*panel))) {++ entry.active = old++ .shown()++ .and_then(|shown| entry.panels.iter().position(|panel| *panel == shown))++ .unwrap_or(old.active.min(entry.panels.len().saturating_sub(1)));++ }++ }++ *entries = result;++ }++ DockNode::Tabs { .. } => {}++ }++ }++ let mut frames = Vec::new();++ collect(original, &mut frames);++ restore(node, &frames);++}+++pub(crate) fn apply(layout: &mut Layout, action: Action<PanelKind>) -> Result<(), String> {+ let mut shared = encode(&layout.root, &layout.floating)?;- shared.apply(action).map_err(|error| error.to_string())?;- let proposed = decode(shared);- encode(&proposed.root, &proposed.floating)?;++ // Validate the same shared command first. Native stack insertion then retains tabs inside++ // their accordion frame, including the existing before/after insertion policy.++ shared.apply(action.clone()).map_err(|error| error.to_string())?;++ let mut proposed = decode(shared);++ restore_frames(&mut proposed.root, &layout.root);++ match action {++ Action::Move { panel, anchor, placement } | Action::OpenAt { panel, anchor, placement } if layout.root.contains(anchor) => {++ fn stacked(node: &DockNode, p: PanelKind) -> bool {++ match node {++ DockNode::Split { a, b, .. } => stacked(a, p) || stacked(b, p),++ DockNode::Stack { entries } => entries.iter().any(|e| e.contains(p)),++ _ => false,++ }++ }++ if stacked(&layout.root, anchor) {++ let mut native = layout.clone();++ native.unfloat(panel);++ let applied = match placement {++ Placement::Tab { before } => native.root.insert_tab(panel, anchor, before),++ Placement::Split(zone) => native.root.dock_panel(++ panel,++ anchor,++ match zone {++ craft_ui::docking::Zone::Left => crate::dock::Zone::Left,++ craft_ui::docking::Zone::Right => crate::dock::Zone::Right,++ craft_ui::docking::Zone::Top => crate::dock::Zone::Top,++ craft_ui::docking::Zone::Bottom => crate::dock::Zone::Bottom,++ craft_ui::docking::Zone::Center => crate::dock::Zone::Center,++ },++ ),++ };++ if !applied {++ return Err("stacked panel move failed".into());++ }++ proposed = native;++ }++ }++ Action::Activate { panel } => {++ proposed.root.activate(panel);++ }++ Action::SetStackOpen { panel, open } => {++ fn set(node: &mut DockNode, p: PanelKind, open: bool) {++ match node {++ DockNode::Split { a, b, .. } => {++ set(a, p, open);++ set(b, p, open);++ }++ DockNode::Stack { entries } => {++ if let Some(e) = entries.iter_mut().find(|e| e.contains(p)) {++ e.open = open;++ }++ }++ _ => {}++ }++ }++ set(&mut proposed.root, panel, open);++ }++ Action::ResizeStack { panel, height } => {++ fn set(node: &mut DockNode, p: PanelKind, h: Option<f32>) {++ match node {++ DockNode::Split { a, b, .. } => {++ set(a, p, h);++ set(b, p, h);++ }++ DockNode::Stack { entries } => {++ if let Some(e) = entries.iter_mut().find(|e| e.contains(p)) {++ e.height = h;++ }++ }++ _ => {}++ }++ }++ set(&mut proposed.root, panel, height);++ }++ _ => {}++ }++ encode(&proposed.root, &proposed.floating)?.validate().map_err(|error| error.to_string())?;+ *layout = proposed;+ Ok(())+}++pub(crate) fn apply_tree(root: &mut DockNode, action: Action<PanelKind>) -> bool {- let Ok(mut shared) = encode(root, &[]) else { return false };- if shared.apply(action).is_err() {++ if !valid_tree(root) {+ return false;+ }- let proposed = decode(shared).root;- if encode(&proposed, &[]).is_err() {++ let mut layout = Layout { root: root.clone(), floating: vec![] };++ if apply(&mut layout, action).is_err() {+ return false;+ }- *root = proposed;++ *root = layout.root;+ true+}+- pub(crate) fn move_in_tree(root: &mut DockNode, panel: PanelKind, anchor: PanelKind, placement: Placement<PanelKind>) -> bool {- let Ok(mut shared) = encode(root, &[]) else { return false };- if panel == anchor || !root.contains(anchor) {- return false;- }- // This legacy entry point also opens new viewer/ScriptUI panels. Keep that explicit,- // separate from Move, and commit only once both shared transactions have succeeded.- if !root.contains(panel) && shared.apply(Action::Open { panel, anchor: Some(anchor) }).is_err() {- return false;- }- if shared.apply(Action::Move { panel, anchor, placement }).is_err() {- return false;- }- let proposed = decode(shared).root;- if encode(&proposed, &[]).is_err() {- return false;- }- *root = proposed;- true++pub(crate) fn valid_tree(root: &DockNode) -> bool {++ encode(root, &[]).is_ok_and(|shared| shared.validate().is_ok())+}+- // Legacy close methods repair selection indices. Do that on a bounded encoded copy,- // then retain shared validation for geometry, duplicates and all other invariants.- fn normalize_selection(node: &mut Node<PanelKind>) {- match node {- Node::Tabs { panels, active } => *active = (*active).min(panels.len().saturating_sub(1)),- Node::Split { first, second, .. } => {- normalize_selection(first);- normalize_selection(second);++pub(crate) fn valid_for_close(root: &DockNode) -> bool {++ fn normalize(node: &mut Node<PanelKind>) {++ match node {++ Node::Tabs { panels, active } => *active = (*active).min(panels.len().saturating_sub(1)),++ Node::Split { first, second, .. } => {++ normalize(first);++ normalize(second);++ }++ Node::Stack { .. } => {}+ }- Node::Stack { .. } => {}+ }- }-- pub(crate) fn close_tree(root: &mut DockNode, panel: PanelKind) {- let Ok(mut shared) = encode(root, &[]) else { return };- if let Some(node) = &mut shared.root {- normalize_selection(node);- }- if shared.validate().is_err() {- return;- }- // An absent close still repairs an invalid selection, as the legacy method did.- if root.contains(panel) && shared.apply(Action::Close { panel }).is_err() {- return;++ let Ok(mut shared) = encode(root, &[]) else { return false };++ if let Some(root) = &mut shared.root {++ normalize(root);+ }- *root = decode(shared).root;++ shared.validate().is_ok()+}++pub(crate) fn unfloat(layout: &mut Layout, panel: PanelKind) -> bool {+ let Ok(mut shared) = encode(&layout.root, &layout.floating) else { return false };+ let mut found = false;+ for group in &mut shared.floating {+ if group.panels.contains(&panel) {+ group.active = group.active.min(group.panels.len().saturating_sub(1));+ found = true;+ }+ }+ if !found || shared.apply(Action::Close { panel }).is_err() {+ return false;+ }- *layout = decode(shared);++ let mut proposed = decode(shared);++ restore_frames(&mut proposed.root, &layout.root);++ *layout = proposed;+ true+}++++#[cfg(test)]++mod stacked_frame_tests {++ use super::*;++ use crate::dock::Zone;++ #[test]++ fn stacked_tabs_survive_shared_resize_activate_float_and_close() {++ let mut root = crate::dock::workspace("Default");++ assert!(root.dock_panel(PanelKind::Info, PanelKind::Properties, Zone::Center));++ fn group(node: &DockNode) -> Option<&StackEntry> {++ match node {++ DockNode::Split { a, b, .. } => group(a).or_else(|| group(b)),++ DockNode::Stack { entries } => entries.iter().find(|e| e.contains(PanelKind::Properties)),++ _ => None,++ }++ }++ let before = group(&root).unwrap().clone();++ assert!(before.contains(PanelKind::Info));++ let mut layout = Layout { root, floating: vec![] };++ layout.apply(Action::ResizeSplit { path: vec![], size: SharedSplitSize::Ratio(0.6) }).unwrap();++ assert_eq!(group(&layout.root).unwrap(), &before);++ layout.apply(Action::Activate { panel: PanelKind::Properties }).unwrap();++ assert_eq!(group(&layout.root).unwrap().shown(), Some(PanelKind::Properties));++ let original_frame = group(&layout.root).unwrap().clone();++ layout.apply(Action::OpenAt { panel: PanelKind::History, anchor: PanelKind::Properties, placement: Placement::Tab { before: None } }).unwrap();++ let opened = group(&layout.root).unwrap();++ assert!(opened.contains(PanelKind::History));++ assert!(opened.contains(PanelKind::Info));++ assert_eq!(opened.shown(), Some(PanelKind::History));++ assert_eq!(opened.height, original_frame.height);++ layout.apply(Action::Close { panel: PanelKind::History }).unwrap();++ layout.apply(Action::Float { panel: PanelKind::Info, rect: [20.0, 20.0, 300.0, 300.0] }).unwrap();++ assert_eq!(group(&layout.root).unwrap().panels, vec![PanelKind::Properties]);++ layout.apply(Action::Close { panel: PanelKind::Info }).unwrap();++ assert!(layout.floating.is_empty());++ assert_eq!(group(&layout.root).unwrap().panels, vec![PanelKind::Properties]);++ }++}diff --cc crates/ui-egui/src/dock_ui.rsindex 83098d06a,ab8baace3..9c28f353b--- a/crates/ui-egui/src/dock_ui.rs+++ b/crates/ui-egui/src/dock_ui.rs@@@ -114,11 -108,7 +114,11 @@@ impl EffectcraftApp/// Edit the full layout (docked tree + floating groups) with a [`Layout`] operation.pub fn edit_layout(&mut self, f: impl FnOnce(&mut Layout) -> bool) -> bool {+ let Ok(shared) = crate::dock_shared::encode(&self.ui.dock, &self.ui.floating) else { return false };+ if shared.validate().is_err() {+ return false;+ }- let mut l = crate::dock_shared::decode(shared);+ let mut l = Layout { root: self.ui.dock.clone(), floating: self.ui.floating.clone() };if !f(&mut l) {return false;}diff --cc crates/ui-egui/src/lib.rsindex f7a06d66f,d0ed7315b..a0e05e007--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@@ -298,14 -343,22 +346,25 @@@ pub struct EffectcraftApppub(crate) template_list: Option<(Vec<String>, Vec<effectcraft_engine::templates::TemplateInfo>)>,}+ /// The saved workspaces in the settings store ([`effectcraft_engine::config::ConfigStore`]).+ pub const WORKSPACES_FILE: &str = "workspaces.json";++ #[derive(serde::Serialize, serde::Deserialize)]+ struct SavedWorkspaces {+ #[serde(default)]+ workspaces: std::collections::BTreeMap<String, dock::DockNode>,+ #[serde(default)]+ floating: std::collections::BTreeMap<String, Vec<dock::Floating>>,+ }+impl EffectcraftApp {pub fn new(session: Session) -> Self {+ let mut ui = UiState::default();+ let workspace_store = workspace_state::WorkspaceStore::load(session.config.as_deref(), &mut ui);EffectcraftApp {session,- ui: UiState::default(),+ ui,+ workspace_store,tokens: Tokens::for_kind(Default::default()),auto: Default::default(),frames: Frames::default(),@@@ -359,8 -414,36 +420,14 @@@template_list: None,}.with_ui_commands()- .with_saved_workspaces()- }-- /// The workspaces saved in an earlier session (Window ▸ Workspace ▸ Save as New Workspace,- /// Save Changes to this Workspace), from the settings store. A file that doesn't read is- /// ignored.- fn with_saved_workspaces(mut self) -> Self {- let text = self.session.config.as_ref().and_then(|c| c.read(WORKSPACES_FILE));- match text.map(|t| serde_json::from_str::<SavedWorkspaces>(&t)) {- Some(Ok(w)) => {- self.ui.saved_workspaces = w.workspaces;- self.ui.saved_floating = w.floating;- }- Some(Err(e)) => log::warn!("{WORKSPACES_FILE}: {e}"),- None => {}- }- self}+ /// Keep the saved workspaces for the next session (see [`EffectcraftApp::new`]): After+ /// Effects' saved workspaces last until they are deleted (#320).- pub(crate) fn store_saved_workspaces(&self) {- let Some(c) = &self.session.config else { return };- let w = SavedWorkspaces { workspaces: self.ui.saved_workspaces.clone(), floating: self.ui.saved_floating.clone() };- let written = serde_json::to_string(&w).map_err(std::io::Error::other).and_then(|t| c.write(WORKSPACES_FILE, &t));- if let Err(e) = written {- log::warn!("{WORKSPACES_FILE}: {e}");- }++ pub(crate) fn store_saved_workspaces(&mut self) {++ self.save_workspace_state();+ }+/// Offer the frontend's commands (tools, timeline navigation…) for keyboard shortcuts.fn with_ui_commands(mut self) -> Self {let cmds = menus::UI_COMMANDS@@@ -1649,13 -1755,16 +1761,17 @@@ impl EffectcraftAppimpl eframe::App for EffectcraftApp {fn on_exit(&mut self) {+ self.save_workspace_state();- // Clean exit: no crash recovery next launch.- self.session.end_recovery();+ // Clean exit: no crash recovery next launch (unless the graphics device was lost with+ // unsaved changes, which are in the auto-save it offers).+ if self.device_lost_close != Some(true) {+ self.session.end_recovery();+ }}- fn raw_input_hook(&mut self, _ctx: &egui::Context, raw_input: &mut egui::RawInput) {- if !self.synthetic.is_empty() {+ fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {+ let injected = !self.synthetic.is_empty();+ if injected {// Pointer events go one per frame so egui sees press → moves → release as a real drag.let pointer = |e: &egui::Event| matches!(e, egui::Event::PointerMoved(_) | egui::Event::PointerButton { .. } | egui::Event::MouseWheel { .. });let n = if pointer(&self.synthetic[0]) {diff --cc crates/ui-egui/src/menus.rsindex 819f1c700,52ae3b150..5c61b4977--- a/crates/ui-egui/src/menus.rs+++ b/crates/ui-egui/src/menus.rs@@@ -417,30 -417,10 +418,34 @@@ pub fn invoke(app: &mut EffectcraftApp_ => {}}}+ if id == "window.dockAction" {+ let value = params.get("action").cloned().ok_or("missing docking action")?;+ let action: craft_ui::docking::Action<PanelKind> = serde_json::from_value(value).map_err(|error| format!("invalid docking action: {error}"))?;+ if matches!(&action, craft_ui::docking::Action::Open { .. } | craft_ui::docking::Action::OpenAt { .. }) {+ return Err("use the panel open commands to preserve viewer and ScriptUI lifecycle callbacks".into());+ }+ if let craft_ui::docking::Action::Close { panel } = &action {+ let mut layout = crate::dock_shared::encode(&app.ui.dock, &app.ui.floating)?;+ layout.apply(action.clone()).map_err(|error| error.to_string())?;+ app.close_panel(*panel);+ return Ok(Value::Null);+ }+ let mut error = None;+ if !app.edit_layout(|layout| match layout.apply(action) {+ Ok(()) => true,+ Err(reason) => {+ error = Some(reason);+ false+ }+ }) {+ return Err(error.unwrap_or_else(|| "invalid docking layout".into()));+ }+ return Ok(Value::Null);+ }+ // A UI-only command (not in the engine's menus), so `frontend` gets it from here.+ if id == "window.maximizeApp" {+ return frontend(app, ctx, id, params);+ }// Docking: {panel, anchor, zone: center|left|right|top|bottom}, {panel, rect?}, {panel?}.if let Some(op) = id.strip_prefix("window.").filter(|o| matches!(*o, "maximizePanel" | "dockPanel" | "floatPanel" | "closePanel")) {let panel_of = |k: &str| params.get(k).and_then(Value::as_str).map(|s| PanelKind::from_name(s).ok_or(format!("unknown panel `{s}`")));diff --cc crates/ui-egui/src/panels/text_panels.rsindex 8e24a0835,47aacc46f..a32d74b43--- a/crates/ui-egui/src/panels/text_panels.rs+++ b/crates/ui-egui/src/panels/text_panels.rs@@@ -722,3 -842,63 +842,63 @@@ fn align_glyph(p: &egui::Painter, r: Rep.rect_filled(Rect::from_min_size(pos2(c.x + 3.0, off(9.0)), vec2(5.0, 9.0)), 1.0, t.text_dim);}}++ /// Where a font's "Sample" outlines (`lines`, baseline at y = 0) go in `room`: `(scale, origin)`,+ /// a point `p` landing at `origin + p * scale`. At their natural size on `baseline` when they fit;+ /// fonts with large or odd metrics are scaled down (never up) and moved inside, so no preview+ /// spills out of its row (#577). `None`: nothing to draw.+ fn fit_preview(lines: &[Vec<[f32; 2]>], room: Rect, baseline: f32) -> Option<(f32, egui::Vec2)> {+ let b = lines+ .iter()+ .flatten()+ .filter(|p| p[0].is_finite() && p[1].is_finite())+ .fold(Rect::NOTHING, |b, p| b.union(Rect::from_min_max(pos2(p[0], p[1]), pos2(p[0], p[1]))));- if !(b.min.x <= b.max.x && b.min.y <= b.max.y) || !room.is_positive() {++ if !(b.min.x <= b.max.x && b.min.y <= b.max.y && room.is_positive()) {+ return None;+ }+ let k = (room.width() / b.width().max(1e-3)).min(room.height() / b.height().max(1e-3)).min(1.0);+ let mut o = vec2(room.min.x - b.min.x * k, baseline);+ let (top, bottom) = (o.y + b.min.y * k, o.y + b.max.y * k);+ if top < room.min.y {+ o.y += room.min.y - top;+ } else if bottom > room.max.y {+ o.y -= bottom - room.max.y;+ }+ Some((k, o))+ }++ #[cfg(test)]+ mod tests {+ use super::*;++ /// #577: every font's "Sample" preview lands inside its row's preview box: at its natural size+ /// when it fits, else scaled down; nothing for no outlines.+ #[test]+ fn font_previews_fit_their_row() {+ let room = Rect::from_min_max(pos2(180.0, 101.0), pos2(294.0, 119.0));+ let baseline = 115.0;+ let inside = |lines: &[Vec<[f32; 2]>]| {+ let (k, o) = fit_preview(lines, room, baseline).expect("a preview");+ for p in lines.iter().flatten() {+ let q = o + vec2(p[0], p[1]) * k;+ assert!(room.expand(0.01).contains(pos2(q.x, q.y)), "{p:?} → {q:?} outside {room:?}");+ }+ k+ };+ // A plain 14 px sample fits as it is, on the baseline.+ let plain = vec![vec![[0.0, -10.0], [60.0, -10.0], [60.0, 3.0], [0.0, 3.0]]];+ assert_eq!(inside(&plain), 1.0);+ assert_eq!(fit_preview(&plain, room, baseline).map(|(_, o)| o.y), Some(baseline));+ // Huge, wide, tall, offset and negative-bearing outlines are scaled into the box.+ for lines in [+ vec![vec![[0.0, -80.0], [400.0, 30.0]]],+ vec![vec![[-50.0, -5.0], [500.0, 2.0]]],+ vec![vec![[10.0, -200.0], [12.0, 0.0]]],+ vec![vec![[0.0, 20.0], [30.0, 40.0]]],+ ] {+ assert!(inside(&lines) <= 1.0);+ }+ assert!(fit_preview(&[], room, baseline).is_none());+ assert!(fit_preview(&[vec![[f32::NAN, 1.0]]], room, baseline).is_none());+ }+ }diff --cc crates/ui-egui/src/panels/viewer_tools.rsindex 94e7fedd1,72cb0806f..772d0769a--- a/crates/ui-egui/src/panels/viewer_tools.rs+++ b/crates/ui-egui/src/panels/viewer_tools.rs@@@ -704,14 -684,16 +709,16 @@@ fn bottom_bar_contents(app: &mut Effectlet mut ev = vo.exposure as f64;let resp = ui.put(er,- egui::DragValue::new(&mut ev)- .speed(0.05)- .range(-40.0..=40.0)- .fixed_decimals(1)- .custom_formatter(|v, _| if v == 0.0 { "0.0".into() } else { format!("{v:+.1}") }),+ crate::widgets::drag_value(+ egui::DragValue::new(&mut ev)+ .speed(0.05)+ .range(-40.0..=40.0)+ .fixed_decimals(1)+ .custom_formatter(|v, _| if v == 0.0 { "0.0".into() } else { format!("{v:+.1}") }),+ ),);let resp = resp.on_hover_text(crate::i18n::tr("Adjust Exposure (stops)"));- app.auto.add("viewer.exposure", er, "Adjust Exposure");+ app.auto.add_response("viewer.exposure", &resp, "Adjust Exposure");if resp.changed() {let _ = app.session.execute("view.exposure", json!({"stops": ev}));}diff --cc crates/ui-egui/src/workspace_state.rsindex 6e2b9a062,000000000..9262266dbmode 100644,000000..100644--- a/crates/ui-egui/src/workspace_state.rs+++ b/crates/ui-egui/src/workspace_state.rs@@@ -1,391 -1,0 +1,410 @@@+//! Persistent workspace layouts, separate from document-bound and transient UI state.++use std::collections::BTreeMap;++use effectcraft_engine::config::ConfigStore;+use serde::{Deserialize, Serialize};++use crate::dock::{DockNode, Floating, PanelKind, SplitSize};+use crate::state::UiState;++const FILE: &str = "workspaces.json";+const MAX_BYTES: usize = 1024 * 1024;+const MAX_WORKSPACES: usize = 64;+const MAX_NODES: usize = 4096;+const MAX_DEPTH: usize = 32;+const MAX_PANELS: usize = 128;+/// Leave room for new viewers without approaching the u32 allocator limit.+const MAX_VIEWER_ID: u32 = 65_535;+const MAX_COORD: f32 = 1_000_000.0;++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+struct Snapshot {+ version: u32,+ workspace: String,+ dock: DockNode,+ floating: Vec<Floating>,+ focused: PanelKind,+ maximized: Option<PanelKind>,+ saved_workspaces: BTreeMap<String, DockNode>,+ saved_floating: BTreeMap<String, Vec<Floating>>,+}++impl Snapshot {+ fn capture(ui: &UiState) -> Self {+ Self {+ version: 1,+ workspace: ui.workspace.clone(),+ dock: ui.dock.clone(),+ floating: ui.floating.clone(),+ focused: ui.focused,+ maximized: ui.maximized,+ saved_workspaces: ui.saved_workspaces.clone(),+ saved_floating: ui.saved_floating.clone(),+ }+ }++ fn apply(self, ui: &mut UiState) {+ ui.workspace = self.workspace;+ ui.dock = self.dock;+ ui.floating = self.floating;+ ui.focused = self.focused;+ ui.maximized = self.maximized;+ ui.saved_workspaces = self.saved_workspaces;+ ui.saved_floating = self.saved_floating;+ // Reserve restored viewer slots without restoring any project-specific composition+ // links. New Viewer allocates from this map, including after switching named layouts.+ let mut panels = Vec::new();+ for root in std::iter::once(&ui.dock).chain(ui.saved_workspaces.values()) {+ root.panels(&mut panels);+ }+ for groups in std::iter::once(&ui.floating).chain(ui.saved_floating.values()) {+ for group in groups {+ panels.extend(group.panels.iter().copied());+ }+ }+ for panel in panels {+ if let PanelKind::Viewer(id) = panel {+ ui.viewers.entry(id).or_insert(None);+ }+ }+ }++ fn validate(&self) -> Result<(), String> {+ if self.version != 1 {+ return Err(format!("unsupported workspace version {}", self.version));+ }+ let name_ok = |name: &str| !name.trim().is_empty() && name.len() <= 256;+ if !name_ok(&self.workspace)+ || self.saved_workspaces.len() > MAX_WORKSPACES+ || self.saved_floating.len() > MAX_WORKSPACES+ || self.saved_workspaces.keys().chain(self.saved_floating.keys()).any(|name| !name_ok(name))+ {+ return Err("workspace names or count exceed supported limits".into());+ }+ if !crate::dock::WORKSPACES.contains(&self.workspace.as_str()) && !self.saved_workspaces.contains_key(&self.workspace) {+ return Err("current workspace has no saved definition".into());+ }+ let panel_ok = |panel: PanelKind| match panel {+ PanelKind::Viewer(id) => (1..=MAX_VIEWER_ID).contains(&id),+ _ => true,+ };+ if !panel_ok(self.focused) || self.maximized.is_some_and(|panel| !panel_ok(panel)) {+ return Err("workspace viewer ID is outside the supported range 1–65535".into());+ }+ let mut nodes = 0usize;+ for root in std::iter::once(&self.dock).chain(self.saved_workspaces.values()) {+ let mut pending = vec![(root, 0usize)];+ while let Some((node, depth)) = pending.pop() {+ nodes = nodes.saturating_add(1);+ if depth > MAX_DEPTH || nodes > MAX_NODES {+ return Err("workspace dock tree exceeds supported limits".into());+ }+ match node {+ DockNode::Split { size, a, b, .. } => {+ let valid = match *size {+ SplitSize::Ratio(v) => v.is_finite() && (0.0..=1.0).contains(&v),+ SplitSize::FixedA(v) | SplitSize::FixedB(v) => v.is_finite() && (0.0..=MAX_COORD).contains(&v),+ };+ if !valid {+ return Err("invalid workspace split size".into());+ }+ pending.push((a, depth.saturating_add(1)));+ pending.push((b, depth.saturating_add(1)));+ }+ DockNode::Tabs { panels, active } => {+ // Closing the last docked panel leaves an empty group with active=0.+ if panels.len() > MAX_PANELS || *active >= panels.len().max(1) || panels.iter().any(|panel| !panel_ok(*panel)) {+ return Err("invalid workspace tab group".into());+ }+ }+ DockNode::Stack { entries } => {+ if entries.len() > MAX_PANELS- || entries.iter().any(|e| !panel_ok(e.panel) || e.height.is_some_and(|v| !v.is_finite() || !(0.0..=MAX_COORD).contains(&v)))++ || entries.iter().any(|e| {++ e.panels.is_empty()++ || e.panels.len() > MAX_PANELS++ || e.active >= e.panels.len()++ || e.panels.iter().any(|p| !panel_ok(*p))++ || e.height.is_some_and(|v| !v.is_finite() || !(0.0..=MAX_COORD).contains(&v))++ })+ {+ return Err("invalid workspace panel stack".into());+ }+ }+ }+ }+ }+ for groups in std::iter::once(&self.floating).chain(self.saved_floating.values()) {+ if groups.len() > MAX_PANELS {+ return Err("too many floating workspace groups".into());+ }+ for group in groups {+ let [x, y, width, height] = group.rect;+ if group.panels.is_empty()+ || group.panels.len() > MAX_PANELS+ || group.panels.iter().any(|panel| !panel_ok(*panel))+ || group.active >= group.panels.len()+ || !group.rect.iter().all(|v| v.is_finite())+ || x.abs() > MAX_COORD+ || y.abs() > MAX_COORD+ || !(1.0..=MAX_COORD).contains(&width)+ || !(1.0..=MAX_COORD).contains(&height)+ {+ return Err("invalid floating workspace group".into());+ }+ }+ }+ crate::dock_shared::encode(&self.dock, &self.floating)?.validate().map_err(|error| error.to_string())?;+ for (name, root) in &self.saved_workspaces {+ let floating = self.saved_floating.get(name).map(Vec::as_slice).unwrap_or(&[]);+ crate::dock_shared::encode(root, floating)?.validate().map_err(|error| error.to_string())?;+ }+ Ok(())+ }+}++pub(crate) struct WorkspaceStore {+ saved: Snapshot,+ last_attempt: f64,+ writable: bool,+ pub(crate) error: Option<String>,+}++impl WorkspaceStore {+ pub(crate) fn load(config: Option<&dyn ConfigStore>, ui: &mut UiState) -> Self {+ let loaded = config.map_or(Ok(None), |c| c.read_bounded(FILE, MAX_BYTES)).map_err(|e| e.to_string()).and_then(|text| {+ text.map(|text| {- let snapshot = serde_json::from_str::<Snapshot>(&text).map_err(|e| e.to_string())?;++ let value: serde_json::Value = serde_json::from_str(&text).map_err(|e| e.to_string())?;++ // Only an explicitly legacy-shaped record can migrate. A versioned future++ // snapshot must never deserialize as an empty defaulted legacy record.++ let snapshot = if value.get("version").is_none()++ && value.as_object().is_some_and(|fields| fields.contains_key("workspaces") || fields.contains_key("floating"))++ {++ let legacy: crate::SavedWorkspaces = serde_json::from_value(value).map_err(|e| e.to_string())?;++ let mut snapshot = Snapshot::capture(ui);++ snapshot.saved_workspaces = legacy.workspaces;++ snapshot.saved_floating = legacy.floating;++ snapshot++ } else {++ serde_json::from_value::<Snapshot>(value).map_err(|e| e.to_string())?++ };+ snapshot.validate()?;+ Ok(snapshot)+ })+ .transpose()+ });+ let error = match loaded {+ Ok(Some(snapshot)) => {+ snapshot.apply(ui);+ None+ }+ Ok(None) => None,+ Err(e) => Some(format!("Could not load workspaces: {e}. The existing file will be preserved for this session.")),+ };+ if let Some(error) = &error {+ log::warn!("{error}");+ ui.status = error.clone();+ }+ // An unreadable or newer file is never replaced by this session, even after a later+ // layout edit. Ordinary failed writes remain dirty and retryable.+ Self { saved: Snapshot::capture(ui), last_attempt: f64::NEG_INFINITY, writable: error.is_none(), error }+ }++ pub(crate) fn due(&mut self, now: f64) -> bool {+ if now - self.last_attempt < 1.0 {+ return false;+ }+ self.last_attempt = now;+ true+ }++ pub(crate) fn has_changes(&self, ui: &UiState) -> bool {+ if !self.writable {+ return false;+ }+ self.saved.workspace != ui.workspace+ || self.saved.dock != ui.dock+ || self.saved.floating != ui.floating+ || self.saved.focused != ui.focused+ || self.saved.maximized != ui.maximized+ || self.saved.saved_workspaces != ui.saved_workspaces+ || self.saved.saved_floating != ui.saved_floating+ }++ pub(crate) fn save(&mut self, config: Option<&dyn ConfigStore>, ui: &UiState) -> Result<bool, String> {+ let Some(config) = config else { return Ok(false) };+ if !self.has_changes(ui) {+ return Ok(false);+ }+ let snapshot = Snapshot::capture(ui);+ snapshot.validate()?;+ let text = serde_json::to_string_pretty(&snapshot).map_err(|e| format!("serialize workspaces: {e}"))?;+ if text.len() > MAX_BYTES {+ return Err("workspace file exceeds 1 MiB".into());+ }+ config.write(FILE, &text).map_err(|e| format!("save workspaces: {e}"))?;+ self.saved = snapshot;+ self.error = None;+ Ok(true)+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use effectcraft_engine::config::MemoryConfig;++ #[test]+ fn corrupt_or_future_workspace_keeps_defaults_and_original_file() {+ let valid = Snapshot::capture(&UiState::default());+ for text in ["{".into(), serde_json::to_string(&Snapshot { version: 2, ..valid }).unwrap(), " ".repeat(MAX_BYTES + 1)] {+ let config = MemoryConfig::default();+ config.write(FILE, &text).unwrap();+ let mut ui = UiState::default();+ let mut store = WorkspaceStore::load(Some(&config), &mut ui);+ assert!(store.error.is_some());+ assert_eq!(ui.workspace, "Default");+ ui.focused = PanelKind::Project;+ ui.dock = crate::dock::workspace("Minimal");+ assert!(!store.save(Some(&config), &ui).unwrap());+ assert_eq!(config.read(FILE).as_deref(), Some(text.as_str()));+ }+ }++ #[test]+ fn invalid_tabs_split_and_deep_tree_are_rejected() {+ let mut snapshot = Snapshot::capture(&UiState::default());+ snapshot.dock = DockNode::Tabs { panels: vec![], active: usize::MAX };+ assert!(snapshot.validate().is_err());+ snapshot.dock = DockNode::Split {+ vertical: false,+ size: SplitSize::FixedA(f32::NAN),+ a: Box::new(crate::dock::workspace("Minimal")),+ b: Box::new(crate::dock::workspace("Minimal")),+ };+ assert!(snapshot.validate().is_err());+ snapshot.dock = crate::dock::workspace("Minimal");+ for _ in 0..=MAX_DEPTH {+ snapshot.dock = DockNode::Split {+ vertical: false,+ size: SplitSize::Ratio(0.5),+ a: Box::new(snapshot.dock),+ b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 }),+ };+ }+ assert!(snapshot.validate().is_err());+ }++ #[test]+ fn closing_all_docked_panels_remains_a_persistable_layout() {+ let config = MemoryConfig::default();+ let mut ui = UiState::default();+ let mut store = WorkspaceStore::load(Some(&config), &mut ui);+ let mut panels = Vec::new();+ ui.dock.panels(&mut panels);+ for panel in panels {+ ui.dock.close(panel);+ }+ assert!(store.save(Some(&config), &ui).unwrap());+ let mut restored = UiState::default();+ let loaded = WorkspaceStore::load(Some(&config), &mut restored);+ assert!(loaded.error.is_none());+ assert_eq!(restored.dock, ui.dock);+ }++ #[test]+ fn floating_groups_and_named_snapshots_roundtrip_without_document_state() {+ let config = MemoryConfig::default();+ let mut ui = UiState::default();+ let mut store = WorkspaceStore::load(Some(&config), &mut ui);+ ui.workspace = "Floating".into();+ ui.dock.close(PanelKind::Preview);+ ui.floating = vec![Floating { panels: vec![PanelKind::Preview], active: 0, rect: [50.0, 80.0, 200.0, 160.0] }];+ ui.saved_workspaces.insert(ui.workspace.clone(), ui.dock.clone());+ ui.saved_floating.insert(ui.workspace.clone(), ui.floating.clone());+ ui.maximized = Some(PanelKind::Composition);+ ui.project_search = "do not persist".into();+ assert!(store.save(Some(&config), &ui).unwrap());+ let mut restored = UiState::default();+ WorkspaceStore::load(Some(&config), &mut restored);+ assert_eq!(Snapshot::capture(&restored), Snapshot::capture(&ui));+ assert!(restored.project_search.is_empty());+ }++ #[test]+ fn restored_viewer_slots_do_not_reuse_ids_or_restore_document_links() {+ let config = MemoryConfig::default();+ let mut ui = UiState::default();+ let mut store = WorkspaceStore::load(Some(&config), &mut ui);+ ui.dock = DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(2)], active: 0 };+ ui.saved_workspaces.insert("Two views".into(), DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(5)], active: 0 });+ ui.viewers.insert(2, Some(42));+ assert!(store.save(Some(&config), &ui).unwrap());+ let mut app = crate::EffectcraftApp::new(effectcraft_engine::Session::default());+ WorkspaceStore::load(Some(&config), &mut app.ui);+ assert_eq!(app.ui.viewers.get(&2), Some(&None));+ assert_eq!(app.ui.viewers.get(&5), Some(&None));+ assert_eq!(crate::panels::viewers::new_viewer(&mut app), 6);+ assert!(app.ui.dock.contains(PanelKind::Viewer(2)));+ }++ #[test]+ fn invalid_viewer_ids_are_rejected_in_every_workspace_reference() {+ for id in [0, MAX_VIEWER_ID + 1, u32::MAX] {+ for location in 0..8 {+ let mut snapshot = Snapshot::capture(&UiState::default());+ let panel = PanelKind::Viewer(id);+ let dock = DockNode::Tabs { panels: vec![panel], active: 0 };- let stack = DockNode::Stack { entries: vec![crate::dock::StackEntry { panel, open: true, height: None }] };++ let stack = DockNode::Stack { entries: vec![crate::dock::StackEntry::new(panel, true, None)] };+ let floating = vec![Floating { panels: vec![panel], active: 0, rect: [0.0, 0.0, 200.0, 100.0] }];+ match location {+ 0 => snapshot.focused = panel,+ 1 => snapshot.maximized = Some(panel),+ 2 => snapshot.dock = dock,+ 3 => snapshot.dock = stack,+ 4 => snapshot.floating = floating,+ 5 => {+ snapshot.saved_workspaces.insert("Saved".into(), dock);+ }+ 6 => {+ snapshot.saved_workspaces.insert("Saved".into(), stack);+ }+ _ => {+ snapshot.saved_floating.insert("Saved".into(), floating);+ }+ }+ assert!(snapshot.validate().is_err(), "viewer {id} at location {location} must be rejected");+ }+ }+ }++ #[test]+ fn failed_write_keeps_previous_snapshot_and_retries() {+ struct Fails<'a>(&'a MemoryConfig);+ impl ConfigStore for Fails<'_> {+ fn read(&self, name: &str) -> Option<String> {+ self.0.read(name)+ }+ fn write(&self, _name: &str, _data: &str) -> std::io::Result<()> {+ Err(std::io::Error::other("synthetic full disk"))+ }+ fn remove(&self, _name: &str) -> std::io::Result<()> {+ Err(std::io::Error::other("unused"))+ }+ }+ let config = MemoryConfig::default();+ let mut ui = UiState::default();+ let mut store = WorkspaceStore::load(Some(&config), &mut ui);+ ui.focused = PanelKind::Project;+ assert!(store.save(Some(&config), &ui).unwrap());+ let previous = config.read(FILE).unwrap();+ ui.focused = PanelKind::Timeline;+ assert!(store.save(Some(&Fails(&config)), &ui).unwrap_err().contains("synthetic full disk"));+ assert_eq!(config.read(FILE).as_deref(), Some(previous.as_str()));+ assert!(store.has_changes(&ui));+ assert!(store.save(Some(&config), &ui).unwrap());+ let mut restored = UiState::default();+ WorkspaceStore::load(Some(&config), &mut restored);+ assert_eq!(restored.focused, PanelKind::Timeline);+ }+}diff --cc crates/ui-egui/tests/shared_docking_ui.rsindex 9f848522c,000000000..a1bc9280bmode 100644,000000..100644--- a/crates/ui-egui/tests/shared_docking_ui.rs+++ b/crates/ui-egui/tests/shared_docking_ui.rs@@@ -1,400 -1,0 +1,403 @@@+//! Existing EffectCraft workspaces use shared transactions without changing their saved schema.+use craft_ui::docking::{Action, Placement, Zone};+use effectcraft_engine::Session;+use effectcraft_ui_egui::{+ EffectcraftApp,+ dock::{self, DockNode, Layout, PanelKind, SplitSize, StackEntry},+};+use egui::{Event, Modifiers, PointerButton, Rect, pos2, vec2};+use egui_kittest::Harness;+use egui_kittest::kittest::{NodeT, Queryable};+use serde_json::json;++#[test]+fn shared_move_preserves_accordion_metadata_and_unrelated_active_tabs() {+ let mut layout = Layout {+ root: DockNode::Split {+ vertical: false,+ size: SplitSize::FixedB(300.0),+ a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project, PanelKind::Composition, PanelKind::Layer], active: 1 }),+ b: Box::new(DockNode::Stack {+ entries: vec![- StackEntry { panel: PanelKind::Preview, open: false, height: Some(73.0) },- StackEntry { panel: PanelKind::Properties, open: true, height: Some(211.0) },- StackEntry { panel: PanelKind::Align, open: false, height: None },++ StackEntry::new(PanelKind::Preview, false, Some(73.0)),++ StackEntry::new(PanelKind::Properties, true, Some(211.0)),++ StackEntry::new(PanelKind::Align, false, None),+ ],+ }),+ },+ floating: vec![],+ };+ layout.apply(Action::Close { panel: PanelKind::Project }).unwrap();+ assert!(layout.root.is_visible(PanelKind::Composition));+ layout.apply(Action::Move { panel: PanelKind::Preview, anchor: PanelKind::Align, placement: Placement::Tab { before: None } }).unwrap();+ let DockNode::Split { b, size, .. } = &layout.root else { panic!("split was lost") };+ assert_eq!(*size, SplitSize::FixedB(300.0));+ let DockNode::Stack { entries } = b.as_ref() else { panic!("stack was lost") };- assert_eq!(entries.iter().find(|entry| entry.panel == PanelKind::Preview).unwrap().height, Some(73.0));- assert_eq!(- entries.iter().find(|entry| entry.panel == PanelKind::Properties).unwrap(),- &StackEntry { panel: PanelKind::Properties, open: true, height: Some(211.0) }- );++ // Upstream now makes a tab drop join the anchor's accordion frame. Its height belongs++ // to the destination frame; the unrelated Properties frame keeps its exact metadata.++ let joined = entries.iter().find(|entry| entry.contains(PanelKind::Preview)).unwrap();++ assert_eq!(joined.panels, vec![PanelKind::Align, PanelKind::Preview]);++ assert_eq!(joined.shown(), Some(PanelKind::Preview));++ assert!(joined.open);++ assert_eq!(joined.height, None);++ assert_eq!(entries.iter().find(|entry| entry.contains(PanelKind::Properties)).unwrap(), &StackEntry::new(PanelKind::Properties, true, Some(211.0)));+ let before = layout.clone();+ assert!(layout.apply(Action::Move { panel: PanelKind::Preview, anchor: PanelKind::Audio, placement: Placement::Split(Zone::Left) }).is_err());+ assert_eq!(layout, before);+ assert!(layout.apply(Action::Float { panel: PanelKind::Preview, rect: [0.0, 0.0, f32::INFINITY, 200.0] }).is_err());+ assert_eq!(layout, before);+}++#[test]+fn every_builtin_workspace_and_dynamic_identity_roundtrips() {+ for name in dock::WORKSPACES {+ let mut layout = Layout { root: dock::workspace(name), floating: dock::workspace_floating(name) };+ let before = serde_json::to_value(&layout).unwrap();+ // A structural no-op still crosses both adapters and shared validation. The complete+ // persisted shape must remain byte-equivalent, including accordion state and heights.+ let action = match &layout.root {+ DockNode::Split { size, .. } => Action::ResizeSplit {+ path: vec![],+ size: match *size {+ SplitSize::Ratio(v) => craft_ui::layout::SplitSize::Ratio(v),+ SplitSize::FixedA(v) => craft_ui::layout::SplitSize::FixedFirst(v),+ SplitSize::FixedB(v) => craft_ui::layout::SplitSize::FixedSecond(v),+ },+ },+ DockNode::Tabs { panels, .. } => Action::Move { panel: panels[0], anchor: panels[1], placement: Placement::Tab { before: Some(panels[0]) } },- DockNode::Stack { entries } => Action::SetStackOpen { panel: entries[0].panel, open: entries[0].open },++ DockNode::Stack { entries } => Action::SetStackOpen { panel: entries[0].shown().unwrap(), open: entries[0].open },+ };+ layout.apply(action).unwrap();+ assert_eq!(before, serde_json::to_value(&layout).unwrap());+ let back: Layout = serde_json::from_value(before).unwrap();+ assert_eq!(layout, back);+ }+ let mut layout = Layout {+ root: DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(42), PanelKind::ScriptPanel(77)], active: 1 },+ floating: vec![],+ };+ layout.apply(Action::Float { panel: PanelKind::ScriptPanel(77), rect: [20.0, 30.0, 400.0, 300.0] }).unwrap();+ layout.apply(Action::Move { panel: PanelKind::ScriptPanel(77), anchor: PanelKind::Viewer(42), placement: Placement::Tab { before: None } }).unwrap();+ assert!(layout.floating.is_empty());+ assert!(layout.contains(PanelKind::Viewer(42)));+ assert!(layout.root.is_visible(PanelKind::ScriptPanel(77)));+}++fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {+ let element = h.state().auto.find(id).unwrap_or_else(|| panic!("missing {id}"));+ Rect::from_min_size(pos2(element.rect[0], element.rect[1]), vec2(element.rect[2], element.rect[3]))+}+fn drag(h: &mut Harness<'_, EffectcraftApp>, from: egui::Pos2, to: egui::Pos2, modifiers: Modifiers) {+ h.event(Event::ModifiersChanged(modifiers));+ h.event(Event::PointerMoved(from));+ h.step();+ h.event(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers });+ h.step();+ for fraction in [0.05, 0.25, 0.5, 0.75, 1.0] {+ h.event(Event::PointerMoved(from.lerp(to, fraction)));+ h.step();+ }+ h.event(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers });+ h.step();+ h.event(Event::ModifiersChanged(Modifiers::NONE));+ h.run_steps(3);+}++#[test]+fn pointer_drop_merges_floats_and_redocks_without_project_changes() {+ let mut session = Session::default();+ session.execute("comp.new", json!({"name": "Docking composition", "width": 320, "height": 180, "duration": 4})).unwrap();+ session.execute("layer.newSolid", json!({"name": "Teal plate", "width": 320, "height": 180, "color": "#245b68"})).unwrap();+ session.execute("layer.newSolid", json!({"name": "Coral tile", "width": 110, "height": 70, "color": "#ee7859"})).unwrap();+ let mut app = EffectcraftApp::new(session);+ app.ui.start_screen = false;+ app.ui.dock = DockNode::Split {+ vertical: false,+ size: SplitSize::FixedA(400.0),+ a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project, PanelKind::Info, PanelKind::Audio], active: 1 }),+ b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Layer], active: 0 }),+ };+ app.ui.dock = DockNode::Split {+ vertical: true,+ size: SplitSize::Ratio(0.62),+ a: Box::new(app.ui.dock),+ b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Timeline], active: 0 }),+ };+ let snapshots = std::env::var_os("CRAFT_UI_DOCKING_SNAPSHOT_DIR").map(std::path::PathBuf::from);+ let mut builder = Harness::builder().with_size(vec2(1200.0, 760.0));+ if snapshots.is_some() {+ builder = builder.wgpu();+ }+ let mut h = builder.build_eframe(move |_| app);+ h.run_steps(4);+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);+ while h.state().frames.urgent_pending() && std::time::Instant::now() < deadline {+ std::thread::sleep(std::time::Duration::from_millis(1));+ }+ assert!(!h.state().frames.urgent_pending());+ h.run_steps(3);+ let project = h.state().session.project.clone();+ let times = h.state().session.state.times.clone();+ let mut action_log = vec![action_state(&h, "start")];+ let from = rect(&h, "panel.tab.Info").center();+ let to = rect(&h, "panel.Composition").center();+ drag(&mut h, from, to, Modifiers::NONE);+ assert!(h.state().ui.dock.is_visible(PanelKind::Info));+ assert!(same_group(&h.state().ui.dock, PanelKind::Info, PanelKind::Composition));+ action_log.push(action_state(&h, "merged"));+ let from = rect(&h, "panel.tab.Info").center();+ let before = rect(&h, "panel.tab.Composition");+ drag(&mut h, from, pos2(before.left() + 2.0, before.center().y), Modifiers::NONE);+ assert_eq!(tabs_containing(&h.state().ui.dock, PanelKind::Info).first(), Some(&PanelKind::Info));+ action_log.push(action_state(&h, "reordered"));++ let from = rect(&h, "panel.tab.Info").center();+ drag(&mut h, from, pos2(700.0, 400.0), Modifiers::COMMAND);+ assert_eq!(h.state().ui.floating.len(), 1);+ assert_eq!(h.get_by_label("Resize floating panel").accesskit_node().role(), egui::accesskit::Role::Button);+ action_log.push(action_state(&h, "floated"));+ let original = h.state().ui.floating[0].rect;+ let grip = rect(&h, "panel.float.0.resize").center();+ drag(&mut h, grip, grip + vec2(36.0, 24.0), Modifiers::NONE);+ assert!(h.state().ui.floating[0].rect[2] > original[2] + 25.0);+ assert!(h.state().ui.floating[0].rect[3] > original[3] + 15.0);+ action_log.push(action_state(&h, "resized"));+ let grip_id = egui::Id::new(("floating-panel", PanelKind::Info.id())).with("resize");+ assert_eq!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));+ let before_keys = h.state().ui.floating[0].rect;+ for key in [egui::Key::ArrowRight, egui::Key::ArrowDown] {+ for pressed in [true, false] {+ h.event(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE });+ h.step();+ }+ }+ assert_eq!(h.state().ui.floating[0].rect[2], before_keys[2] + 8.0);+ assert_eq!(h.state().ui.floating[0].rect[3], before_keys[3] + 8.0);+ h.event(Event::Key { key: egui::Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });+ h.step();+ h.event(Event::Key { key: egui::Key::Tab, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });+ h.run_steps(3);+ assert_ne!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));+ action_log.push(action_state(&h, "keyboard-resized"));+ let resized = h.state().ui.floating[0].rect;+ let header = rect(&h, "panel.float.0.move");+ let from = pos2(header.right() - 24.0, header.center().y);+ drag(&mut h, from, from - vec2(24.0, 18.0), Modifiers::NONE);+ assert!(h.state().ui.floating[0].rect[0] < resized[0] - 15.0);+ assert!(h.state().ui.floating[0].rect[1] < resized[1] - 10.0);+ action_log.push(action_state(&h, "moved"));++ if let Some(directory) = &snapshots {+ std::fs::create_dir_all(directory).unwrap();+ h.render().unwrap().save(directory.join("effectcraft-floating.png")).unwrap();+ }+ let from = rect(&h, "panel.tab.Info").center();+ let to = rect(&h, "panel.Audio").center();+ drag(&mut h, from, to, Modifiers::NONE);+ assert!(h.state().ui.floating.is_empty());+ action_log.push(action_state(&h, "redocked"));+ assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));+ assert_eq!(times, h.state().session.state.times);+ assert!(h.state().auto.elements.iter().any(|element| element.id.starts_with("timeline.layer.")));+ h.state_mut().session.execute("view.exposure", json!({"stops": 2.0})).unwrap();+ h.run_steps(3);+ let pos = rect(&h, "viewer.resetExposure").center();+ h.event(Event::PointerMoved(pos));+ h.step();+ for pressed in [true, false] {+ h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });+ h.step();+ }+ h.run_steps(3);+ assert_eq!(h.state().session.state.viewer.exposure, 0.0);+ action_log.push(action_state(&h, "viewer-reset-exposure"));+ if let Some(directory) = &snapshots {+ std::fs::write(directory.join("effectcraft-actions.json"), serde_json::to_vec_pretty(&action_log).unwrap()).unwrap();+ }+ if let Some(directory) = &snapshots {+ h.render().unwrap().save(directory.join("effectcraft-redocked.png")).unwrap();+ }+ assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));+}++fn same_group(root: &DockNode, first: PanelKind, second: PanelKind) -> bool {+ match root {+ DockNode::Tabs { panels, .. } => panels.contains(&first) && panels.contains(&second),+ DockNode::Split { a, b, .. } => same_group(a, first, second) || same_group(b, first, second),+ DockNode::Stack { .. } => false,+ }+}++#[test]+fn current_and_named_floating_layouts_survive_restart() {+ use effectcraft_engine::config::MemoryConfig;+ use std::sync::Arc;+ let store = Arc::new(MemoryConfig::default());+ let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });+ assert!(app.edit_layout(|layout| layout.apply(Action::Float { panel: PanelKind::Project, rect: [45.0, 65.0, 430.0, 310.0] }).is_ok()));+ let ctx = egui::Context::default();+ effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name": "Shared float"})).unwrap();+ let saved = app.ui.floating.clone();+ assert!(app.edit_layout(|layout| layout.apply(Action::MoveFloating { panel: PanelKind::Project, rect: [75.0, 95.0, 480.0, 360.0] }).is_ok()));+ let current = app.ui.floating.clone();+ eframe::App::on_exit(&mut app);+ let mut restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });+ assert_eq!(restarted.ui.floating, current);+ restarted.set_workspace("Default");+ restarted.set_workspace("Shared float");+ assert_eq!(restarted.ui.floating, saved);+}++fn tabs_containing(root: &DockNode, panel: PanelKind) -> Vec<PanelKind> {+ match root {+ DockNode::Tabs { panels, .. } if panels.contains(&panel) => panels.clone(),+ DockNode::Split { a, b, .. } => {+ let first = tabs_containing(a, panel);+ if first.is_empty() { tabs_containing(b, panel) } else { first }+ }+ _ => vec![],+ }+}++#[test]+fn float_command_rejects_malformed_rectangles_atomically() {+ let mut app = EffectcraftApp::new(Session::default());+ let before = app.ui.dock.clone();+ let ctx = egui::Context::default();+ for rect in [json!([1, 2, 300]), json!([1, 2, 300, 200, 7]), json!([1, 2, 1e100, 200]), json!("rectangle")] {+ assert!(effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Project", "rect": rect})).is_err());+ assert_eq!(app.ui.dock, before);+ assert!(app.ui.floating.is_empty());+ }+ app.ui.dock = DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 };+ assert!(!app.edit_layout(|layout| layout.apply(Action::Float { panel: PanelKind::Project, rect: [1.0, 2.0, 300.0, 200.0] }).is_ok()));+}++fn action_state(h: &Harness<'_, EffectcraftApp>, action: &str) -> serde_json::Value {+ json!({"action": action, "dock": h.state().ui.dock, "floating": h.state().ui.floating, "focused": h.state().ui.focused})+}++#[test]+fn catalog_docking_action_supports_resize_reorder_and_floating_geometry() {+ let mut app = EffectcraftApp::new(Session::default());+ app.ui.dock = DockNode::Split {+ vertical: false,+ size: SplitSize::FixedA(300.0),+ a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project, PanelKind::Info], active: 1 }),+ b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition], active: 0 }),+ };+ let ctx = egui::Context::default();+ for action in [+ Action::ResizeSplit { path: vec![], size: craft_ui::layout::SplitSize::FixedFirst(360.0) },+ Action::Move { panel: PanelKind::Info, anchor: PanelKind::Project, placement: Placement::Tab { before: Some(PanelKind::Project) } },+ Action::Float { panel: PanelKind::Info, rect: [20.0, 40.0, 300.0, 200.0] },+ Action::MoveFloating { panel: PanelKind::Info, rect: [45.0, 65.0, 330.0, 240.0] },+ ] {+ effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.dockAction", json!({"action": action})).unwrap();+ }+ assert_eq!(app.ui.floating[0].rect, [45.0, 65.0, 330.0, 240.0]);+ let DockNode::Split { size, .. } = &app.ui.dock else { panic!("split lost") };+ assert_eq!(*size, SplitSize::FixedA(360.0));+ let before = json!({"dock": app.ui.dock, "floating": app.ui.floating});+ assert!(+ effectcraft_ui_egui::menus::invoke(+ &mut app,+ &ctx,+ "window.dockAction",+ json!({"action": {+ "ResizeSplit": {"path": [true, true], "size": {"Ratio": 0.5}}+ }})+ )+ .is_err()+ );+ assert_eq!(json!({"dock": app.ui.dock, "floating": app.ui.floating}), before);+}++#[test]+fn catalog_close_keeps_dynamic_panel_identity() {+ let mut app = EffectcraftApp::new(Session::default());+ app.ui.dock = DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(42), PanelKind::ScriptPanel(77)], active: 1 };+ let ctx = egui::Context::default();+ for panel in [PanelKind::Viewer(42), PanelKind::ScriptPanel(77)] {+ effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.dockAction", json!({"action": Action::Close { panel }})).unwrap();+ assert!(!app.ui.dock.contains(panel));+ }+ assert!(app.ui.dock.contains(PanelKind::Composition));+}++#[test]+fn accordion_resize_routes_pointer_and_keyboard_without_changing_closed_entries() {+ let mut session = Session::default();+ session.execute("comp.new", json!({"width": 160, "height": 90, "duration": 1})).unwrap();+ let mut app = EffectcraftApp::new(session);+ app.ui.start_screen = false;+ let mut h = Harness::builder().with_size(vec2(1000.0, 720.0)).build_eframe(move |_| app);+ h.run_steps(4);+ h.state_mut().ui.dock = DockNode::Stack {+ entries: vec![- StackEntry { panel: PanelKind::Preview, open: true, height: Some(100.0) },- StackEntry { panel: PanelKind::Properties, open: true, height: None },- StackEntry { panel: PanelKind::Align, open: false, height: Some(77.0) },++ StackEntry::new(PanelKind::Preview, true, Some(100.0)),++ StackEntry::new(PanelKind::Properties, true, None),++ StackEntry::new(PanelKind::Align, false, Some(77.0)),+ ],+ };+ h.run_steps(3);+ let project = h.state().session.project.clone();+ let id = egui::Id::new(("dock-gutter", "s0".to_string()));+ h.ctx.memory_mut(|memory| memory.request_focus(id));+ h.run_steps(2);+ for pressed in [true, false] {+ h.event(Event::Key { key: egui::Key::ArrowDown, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE });+ h.step();+ }+ let DockNode::Stack { entries } = &h.state().ui.dock else { panic!("stack lost") };+ assert_eq!(entries[0].height, Some(108.0));+ let from = rect(&h, "dock.gutter.s0").center();+ drag(&mut h, from, from + vec2(0.0, 16.0), Modifiers::NONE);+ let DockNode::Stack { entries } = &h.state().ui.dock else { panic!("stack lost") };+ assert_eq!(entries[0].height, Some(124.0));+ assert_eq!(entries[1].height, None);- assert_eq!(entries[2], StackEntry { panel: PanelKind::Align, open: false, height: Some(77.0) });++ assert_eq!(entries[2], StackEntry::new(PanelKind::Align, false, Some(77.0)));+ assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));+}++#[test]+fn legacy_close_repairs_selection_but_transactions_remain_strict() {+ use effectcraft_ui_egui::dock::Floating;+ let mut root = DockNode::Tabs { panels: vec![PanelKind::Properties, PanelKind::Align, PanelKind::EffectsPresets], active: usize::MAX };+ root.close(PanelKind::History);+ assert!(root.is_visible(PanelKind::EffectsPresets));+ let mut layout = Layout {+ root: DockNode::Tabs { panels: vec![PanelKind::Composition], active: 0 },+ floating: vec![Floating {+ panels: vec![PanelKind::Properties, PanelKind::Align, PanelKind::EffectsPresets],+ active: usize::MAX,+ rect: [0.0, 0.0, 300.0, 200.0],+ }],+ };+ let before = layout.clone();+ assert!(layout.apply(Action::Close { panel: PanelKind::Properties }).is_err());+ assert_eq!(layout, before);+ assert!(layout.unfloat(PanelKind::Properties));+ assert_eq!(layout.floating[0].panels.get(layout.floating[0].active), Some(&PanelKind::EffectsPresets));+ layout.floating[0].rect = [0.0; 4];+ let before = layout.clone();+ assert!(!layout.unfloat(PanelKind::Align));+ assert_eq!(layout, before);+}++#[test]+fn failed_close_preserves_viewer_lifecycle_and_maximize_state() {+ let mut app = EffectcraftApp::new(Session::default());+ app.ui.dock = DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(42)], active: usize::MAX };+ app.ui.maximized = Some(PanelKind::Viewer(42));+ app.ui.viewers.insert(42, None);+ app.ui.active_viewer = 42;+ app.ui.locked_tabs.insert(PanelKind::Viewer(42).id());+ let before = app.ui.clone();+ app.close_panel(PanelKind::Viewer(42));+ assert_eq!(app.ui.dock, before.dock);+ assert_eq!(app.ui.maximized, before.maximized);+ assert_eq!(app.ui.viewers, before.viewers);+ assert_eq!(app.ui.active_viewer, before.active_viewer);+ assert_eq!(app.ui.locked_tabs, before.locked_tabs);+}diff --cc crates/ui-egui/tests/ui_panels.rsindex d58c2146d,7235b75d4..a71bebfeb--- a/crates/ui-egui/tests/ui_panels.rs+++ b/crates/ui-egui/tests/ui_panels.rs@@@ -117,6 -128,42 +128,42 @@@ fn hover(h: &mut Harness<'_, Effectcrafh.run_steps(3);}+ /// Issue #320: saved workspaces last between sessions (they were only kept in memory): a new+ /// app on the same settings store lists them and brings their layout back; renamed and deleted+ /// ones stay that way.+ #[test]+ fn saved_workspaces_persist_across_sessions() {+ use effectcraft_engine::config::{ConfigStore, MemoryConfig};+ use effectcraft_ui_egui::menus::invoke;+ let store = std::sync::Arc::new(MemoryConfig::default());+ let launch = || {+ let s = Session { config: Some(store.clone()), ..Default::default() };+ let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));+ h.run_steps(2);+ h+ };+ let mut h = launch();+ let ctx = h.ctx.clone();+ invoke(h.state_mut(), &ctx, "window.workspace", json!({"name": "Minimal"})).unwrap();+ invoke(h.state_mut(), &ctx, "window.saveWorkspaceAs", json!({"name": "My Layout"})).unwrap();+ invoke(h.state_mut(), &ctx, "window.saveWorkspaceAs", json!({"name": "Scratch"})).unwrap();+ let saved = h.state().ui.dock.clone();+ drop(h);+ let mut h = launch();+ assert_eq!(h.state().saved_workspace_names(), ["My Layout", "Scratch"]);- assert_eq!(h.state().ui.workspace, "Default");++ assert_eq!(h.state().ui.workspace, "Scratch");+ let ctx = h.ctx.clone();+ invoke(h.state_mut(), &ctx, "window.workspace", json!({"name": "My Layout"})).unwrap();+ assert_eq!(h.state().ui.dock, saved);+ invoke(h.state_mut(), &ctx, "window.editWorkspaces", json!({"name": "Scratch", "delete": true})).unwrap();+ invoke(h.state_mut(), &ctx, "window.editWorkspaces", json!({"name": "My Layout", "rename": "Edit Bay"})).unwrap();+ drop(h);+ assert_eq!(launch().state().saved_workspace_names(), ["Edit Bay"]);+ // A damaged file is ignored.+ store.write(effectcraft_ui_egui::WORKSPACES_FILE, "{not json").unwrap();+ assert!(launch().state().saved_workspace_names().is_empty());+ }+/// Issue #191: a workspace saved with Save as New Workspace is listed in Window ▸ Workspace/// (below the built-ins, where the submenu used to be cut off) and choosing it there brings its/// layout back.diff --cc crates/ui-egui/tests/ui_workspace_focus.rsindex c53b3aa42,000000000..f9dd3c47fmode 100644,000000..100644--- a/crates/ui-egui/tests/ui_workspace_focus.rs+++ b/crates/ui-egui/tests/ui_workspace_focus.rs@@@ -1,311 -1,0 +1,332 @@@+//! Workspaces survive a new frontend, and keyboard input follows real widget focus.++use std::sync::Arc;++use effectcraft_engine::Session;+use effectcraft_engine::config::{ConfigStore, DirConfig, MemoryConfig};+use effectcraft_ui_egui::EffectcraftApp;+use effectcraft_ui_egui::dock::{DockNode, PanelKind, SplitSize};+use effectcraft_ui_egui::state::Tool;+use egui::{Event, Id, Key, Modifiers, vec2};+use egui_kittest::Harness;+use serde_json::json;++#[test]+fn named_and_current_workspaces_survive_frontend_restart() {+ let store = Arc::new(MemoryConfig::default());+ let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });+ app.ui.dock = DockNode::Split {+ vertical: false,+ size: SplitSize::FixedA(345.0),+ a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 }),+ b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Layer], active: 1 }),+ };+ let ctx = egui::Context::default();+ effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name": "Restart layout"})).unwrap();+ let saved = app.ui.dock.clone();+ if let DockNode::Split { size, .. } = &mut app.ui.dock {+ *size = SplitSize::FixedA(390.0);+ }+ app.ui.focused = PanelKind::Layer;+ let current = app.ui.dock.clone();+ eframe::App::on_exit(&mut app);+ assert!(store.read("workspaces.json").is_some(), "workspace data must reach the configured store");+ let mut restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });+ assert_eq!(restarted.ui.workspace, "Restart layout");+ assert_eq!(restarted.ui.dock, current, "restore current unsaved divider changes independently of the named snapshot");+ assert_eq!(restarted.ui.saved_workspaces.get("Restart layout"), Some(&saved));+ assert_eq!(restarted.ui.focused, PanelKind::Layer);+ restarted.set_workspace("Default");+ restarted.set_workspace("Restart layout");+ assert_eq!(restarted.ui.dock, saved, "the named snapshot is separately available after restart");+}++fn key(h: &mut Harness<'_, EffectcraftApp>, key: Key, modifiers: Modifiers) {+ h.event(Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers });+ h.step();+ h.event(Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers });+ h.step();+ h.run_steps(2);+}++fn scratch_dir(label: &str) -> std::path::PathBuf {+ static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);+ let id = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);+ let path = std::env::temp_dir().join(format!("effectcraft-workspace-{label}-{}-{id}", std::process::id()));+ std::fs::create_dir(&path).unwrap();+ path+}++#[test]+fn native_config_read_is_byte_bounded_and_reports_errors() {+ let dir = scratch_dir("bounded-read");+ let config = DirConfig::new(&dir);+ assert!(config.read_bounded("missing", 4).unwrap().is_none());+ std::fs::write(dir.join("entry"), "é").unwrap();+ assert_eq!(config.read_bounded("entry", 2).unwrap().as_deref(), Some("é"));+ assert_eq!(config.read_bounded("entry", 1).unwrap_err().kind(), std::io::ErrorKind::InvalidData);+ std::fs::write(dir.join("entry"), [0xff, 0xfe]).unwrap();+ assert_eq!(config.read_bounded("entry", 4).unwrap_err().kind(), std::io::ErrorKind::InvalidData);+ std::fs::create_dir(dir.join("folder")).unwrap();+ assert!(config.read_bounded("folder", 4).is_err());+ std::fs::remove_dir_all(dir).unwrap();+}++#[test]+fn unreadable_native_workspace_is_preserved_after_later_layout_changes() {- for bytes in [vec![0xff, 0xfe], vec![b' '; 1024 * 1024 + 1], b"{".to_vec()] {++ for bytes in++ [vec![0xff, 0xfe], vec![b' '; 1024 * 1024 + 1], b"{".to_vec(), serde_json::to_vec(&json!({"version":2,"workspaces":{},"floating":{}})).unwrap()]++ {+ let dir = scratch_dir("preserve");+ let path = dir.join("workspaces.json");+ std::fs::write(&path, &bytes).unwrap();+ let mut app = EffectcraftApp::new(Session { config: Some(Arc::new(DirConfig::new(&dir))), ..Default::default() });+ let ctx = egui::Context::default();+ assert!(effectcraft_ui_egui::control::inspect(&app, &ctx)["workspaceStorageError"].is_string());+ app.set_workspace("Minimal");+ app.ui.focused = PanelKind::Project;++ effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name":"Must not overwrite"})).unwrap();+ eframe::App::on_exit(&mut app);+ assert_eq!(std::fs::read(&path).unwrap(), bytes);+ assert!(effectcraft_ui_egui::control::inspect(&app, &ctx)["workspaceStorageError"].is_string());+ std::fs::remove_dir_all(dir).unwrap();+ }+}+++#[test]++fn legacy_named_workspaces_migrate_once_and_survive_actual_app_restart() {++ let store = Arc::new(MemoryConfig::default());++ let saved = effectcraft_ui_egui::dock::workspace("Minimal");++ store.write("workspaces.json", &json!({"workspaces":{"Legacy":saved},"floating":{}}).to_string()).unwrap();++ let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });++ assert_eq!(app.ui.saved_workspaces.get("Legacy"), Some(&saved));++ app.set_workspace("Legacy");++ let ctx = egui::Context::default();++ effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name":"Migrated"})).unwrap();++ let text = store.read("workspaces.json").unwrap();++ assert_eq!(serde_json::from_str::<serde_json::Value>(&text).unwrap()["version"], 1);++ let restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });++ assert_eq!(restarted.ui.saved_workspaces.get("Legacy"), Some(&saved));++ assert_eq!(restarted.ui.saved_workspaces.get("Migrated"), Some(&saved));++ assert_eq!(restarted.ui.workspace, "Migrated");++}+++#[test]+fn tab_and_shift_tab_traverse_toolbar_and_space_activates_only_focused_tool() {+ let mut session = Session::default();+ session.execute("comp.new", json!({"width": 160, "height": 90, "duration": 1})).unwrap();+ session.execute("layer.newSolid", json!({"name": "Keep unchanged", "color": "#ff0000"})).unwrap();+ let project = session.project.clone();+ let mut app = EffectcraftApp::new(session);+ app.ui.start_screen = false;+ app.ui.show_menu_bar = false;+ let mut h = Harness::builder().with_size(vec2(1400.0, 900.0)).build_eframe(move |_| app);+ h.run_steps(3);+ for _ in 0..8 {+ key(&mut h, Key::Tab, Modifiers::NONE);+ if h.ctx.memory(|m| m.focused()) == Some(Id::new(("tool-slot", 0usize))) {+ break;+ }+ }+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 0usize))));+ key(&mut h, Key::Tab, Modifiers::NONE);+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 1usize))));+ assert_eq!(h.state().ui.tool, Tool::Selection, "focus movement alone must not select a tool");+ key(&mut h, Key::Tab, Modifiers::NONE);+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 2usize))));+ key(&mut h, Key::Tab, Modifiers::SHIFT);+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 1usize))));+ key(&mut h, Key::Space, Modifiers::NONE);+ assert_eq!(h.state().ui.tool, Tool::Hand);+ assert!(!h.state().playback.playing, "Space activates the focused widget, not preview playback");+ assert!(Arc::ptr_eq(&h.state().session.project, &project), "keyboard focus and tool selection do not modify the project");+ let response = h.ctx.read_response(Id::new(("tool-slot", 1usize))).unwrap();+ assert!(+ h.output().shapes.iter().any(|shape| {+ matches!(&shape.shape, egui::Shape::Rect(r) if r.rect == response.rect.shrink(1.0) && r.stroke.color == h.state().tokens.text && r.stroke.width > 0.0)+ }),+ "the custom-painted toolbar must visibly identify keyboard focus"+ );+ let inspected = effectcraft_ui_egui::control::inspect(h.state(), &h.ctx);+ assert_eq!(inspected["keyboardFocus"]["automationId"], "tools.Hand");+ assert_eq!(inspected["keyboardFocus"]["rect"], json!([response.rect.min.x, response.rect.min.y, response.rect.width(), response.rect.height()]));+}++#[test]+fn tab_traversal_activates_an_inactive_dock_tab_without_editing_the_project() {+ let mut session = Session::default();+ session.execute("comp.new", json!({"width": 160, "height": 90, "duration": 1})).unwrap();+ session.execute("layer.newSolid", json!({"name": "Keep unchanged", "color": "#ff0000"})).unwrap();+ let project = session.project.clone();+ let mut app = EffectcraftApp::new(session);+ app.ui.start_screen = false;+ app.ui.show_menu_bar = false;+ // Leave the inactive, layer-named tab visible instead of behind the overflow control.+ if let DockNode::Split { a, .. } = &mut app.ui.dock+ && let DockNode::Split { a, .. } = a.as_mut()+ && let DockNode::Split { size, .. } = a.as_mut()+ {+ *size = SplitSize::FixedA(420.0);+ }+ let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);+ h.run_steps(3);+ assert!(h.state().auto.find("panel.tab.EffectControls").is_some(), "the inactive tab must be visible in this fixture");+ let before = h.state().ui.dock.clone();+ let target = Id::new(("tab", "aaa".to_string(), 1usize));+ let mut tabs = 0;+ for _ in 0..80 {+ key(&mut h, Key::Tab, Modifiers::NONE);+ tabs += 1;+ if h.ctx.memory(|m| m.focused()) == Some(target) {+ break;+ }+ }+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(target));+ println!("Tab presses from no focus to Effect Controls: {tabs}");+ assert_eq!(h.state().ui.dock, before, "traversal alone must not activate a tab");+ key(&mut h, Key::Space, Modifiers::NONE);+ let mut activated = before;+ assert!(activated.activate(PanelKind::EffectControls));+ assert_eq!(h.state().ui.dock, activated);+ assert_eq!(h.state().ui.focused, PanelKind::EffectControls);+ assert!(!h.state().playback.playing);+ assert!(Arc::ptr_eq(&h.state().session.project, &project));+ let response = h.ctx.read_response(target).unwrap();+ assert!(+ h.output().shapes.iter().any(|shape| {+ matches!(&shape.shape, egui::Shape::Rect(r) if r.rect == response.rect.shrink(1.0) && r.stroke.color == h.state().tokens.text && r.stroke.width > 0.0)+ }),+ "the active dock tab must visibly retain keyboard focus"+ );+ let inspected = effectcraft_ui_egui::control::inspect(h.state(), &h.ctx);+ assert_eq!(inspected["keyboardFocus"]["automationId"], "panel.tab.EffectControls");+ key(&mut h, Key::Tab, Modifiers::SHIFT);+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tab", "aaa".to_string(), 0usize))));+ key(&mut h, Key::Enter, Modifiers::NONE);+ assert_eq!(h.state().ui.focused, PanelKind::Project);+ assert!(!h.state().playback.playing);+ assert!(Arc::ptr_eq(&h.state().session.project, &project));+}++struct ControlDriver {+ h: Harness<'static, EffectcraftApp>,+ tx: std::sync::mpsc::Sender<effectcraft_ui_egui::ControlRequest>,+}++impl ControlDriver {+ fn new() -> Self {+ let (tx, rx) = std::sync::mpsc::channel();+ let mut app = EffectcraftApp::new(Session::default()).with_control(rx);+ app.ui.start_screen = false;+ app.ui.show_menu_bar = false;+ let mut driver = Self { h: Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app), tx };+ driver.frames(4, true);+ driver.ok("engine.execute", json!({"command":"comp.new", "params":{"name":"Native Validation", "width":160,"height":90,"duration":1}}), true);+ driver.ok("engine.execute", json!({"command":"layer.newSolid", "params":{"name":"Validation Red","color":"#ff0000"}}), true);+ driver.ok("ui.set", json!({"focused":"Timeline"}), true);+ driver.ok("ui.key", json!({"key":"Z","command":true}), true);+ driver.ok("ui.key", json!({"key":"Z","command":true,"shift":true}), true);+ driver+ }++ fn frames(&mut self, count: usize, native_focused: bool) {+ for _ in 0..count {+ let ctx = self.h.ctx.clone();+ let mut raw = std::mem::take(self.h.input_mut());+ raw.focused = native_focused;+ if let Some(viewport) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {+ viewport.focused = Some(native_focused);+ }+ eframe::App::raw_input_hook(self.h.state_mut(), &ctx, &mut raw);+ *self.h.input_mut() = raw;+ self.h.step();+ }+ }++ fn ok(&mut self, method: &str, params: serde_json::Value, native_focused: bool) -> serde_json::Value {+ let (request, reply) = effectcraft_ui_egui::ControlRequest::new(method, params);+ self.tx.send(request).unwrap();+ for _ in 0..60 {+ self.frames(1, native_focused);+ if let Ok(result) = reply.try_recv() {+ assert_eq!(result["ok"], true, "{result}");+ self.frames(2, native_focused);+ return result["result"].clone();+ }+ }+ panic!("no control reply to {method}");+ }+}++#[test]+fn control_root_divider_drag_after_toolbar_and_dock_tab_keyboard_activation() {+ let mut d = ControlDriver::new();+ let project = d.h.state().session.project.clone();+ let times = d.h.state().session.state.times.clone();+ assert_eq!(d.h.state().ui.focused, PanelKind::Timeline);+ assert!(d.h.state().ui.mini_flowchart.is_none());+ d.ok("ui.click", json!({"id":"tools.Selection"}), true);+ for _ in 0..5 {+ d.ok("ui.key", json!({"key":"Tab"}), true);+ assert!(d.h.state().ui.mini_flowchart.is_none(), "Tab entering or traversing widgets must not also invoke the Timeline mini-flowchart shortcut");+ }+ d.ok("ui.key", json!({"key":"Tab","shift":true}), true);+ d.ok("ui.key", json!({"key":"Space"}), true);+ assert_eq!(d.h.state().ui.tool, Tool::Hand);+ d.ok("ui.key", json!({"key":"Tab","shift":true}), true);+ d.ok("ui.key", json!({"key":"Enter"}), true);+ assert_eq!(d.h.state().ui.tool, Tool::Selection);+ d.ok("ui.drag", json!({"from":{"id":"dock.gutter.aa","fx":0.5,"fy":0.5},"to":{"id":"dock.gutter.aa","fx":10.5,"fy":0.5},"steps":8}), true);+ d.ok("ui.click", json!({"id":"tools.Selection"}), true);+ // The toolbar can grow as upstream adds controls. Traverse to the actual response+ // identity rather than assuming a fixed number of focus stops.+ let target = Id::new(("tab", "aaa".to_string(), 1usize));+ for tabs in 1..=100 {+ d.ok("ui.key", json!({"key":"Tab"}), true);+ assert!(d.h.state().ui.mini_flowchart.is_none(), "dock-tab traversal must not open a foreground popup");+ if d.h.ctx.memory(|memory| memory.focused()) == Some(target) {+ println!("control Tab presses to Effect Controls: {tabs}");+ break;+ }+ }+ assert_eq!(d.h.ctx.memory(|memory| memory.focused()), Some(target), "Effect Controls must remain reachable by control-channel Tab traversal");+ d.ok("ui.key", json!({"key":"Space"}), true);+ assert_eq!(d.h.state().ui.focused, PanelKind::EffectControls);+ d.ok("ui.key", json!({"key":"Tab","shift":true}), true);+ d.ok("ui.key", json!({"key":"Enter"}), true);+ assert_eq!(d.h.state().ui.focused, PanelKind::Project);+ let before = d.h.state().ui.dock.clone();+ let gutter = d.h.state().auto.find("dock.gutter.").unwrap().rect;+ println!("root gutter before control drag: {gutter:?}; mini-flowchart: {:?}", d.h.state().ui.mini_flowchart);+ d.ok("ui.drag", json!({"from":{"id":"dock.gutter.","fx":0.5,"fy":0.5},"to":{"id":"dock.gutter.","fx":5.0,"fy":0.5},"steps":8}), true);+ assert_ne!(d.h.state().ui.dock, before, "the foreground root divider must still accept a drag after dock-tab keyboard activation");+ assert_eq!(d.h.state().session.state.times, times);+ assert!(Arc::ptr_eq(&d.h.state().session.project, &project));+ assert!(!d.h.state().playback.playing);+ for _ in 0..160 {+ d.ok("ui.key", json!({"key":"Tab"}), true);+ assert!(d.h.state().ui.mini_flowchart.is_none(), "wrapping widget traversal must not dispatch the application Tab binding");+ }+}++#[test]+fn unowned_tab_keeps_the_timeline_mini_flowchart_shortcut() {+ let mut session = Session::default();+ session.execute("comp.new", json!({"width":160,"height":90,"duration":1})).unwrap();+ let mut app = EffectcraftApp::new(session);+ app.ui.focused = PanelKind::Timeline;+ let ctx = egui::Context::default();+ let raw = egui::RawInput {+ events: vec![egui::Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }],+ ..Default::default()+ };+ let mut output = ctx.run_ui(raw, |ui| {+ let ctx = ui.ctx();+ effectcraft_ui_egui::menus::handle_shortcuts(&mut app, ctx);+ assert!(app.ui.mini_flowchart.is_none(), "application Tab waits until widgets can claim focus");+ assert!(!ctx.egui_wants_keyboard_input());+ effectcraft_ui_egui::menus::handle_tab_shortcut(&mut app, ctx);+ });+ output.textures_delta.clear();+ assert!(app.ui.mini_flowchart.is_some(), "an unowned Tab still invokes the application binding");+}