fix: drop unused imports

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

crates/anim/src/tests.rs

@@ -7,7 +7,10 @@ use deckcraft_model::{
     AnimClass, AnimStart, Animation, ColorRef, CustomShow, Presentation, Rgba, Shape, ShapeId, Slide, SlideId, TextBody, Transition, Xfrm,
 };
 
-use crate::*;
+use crate::{
+    AnimState, Layer, LinkJump, MotionPath, ShowAction, ShowState, Source, Timeline, TriggerPlay, default_path, ease, morph_crop, morph_frame,
+    morph_pairs, morph_xfrm, show_order, transition_frame, transition_layers,
+};
 
 const W: f64 = 960.0;
 const H: f64 = 540.0;

crates/anim/src/tests_interact.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use deckcraft_model::text::Action;
 use deckcraft_model::{AnimClass, AnimStart, Animation, Presentation, Shape, ShapeId, Slide, SlideId, Transition, Xfrm};
 
-use crate::*;
+use crate::{Click, HitShape, LinkJump, ShowAction, ShowState, Target, Timeline};
 
 fn shape(id: u32) -> Shape {
     Shape { id: ShapeId(id), name: format!("S{id}"), xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)), ..Default::default() }

crates/engine/src/cmd/animation.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use deckcraft_model::anim::{ANIMATIONS, AnimClass, AnimStart, Animation, TextBuild, animation_info};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, bool_or, bool_param, id_param, ok, str_param, targets, usize_param};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/arrange.rs

@@ -4,7 +4,7 @@ use deckcraft_geom::{Point, Rect, Xfrm};
 use deckcraft_model::{Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_or, edit_geometry, id_param, ok, str_param, targets, usize_param, with_param, xfrm_of};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/artistic.rs

@@ -9,7 +9,7 @@ use deckcraft_model::{MediaId, ShapeId, ShapeKind};
 use image::{GrayImage, Rgba, RgbaImage};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, str_param, targets};
 use crate::{Result, Session};
 
 /// The effects offered: `a14` element name and label.

crates/engine/src/cmd/background.rs

@@ -8,7 +8,7 @@ use std::collections::VecDeque;
 use deckcraft_model::{ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, base64_encode, f64_or, targets};
 use crate::{Result, Session};
 
 /// Larger pictures are refused rather than matted slowly (16 megapixels).

crates/engine/src/cmd/color_at_tests.rs

@@ -2,7 +2,7 @@
 
 use serde_json::{Value, json};
 
-use crate::*;
+use crate::Session;
 
 fn deck() -> Session {
     let mut s = Session::with_new();

crates/engine/src/cmd/compress.rs

@@ -8,7 +8,7 @@ use deckcraft_model::style::PictureFill;
 use deckcraft_model::{MediaId, Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_or, f64_param, targets};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/design.rs

@@ -10,7 +10,9 @@ use deckcraft_model::theme::{builtin_color_schemes, builtin_font_schemes, builti
 use deckcraft_model::{Background, Fill, PhType, Presentation, Shape, ShapeId, defaults};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{
+    CommandSpec, NO_ID_SPACE, bad, bool_or, bool_param, cmd, color_param, f64_param, ok, rect_param, shape, str_param, text, usize_param, with_param,
+};
 use crate::{Result, Session, Target};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/edit.rs

@@ -7,7 +7,7 @@ use deckcraft_model::text::TextBody;
 use deckcraft_model::{MediaId, Shape, ShapeId, Slide, SlideId};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, base64_encode, bool_or, id_param, ids_param, ok, richclip, str_param, targets, text, xfrm_of};
 use crate::{HistoryEntry, Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/file.rs

@@ -7,7 +7,7 @@ use deckcraft_media::MediaInfo;
 use deckcraft_model::{MediaId, MediaItem, Presentation, Shape, ShapeKind, defaults};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, base64_encode, bool_or, f64_or, ok, str_param, usize_param};
 use crate::{DocState, EngineError, Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/find.rs

@@ -6,7 +6,7 @@ use deckcraft_model::text::RunKind;
 use deckcraft_model::{Paragraph, Shape, ShapeKind, Slide, TextBody};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, bool_or, str_param, text};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/format.rs

@@ -8,7 +8,7 @@ use deckcraft_model::{ColorRef, ColorTransform, Effects, Fill, Line, SchemeSlot,
 use serde_json::{Value, json};
 
 use super::text::{format_body, format_para, format_run};
-use super::*;
+use super::{CommandSpec, bad, bool_or, bool_param, color_param, edit_shapes, f64_or, f64_param, ids_param, ok, str_param};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/ideas.rs

@@ -7,7 +7,7 @@ use deckcraft_geom::Xfrm;
 use deckcraft_model::{Fill, Presentation, Rgba, Shape, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, str_param, text, usize_param, xfrm_of};
 use crate::{Result, Selection, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/insert.rs

@@ -8,7 +8,10 @@ use deckcraft_model::text::{AutoFit, RunKind, TextBody};
 use deckcraft_model::{Chart, ColorRef, Fill, Geom, Line, MediaClip, Shape, ShapeId, ShapeKind, ShapeStyle, Table};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{
+    CommandSpec, NO_ID_SPACE, bad, base64_decode, base64_encode, bool_or, bool_param, edit_shapes, format, ok, rect_param, str_param, text,
+    usize_param, xfrm_of,
+};
 use crate::{EngineError, Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/inspect.rs

@@ -4,7 +4,7 @@ use deckcraft_model::resolve::{self, Ctx};
 use deckcraft_model::{Shape, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, id_param, str_param, usize_param, xfrm_of};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/media.rs

@@ -5,7 +5,7 @@
 use deckcraft_model::{MediaClip, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, base64_encode, bool_param, edit_shapes, targets};
 use crate::{EngineError, MediaStatus, Result, Session, UiRequest};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/merge.rs

@@ -9,7 +9,7 @@ use i_overlay::core::overlay_rule::OverlayRule;
 use i_overlay::float::single::SingleFloatOverlay;
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, base64_encode, str_param, targets, text, xfrm_of};
 use crate::{Result, Session};
 
 /// Closed polygons (slide points) describing a filled area (non-zero winding).

crates/engine/src/cmd/picture_style.rs

@@ -6,7 +6,7 @@ use deckcraft_model::style::{Effects, Reflection, Shadow};
 use deckcraft_model::{ColorRef, Geom, Line, Shape};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, edit_shapes, str_param};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/points.rs

@@ -10,7 +10,7 @@ use deckcraft_geom::{PathEl, Point, Xfrm};
 use deckcraft_model::{CustomPath, Geom, Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, f64_param, id_param, ok, str_param, xfrm_of};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/recolor.rs

@@ -6,7 +6,7 @@ use deckcraft_model::style::{PictureAdjust, PictureMode};
 use deckcraft_model::{ColorRef, Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, bool_or, current_shapes, edit_shapes, str_param, targets, text, xfrm_of};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/reuse.rs

@@ -13,7 +13,7 @@ use deckcraft_model::text::{Action, Hyperlink, RunProps, TextBody};
 use deckcraft_model::{LayoutId, MasterId, MediaId, Presentation, ShapeId, ShapeKind, Slide, SlideId};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_or, cmd, slide, text, usize_param};
 use crate::{Result, Session, media_refs};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/review.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use deckcraft_model::Comment;
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, base64_decode, bool_or, bool_param, f64_or, id_param, ok, str_param, text, usize_param};
 use crate::{Result, Session, Target, UiRequest};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/selection.rs

@@ -5,7 +5,7 @@
 use deckcraft_model::{Shape, ShapeId};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, bad, bool_or, id_param, ids_param, ok};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/selection_tests.rs

@@ -2,8 +2,8 @@
 
 use serde_json::{Value, json};
 
+use crate::Session;
 use crate::tools::{Mods, PointerEvent, PointerKind};
-use crate::*;
 
 /// A blank slide with A, B, C (back to front) and G = group [D, H = group [E, F]] in front.
 fn deck() -> (Session, Vec<u32>) {

crates/engine/src/cmd/shape.rs

@@ -8,7 +8,10 @@ use deckcraft_model::style::{Dash, Glow, Gradient, GradientShape, GradientStop,
 use deckcraft_model::{ColorRef, Effects, Fill, Geom, Line, ShapeStyle};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{
+    CommandSpec, NO_ID_SPACE, bad, bool_or, bool_param, color_param, color_value, edit_geometry, edit_shapes, f64_param, format, id_param, ok,
+    str_param, targets, text, three_d, usize_param, with_param, xfrm_of,
+};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/slide.rs

@@ -6,7 +6,7 @@ use deckcraft_model::text::TextBody;
 use deckcraft_model::{LayoutId, LayoutType, Presentation, Section, SlideId, defaults};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_or, bool_param, ok, opt_usize_param, str_param, text, usize_param};
 use crate::{Result, Session, Target};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/smartart.rs

@@ -14,7 +14,7 @@ use deckcraft_model::{
 };
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_or, current_shapes, shape_of, str_param, targets, text, xfrm_of};
 use crate::{EngineError, Result, Session};
 
 /// Deepest outline level the Text Pane allows.

crates/engine/src/cmd/table.rs

@@ -4,7 +4,10 @@ use deckcraft_geom::{Affine, Point, Rect};
 use deckcraft_model::{Shape, ShapeKind, Table};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{
+    CommandSpec, bad, bool_or, bool_param, color_param, edit_shapes, f64_param, id_param, ok, str_param, table_drawn_heights, targets, usize_param,
+    xfrm_of,
+};
 use crate::{DocState, Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/text.rs

@@ -9,7 +9,9 @@ use deckcraft_model::text::{Align, AutoFit, Hyperlink, Paragraph, Run, RunKind,
 use deckcraft_model::{Presentation, Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{
+    CommandSpec, NO_TEXT_POINT, SELECT_TEXT_OR_SHAPE, bad, bool_or, cmd, edit_shapes, format, id_param, ok, shape_of, str_param, text, xfrm_of,
+};
 use crate::{DocState, Result, Selection, Session, Target, TextSel};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/transition.rs

@@ -6,7 +6,7 @@ use deckcraft_model::Transition;
 use deckcraft_model::anim::TRANSITIONS;
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_param, ok, str_param, usize_param};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/zoom.rs

@@ -13,7 +13,7 @@ use deckcraft_model::text::{Action, Hyperlink, TextBody};
 use deckcraft_model::{LayoutType, Shape, ShapeId, ShapeKind, SlideId, defaults};
 use serde_json::{Value, json};
 
-use super::*;
+use super::{CommandSpec, NO_ID_SPACE, bad, bool_or, str_param};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/soak_tests.rs

@@ -9,7 +9,7 @@ use std::collections::VecDeque;
 
 use serde_json::{Value, json};
 
-use crate::*;
+use crate::{EngineError, Session, command_specs, sample};
 
 /// Commands that touch the file system, other windows or real time; the soak drives the rest.
 fn skipped(id: &str) -> bool {

crates/engine/src/tests.rs

@@ -1,6 +1,8 @@
 use serde_json::json;
 
-use crate::*;
+use crate::{
+    DocState, History, Presentation, Session, Target, TextSel, ToolKind, Value, cmd, command_specs, connect, find_command, model, sample, tools,
+};
 
 fn session() -> Session {
     Session::with_new()

crates/format/src/chart_parts_tests.rs

@@ -1,4 +1,4 @@
-use super::*;
+use super::Presentation;
 use deckcraft_model::chart::{Chart, ChartPart, ChartRel, ChartType};
 use deckcraft_model::{Master, Shape, ShapeId};
 use serde_json::{Value, json};

crates/geom/src/preset/extra.rs

@@ -2,7 +2,10 @@
 //! ribbons, gears, tabs and chart markers. Like the rest of `preset`, every outline is our own
 //! construction, fitted to how the shapes look and to what their adjust values mean.
 
-use super::*;
+use super::{
+    Corner, Dir, FillMode, Geometry, Handle, Pb, Point, Rect, Vec2, corner_rect, fill, fill_eo, fill_only, mid_sites, orient, shade, simple,
+    stroke_only, vis,
+};
 
 /// Builds the presets this module knows; `None` for any other name.
 pub(super) fn build(name: &str, w: f64, h: f64, a: &dyn Fn(usize) -> f64) -> Option<Geometry> {

crates/geom/src/warp/tests.rs

@@ -1,4 +1,6 @@
-use super::*;
+use super::{
+    Band, BezPath, CATALOG, Guide, Point, Rect, WarpLine, adjust_count, adjust_defaults, band_of_line, handles, is_follow, is_supported, warp,
+};
 
 const W: f64 = 420.0;
 const H: f64 = 200.0;

crates/h264/src/dpb.rs

@@ -3,7 +3,7 @@
 
 use crate::error::{Result, ensure};
 use crate::picture::{FrameRef, RefPic};
-use crate::slice::{Mmco, RefPicListMod, SliceHeader, SliceType};
+use crate::slice::{Mmco, SliceHeader, SliceType};
 use std::sync::Arc;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -174,103 +174,6 @@ impl Dpb {
         }
     }
 
-    /// Initial reference picture lists (8.2.4.2) as DPB entries.
-    fn initial_entry_lists<'a>(
-        sh: &SliceHeader,
-        cur_poc: i32,
-        short: &[&'a DpbEntry],
-        long: &[&'a DpbEntry],
-        pic_num: impl Fn(&DpbEntry) -> i32,
-    ) -> [Vec<&'a DpbEntry>; 2] {
-        let mut entry_lists: [Vec<&'a DpbEntry>; 2] = [Vec::new(), Vec::new()];
-        if sh.slice_type != SliceType::B {
-            let mut s = short.to_vec();
-            s.sort_by_key(|e| std::cmp::Reverse(pic_num(e)));
-            entry_lists[0] = s.into_iter().chain(long.iter().copied()).collect();
-        } else {
-            let mut before: Vec<&'a DpbEntry> = short.iter().copied().filter(|e| e.poc < cur_poc).collect();
-            let mut after: Vec<&'a DpbEntry> = short.iter().copied().filter(|e| e.poc > cur_poc).collect();
-            before.sort_by_key(|e| std::cmp::Reverse(e.poc));
-            after.sort_by_key(|e| e.poc);
-            entry_lists[0] = before.iter().chain(after.iter()).chain(long.iter()).copied().collect();
-            entry_lists[1] = after.iter().chain(before.iter()).chain(long.iter()).copied().collect();
-            if entry_lists[1].len() > 1 && entry_lists[0].len() == entry_lists[1].len() {
-                let same = entry_lists[0].iter().zip(entry_lists[1].iter()).all(|(a, b)| std::ptr::eq(*a, *b));
-                if same {
-                    entry_lists[1].swap(0, 1);
-                }
-            }
-        }
-        entry_lists
-    }
-
-    /// Reference picture list modification (8.2.4.3) of one list; `n` is num_ref_idx_active.
-    fn modify_ref_list<'a>(
-        list: &mut Vec<Option<&'a DpbEntry>>,
-        mods: &[RefPicListMod],
-        n: usize,
-        cur_fn: u32,
-        max_frame_num: u32,
-        short: &[&'a DpbEntry],
-        long: &[&'a DpbEntry],
-    ) -> Result<()> {
-        let max_pic_num = max_frame_num as i32;
-        let curr_pic_num = cur_fn as i32;
-        let mut pred = curr_pic_num;
-        let mut ref_idx = 0usize;
-        for m in mods {
-            ensure!(ref_idx < n, "too many ref_pic_list_modification entries");
-            list.push(None); // temporarily one longer
-            let (target, is_long): (Option<&DpbEntry>, bool) = match m.idc {
-                0 | 1 => {
-                    let d = m.value as i32 + 1;
-                    let no_wrap = if m.idc == 0 {
-                        if pred - d < 0 { pred - d + max_pic_num } else { pred - d }
-                    } else if pred + d >= max_pic_num {
-                        pred + d - max_pic_num
-                    } else {
-                        pred + d
-                    };
-                    pred = no_wrap;
-                    let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap };
-                    (short.iter().copied().find(|e| Self::frame_num_wrap(e, cur_fn, max_frame_num) == pn), false)
-                }
-                2 => (long.iter().copied().find(|e| e.long_term_frame_idx == m.value), true),
-                _ => continue,
-            };
-            let Some(target) = target else {
-                // Missing picture: keep the list unchanged (error concealment).
-                list.pop();
-                ref_idx += 1;
-                continue;
-            };
-            for c in (ref_idx + 1..=n).rev() {
-                list[c] = list[c - 1];
-            }
-            list[ref_idx] = Some(target);
-            ref_idx += 1;
-            let mut nidx = ref_idx;
-            for c in ref_idx..=n {
-                let keep = match list[c] {
-                    None => true,
-                    Some(e) => {
-                        if is_long {
-                            !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx)
-                        } else {
-                            !(e.mark == RefMark::Short && std::ptr::eq(e, target))
-                        }
-                    }
-                };
-                if keep {
-                    list[nidx] = list[c];
-                    nidx += 1;
-                }
-            }
-            list.truncate(n);
-        }
-        Ok(())
-    }
-
     /// Initial reference picture lists (8.2.4.2) + modification (8.2.4.3) for a frame slice.
     pub fn build_ref_lists(&self, sh: &SliceHeader, cur_poc: i32, max_frame_num: u32) -> Result<[Vec<RefPic>; 2]> {
         let mut lists: [Vec<RefPic>; 2] = [Vec::new(), Vec::new()];
@@ -283,7 +186,25 @@ impl Dpb {
         let mut long: Vec<&DpbEntry> = self.entries.iter().filter(|e| e.mark == RefMark::Long).collect();
         long.sort_by_key(|e| e.long_term_frame_idx);
         let to_ref = |e: &&DpbEntry| RefPic { frame: e.frame.clone(), long_term: e.mark == RefMark::Long };
-        let entry_lists = Self::initial_entry_lists(sh, cur_poc, &short, &long, pic_num);
+        let mut entry_lists: [Vec<&DpbEntry>; 2] = [Vec::new(), Vec::new()];
+        if sh.slice_type != SliceType::B {
+            let mut s = short.clone();
+            s.sort_by_key(|e| std::cmp::Reverse(pic_num(e)));
+            entry_lists[0] = s.into_iter().chain(long.iter().copied()).collect();
+        } else {
+            let mut before: Vec<&DpbEntry> = short.iter().copied().filter(|e| e.poc < cur_poc).collect();
+            let mut after: Vec<&DpbEntry> = short.iter().copied().filter(|e| e.poc > cur_poc).collect();
+            before.sort_by_key(|e| std::cmp::Reverse(e.poc));
+            after.sort_by_key(|e| e.poc);
+            entry_lists[0] = before.iter().chain(after.iter()).chain(long.iter()).copied().collect();
+            entry_lists[1] = after.iter().chain(before.iter()).chain(long.iter()).copied().collect();
+            if entry_lists[1].len() > 1 && entry_lists[0].len() == entry_lists[1].len() {
+                let same = entry_lists[0].iter().zip(entry_lists[1].iter()).all(|(a, b)| std::ptr::eq(*a, *b));
+                if same {
+                    entry_lists[1].swap(0, 1);
+                }
+            }
+        }
         let nlists = if sh.slice_type == SliceType::B { 2 } else { 1 };
         for l in 0..nlists {
             let n = sh.num_ref_idx_active[l] as usize;
@@ -291,7 +212,60 @@ impl Dpb {
             list.truncate(n);
             list.resize(n, None);
             if !sh.ref_pic_list_mod[l].is_empty() {
-                Self::modify_ref_list(&mut list, &sh.ref_pic_list_mod[l], n, cur_fn, max_frame_num, &short, &long)?;
+                let max_pic_num = max_frame_num as i32;
+                let curr_pic_num = cur_fn as i32;
+                let mut pred = curr_pic_num;
+                let mut ref_idx = 0usize;
+                for m in &sh.ref_pic_list_mod[l] {
+                    ensure!(ref_idx < n, "too many ref_pic_list_modification entries");
+                    list.push(None); // temporarily one longer
+                    let (target, is_long): (Option<&DpbEntry>, bool) = match m.idc {
+                        0 | 1 => {
+                            let d = m.value as i32 + 1;
+                            let no_wrap = if m.idc == 0 {
+                                if pred - d < 0 { pred - d + max_pic_num } else { pred - d }
+                            } else if pred + d >= max_pic_num {
+                                pred + d - max_pic_num
+                            } else {
+                                pred + d
+                            };
+                            pred = no_wrap;
+                            let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap };
+                            (short.iter().copied().find(|e| pic_num(e) == pn), false)
+                        }
+                        2 => (long.iter().copied().find(|e| e.long_term_frame_idx == m.value), true),
+                        _ => continue,
+                    };
+                    let Some(target) = target else {
+                        // Missing picture: keep the list unchanged (error concealment).
+                        list.pop();
+                        ref_idx += 1;
+                        continue;
+                    };
+                    for c in (ref_idx + 1..=n).rev() {
+                        list[c] = list[c - 1];
+                    }
+                    list[ref_idx] = Some(target);
+                    ref_idx += 1;
+                    let mut nidx = ref_idx;
+                    for c in ref_idx..=n {
+                        let keep = match list[c] {
+                            None => true,
+                            Some(e) => {
+                                if is_long {
+                                    !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx)
+                                } else {
+                                    !(e.mark == RefMark::Short && std::ptr::eq(e, target))
+                                }
+                            }
+                        };
+                        if keep {
+                            list[nidx] = list[c];
+                            nidx += 1;
+                        }
+                    }
+                    list.truncate(n);
+                }
             }
             // Fill missing entries (should not happen in conforming streams) with the first valid entry.
             let fallback = list.iter().flatten().next().copied().or_else(|| self.entries.last());
@@ -301,81 +275,85 @@ impl Dpb {
         Ok(lists)
     }
 
-    /// One memory management control operation; returns true for MMCO 5.
-    fn apply_mmco(&mut self, m: &Mmco, cur_frame_num: u32, max_frame_num: u32, cur_long: &mut Option<u32>) -> bool {
-        let mut had5 = false;
-        let curr_pic_num = cur_frame_num as i32;
-        match m.op {
-            1 => {
-                let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-            }
-            2 => {
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_pic_num {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-            }
-            3 => {
-                let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
-                        e.mark = RefMark::Long;
-                        e.long_term_frame_idx = m.long_term_frame_idx;
-                    }
-                }
-            }
-            4 => {
-                let max = m.max_long_term_frame_idx_plus1;
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && (max == 0 || e.long_term_frame_idx > max - 1) {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-                self.max_long_term_frame_idx = if max == 0 { None } else { Some(max - 1) };
-            }
-            5 => {
-                for e in &mut self.entries {
-                    e.mark = RefMark::Unused;
-                }
-                self.max_long_term_frame_idx = None;
-                had5 = true;
-            }
-            6 => {
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-                *cur_long = Some(m.long_term_frame_idx);
-            }
-            _ => {}
-        }
-        had5
-    }
-
     /// Adaptive memory control (8.2.5.4). Returns true if MMCO 5 was executed.
     fn apply_mmcos(&mut self, mmcos: &[Mmco], cur_frame_num: u32, max_frame_num: u32, cur_long: &mut Option<u32>) -> bool {
         let mut had5 = false;
+        let curr_pic_num = cur_frame_num as i32;
         for m in mmcos {
-            had5 |= self.apply_mmco(m, cur_frame_num, max_frame_num, cur_long);
+            match m.op {
+                1 => {
+                    let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
+                            e.mark = RefMark::Unused;
+                        }
+                    }
+                }
+                2 => {
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_pic_num {
+                            e.mark = RefMark::Unused;
+                        }
+                    }
+                }
+                3 => {
+                    let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
+                            e.mark = RefMark::Unused;
+                        }
+                    }
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
+                            e.mark = RefMark::Long;
+                            e.long_term_frame_idx = m.long_term_frame_idx;
+                        }
+                    }
+                }
+                4 => {
+                    let max = m.max_long_term_frame_idx_plus1;
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Long && (max == 0 || e.long_term_frame_idx > max - 1) {
+                            e.mark = RefMark::Unused;
+                        }
+                    }
+                    self.max_long_term_frame_idx = if max == 0 { None } else { Some(max - 1) };
+                }
+                5 => {
+                    for e in &mut self.entries {
+                        e.mark = RefMark::Unused;
+                    }
+                    self.max_long_term_frame_idx = None;
+                    had5 = true;
+                }
+                6 => {
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
+                            e.mark = RefMark::Unused;
+                        }
+                    }
+                    *cur_long = Some(m.long_term_frame_idx);
+                }
+                _ => {}
+            }
         }
         self.prune();
         had5
     }
 
-    /// Reference marking of the current picture (8.2.5); returns (mark, long-term idx, MMCO 5 executed).
-    fn mark_current(&mut self, sh: &SliceHeader, max_frame_num: u32, max_num_ref_frames: usize) -> (RefMark, u32, bool) {
+    /// Reference marking for the just-decoded picture and insertion into the DPB with output bumping.
+    /// Returns pictures ready for output.
+    #[allow(clippy::too_many_arguments)]
+    pub fn store_picture(
+        &mut self,
+        sh: &SliceHeader,
+        frame: FrameRef,
+        poc: i32,
+        max_frame_num: u32,
+        max_num_ref_frames: usize,
+        meta: Arc<OutputMeta>,
+        out: &mut Vec<Output>,
+    ) {
         let mut mark = RefMark::Unused;
         let mut long_idx = 0;
         let mut had5 = false;
@@ -407,12 +385,12 @@ impl Dpb {
                 }
             }
         }
-        (mark, long_idx, had5)
-    }
-
-    /// Bumping until there is space (C.4.5.1 / C.4.5.2). Returns true when the (non-reference) current
-    /// picture has the smallest POC and is to be output directly instead of being stored.
-    fn bump_for_space(&mut self, mark: RefMark, poc: i32, out: &mut Vec<Output>) -> bool {
+        if had5 {
+            // All earlier pictures are output before the current one (C.4.4).
+            self.flush(out);
+        }
+        let frame_num = if had5 { 0 } else { sh.frame_num };
+        // Bumping until there is space (C.4.5.1 / C.4.5.2).
         if mark == RefMark::Unused {
             loop {
                 let waiting = self.entries.len();
@@ -422,7 +400,8 @@ impl Dpb {
                 // non-reference picture with the smallest POC is output directly
                 let min_poc = self.entries.iter().filter(|e| e.needed_for_output).map(|e| e.poc).min();
                 if min_poc.is_none_or(|m| poc < m) {
-                    return true;
+                    out.push(Output { frame, poc, meta });
+                    return;
                 }
                 if !self.bump(out) {
                     break;
@@ -435,32 +414,6 @@ impl Dpb {
                 }
             }
         }
-        false
-    }
-
-    /// Reference marking for the just-decoded picture and insertion into the DPB with output bumping.
-    /// Returns pictures ready for output.
-    #[allow(clippy::too_many_arguments)]
-    pub fn store_picture(
-        &mut self,
-        sh: &SliceHeader,
-        frame: FrameRef,
-        poc: i32,
-        max_frame_num: u32,
-        max_num_ref_frames: usize,
-        meta: Arc<OutputMeta>,
-        out: &mut Vec<Output>,
-    ) {
-        let (mark, long_idx, had5) = self.mark_current(sh, max_frame_num, max_num_ref_frames);
-        if had5 {
-            // All earlier pictures are output before the current one (C.4.4).
-            self.flush(out);
-        }
-        let frame_num = if had5 { 0 } else { sh.frame_num };
-        if self.bump_for_space(mark, poc, out) {
-            out.push(Output { frame, poc, meta });
-            return;
-        }
         self.entries.push(DpbEntry {
             frame,
             poc,

crates/model/src/tests.rs

@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Cell, Fill, LayoutType, PhType, Presentation, Run, SchemeSlot, Shape, ShapeKind, ShapeStyle, Slide, TextBody, Theme, Xfrm, defaults, resolve,
+    style, text, theme, walk,
+};
 use crate::resolve::Ctx;
 
 #[test]

crates/ogg/src/tests.rs

@@ -1,6 +1,6 @@
 //! Synthetic Ogg streams: a small page writer (RFC 3533) and Opus-like packets.
 
-use super::*;
+use super::{Codec, Error, OpusTiming, Packet, Stream, crc32, open, opus_packet_samples, sniff};
 
 /// Write one page holding `segments` (lacing already computed by `lace`).
 fn page(out: &mut Vec<u8>, flags: u8, granule: i64, serial: u32, seq: u32, lacing: &[u8], body: &[u8]) {

crates/pdf/src/tests.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use super::*;
+use super::{Font, PageLayout, PdfError, PdfOptions, Presentation, export, handout_boxes, raster_scale};
 use deckcraft_model::text::TextBody;
 
 fn deck(n: usize) -> Presentation {

crates/render/src/tests.rs

@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Ctx, Fill, Image, Opts, PathMorph, Point, Rect, RenderOpts, Renderer, SlideFields, TextMorph, crop_dest, dpi_for_scale, gif_frame, image_dpi,
+    images, morph_path, morph_text, parse_path, place_slide, render_blend, render_shapes, render_slide, text_transform,
+};
 use deckcraft_model::chart::{ChartType, Trendline, TrendlineType};
 use deckcraft_model::style::ColorRef;
 use deckcraft_model::text::TextBody;

crates/render/src/tests_wild.rs

@@ -1,7 +1,10 @@
 //! Render tests for shape, line, fill and effect cases checked against PowerPoint's own exports
 //! of synthetic "wild" slides (observed black-box; see `plan/powerpoint/tools/gen_wild.py`).
 
-use super::*;
+use super::{
+    BezPath, Fill, Image, Line, MAX_DASHES, PathEl, Point, Rect, RenderOpts, ShapeKind, dash_with_caps, head_size, images, limit_dash_count, paint,
+    preset, render_slide, trim_ends,
+};
 use deckcraft_color::Rgba;
 use deckcraft_model::style::ColorRef;
 use deckcraft_model::{CustomPath, Geom, Presentation, Shape, ShapeId, Xfrm};

crates/text/src/tests.rs

@@ -1,4 +1,9 @@
-use super::*;
+use super::{
+    Affinity, Align, Anchor, Arc, AutoFit, BodyProps, Bullet, Caps, Cell, Ctx, Dash, Deco, DecoLine, FontDb, FontFace, GlyphRun, LINE_PITCH,
+    MoveMode, NoFields, Opts, ParaProps, Point, Pos, Rect, Rgba, SUB_SUPER, Shape, Spacing, Strike, TextBody, TextLayout, autonum,
+    break_opportunities, caps_char, chinese_num, covers_symbol, is_symbol_font, is_upright, layout, layout_scaled, map_symbol_bullet, measure_str,
+    resolve, shaping_features, symbol_char, symbol_font_char, symbol_font_draw, symbol_unicode, symbol_unicode_alts,
+};
 use deckcraft_model::Fill;
 use deckcraft_model::defaults;
 use deckcraft_model::text::{Paragraph, Run};

crates/ui-egui/src/backstage_tests.rs

@@ -12,7 +12,7 @@ use egui_kittest::Harness;
 use egui_kittest::kittest::Queryable;
 use serde_json::json;
 
-use super::*;
+use super::theme;
 use crate::{Services, SlideApp};
 
 fn harness(app: SlideApp) -> Harness<'static, SlideApp> {