diff --git a/crates/rustmotion-components/src/gif.rs b/crates/rustmotion-components/src/gif.rs
index b5698604..5a0d918d 100644
--- a/crates/rustmotion-components/src/gif.rs
+++ b/crates/rustmotion-components/src/gif.rs
@@ -455,9 +455,9 @@ mod tests {
     /// own video is, so passing generous `max_w`/`max_h` here isolates the
     /// byte-budget check from the video-dimensions check exercised by the
     /// next test. 144 MiB is deliberately far short of the 65535×65535
-    /// (~17 GiB) header a real crafted file could declare — large enough to
-    /// prove the budget check fires, small enough that running this test
-    /// never risks the allocation it is asserting never happens.
+    /// (~17 GiB) header the audit's own crafted file could declare — large
+    /// enough to prove the budget check fires, small enough that running
+    /// this test never risks the allocation it is asserting never happens.
     #[test]
     fn a_canvas_over_the_byte_budget_is_rejected_without_allocating_it() {
         let path = std::env::temp_dir().join(format!(
diff --git a/crates/rustmotion-components/src/table.rs b/crates/rustmotion-components/src/table.rs
index ab882664..06e90ff4 100644
--- a/crates/rustmotion-components/src/table.rs
+++ b/crates/rustmotion-components/src/table.rs
@@ -419,7 +419,9 @@ mod tests {
         // probe specifically for near-white text ink rather than any lit
         // pixel (the header/row backgrounds paint regardless of font-size).
         let text_ink = buf
-            .chunks_exact(4)
+            .as_chunks::<4>()
+            .0
+            .iter()
             .filter(|p| p[3] > 0 && p[0] > 200 && p[1] > 200 && p[2] > 200)
             .count();
         assert!(
diff --git a/crates/rustmotion-components/src/video.rs b/crates/rustmotion-components/src/video.rs
index 1500dbb5..cae7b018 100644
--- a/crates/rustmotion-components/src/video.rs
+++ b/crates/rustmotion-components/src/video.rs
@@ -176,7 +176,7 @@ impl Painter for Video {
                 let img_info = ImageInfo::new(
                     (fw as i32, fh as i32),
                     ColorType::RGBA8888,
-                    skia_safe::AlphaType::Premul,
+                    skia_safe::AlphaType::Unpremul,
                     None,
                 );
                 let row_bytes = fw as usize * 4;
diff --git a/crates/rustmotion-components/tests/audit_ws_d.rs b/crates/rustmotion-components/tests/audit_ws_d.rs
index e884b076..7ac9dbd8 100644
--- a/crates/rustmotion-components/tests/audit_ws_d.rs
+++ b/crates/rustmotion-components/tests/audit_ws_d.rs
@@ -281,3 +281,43 @@ fn without_loop_video_playback_still_clamps_not_wraps() {
         "no loop_video: must clamp to the window's end (nearest: yellow), not wrap"
     );
 }
+
+// ─── cached-frame draw path mistagged straight alpha as premultiplied ──────
+
+/// ffmpeg's `-pix_fmt rgba` output — what fills the video-frame cache — is
+/// straight (unpremultiplied) alpha. Tagging that buffer `AlphaType::Premul`
+/// makes Skia treat the RGB channels as already scaled by alpha instead of
+/// scaling them itself, which brightens (here: doubles) every
+/// semi-transparent pixel's channels once composited.
+///
+/// A straight-alpha (200, 100, 50, 128) pixel, composited over black:
+/// correctly tagged `Unpremul`, Skia premultiplies it to
+/// (200×128/255, 100×128/255, 50×128/255) ≈ (100, 50, 25) before compositing
+/// over black, landing there almost exactly (the `(1 - alpha) * 0` background
+/// term vanishes either way). Mistagged `Premul`, Skia uses the raw channel
+/// values directly as if already scaled — (200, 100, 50) — composited over
+/// black with no further scaling, landing at roughly double the correct
+/// result.
+#[test]
+fn cached_frame_straight_alpha_composites_correctly_not_doubled() {
+    let src = unique_src("alpha");
+    let cache_key = format!("{src}:10x10");
+    let straight = [200u8, 100, 50, 128];
+    video_frame_cache().insert(
+        cache_key,
+        Arc::new(vec![(0.0, solid_rgba(straight, 2, 2), 2, 2)]),
+    );
+
+    let v = video(&src, ImageFit::Fill, None, None, None);
+    let ctx = ctx_at(0.0);
+    let pixels = paint_and_read(&v, &ctx, 10, 10, false);
+    let composited = px(&pixels, 10, 5, 5);
+
+    let close = |actual: u8, expected: u8| (actual as i16 - expected as i16).abs() <= 4;
+    assert!(
+        close(composited[0], 100) && close(composited[1], 50) && close(composited[2], 25),
+        "straight-alpha (200,100,50,128) over black must composite to roughly (100,50,25), \
+         got {composited:?} — a value near (200,100,50) means the buffer is still mistagged \
+         as premultiplied and its channels are being used unscaled"
+    );
+}
diff --git a/crates/rustmotion-components/tests/audit_ws_i.rs b/crates/rustmotion-components/tests/audit_ws_i.rs
index 358e2c9c..46a94cbd 100644
--- a/crates/rustmotion-components/tests/audit_ws_i.rs
+++ b/crates/rustmotion-components/tests/audit_ws_i.rs
@@ -134,7 +134,9 @@ fn paint_card_with_child(card_json: serde_json::Value) -> PaintedScene {
 
 fn count_dominant(pixels: &[u8], dominant: usize, muted: &[usize]) -> usize {
     pixels
-        .chunks_exact(4)
+        .as_chunks::<4>()
+        .0
+        .iter()
         .filter(|p| p[dominant] > 180 && muted.iter().all(|&m| p[m] < 80))
         .count()
 }
@@ -213,7 +215,7 @@ fn text_own_color_wins_over_cascaded_card_color_at_paint_time() {
 }
 
 fn any_ink_above_black_below_y(pixels: &[u8], width: i32, y_threshold: i32) -> bool {
-    pixels.chunks_exact(4).enumerate().any(|(i, p)| {
+    pixels.as_chunks::<4>().0.iter().enumerate().any(|(i, p)| {
         let y = i as i32 / width;
         y > y_threshold && (p[0] > 20 || p[1] > 20 || p[2] > 20)
     })
diff --git a/crates/rustmotion-core/src/css/taffy_bridge.rs b/crates/rustmotion-core/src/css/taffy_bridge.rs
index e30401ce..7ee1fbce 100644
--- a/crates/rustmotion-core/src/css/taffy_bridge.rs
+++ b/crates/rustmotion-core/src/css/taffy_bridge.rs
@@ -246,7 +246,7 @@ pub fn to_taffy_style(css: &CssStyle, ctx: &ConversionContext) -> tf::Style {
 /// = padding + border`) subtracts from a leaf's `available_space` before
 /// handing it to the measure function — see [`crate::engine::layout_pass`],
 /// which uses this to bring `known_dimensions` (still border-box) into that
-/// same content-box space. Percentage padding/border resolves
+/// same content-box space (RM-27). Percentage padding/border resolves
 /// against `ctx.length.parent_size` like every other percentage in this
 /// module; a leaf's own known/available width is not threaded here, so a
 /// percentage inset on a leaf is only as accurate as that shared context.
diff --git a/crates/rustmotion-core/src/engine/animator.rs b/crates/rustmotion-core/src/engine/animator.rs
index be2dce5e..ba343334 100644
--- a/crates/rustmotion-core/src/engine/animator.rs
+++ b/crates/rustmotion-core/src/engine/animator.rs
@@ -2867,7 +2867,7 @@ mod spring_duration_tests {
         // at t=0.8s: spring_value_raw(0.8, 6, 120, 1) ~= 1.027616 — 2.76%
         // past the target, well outside any reasonable rest_threshold
         // (default 0.5%). An author asking this spring to "finish at 0.8s"
-        // got a value nowhere near rest. Reference recomputed when the
+        // got a value nowhere near rest. Reference recomputed for RM-09
         // (issue #220): the solver's underdamped branch fed the wrong
         // argument to its sine term, so this captured value moved when that
         // was corrected.
diff --git a/crates/rustmotion-core/src/engine/layout_pass.rs b/crates/rustmotion-core/src/engine/layout_pass.rs
index 386c201d..e9a03c5e 100644
--- a/crates/rustmotion-core/src/engine/layout_pass.rs
+++ b/crates/rustmotion-core/src/engine/layout_pass.rs
@@ -72,7 +72,7 @@ impl LayoutResult {
 /// taffy nodes and our `BoxNode` ids + intrinsic measurers.
 ///
 /// `inset_width`/`inset_height` are this node's own resolved padding+border
-///: taffy's `compute_leaf_layout` already subtracts them from
+/// (RM-27): taffy's `compute_leaf_layout` already subtracts them from
 /// `available_space` before calling the measure function, but forwards
 /// `known_dimensions` — the outer border-box size — untouched, handing an
 /// `IntrinsicMeasure` implementor two arguments in different coordinate
@@ -137,7 +137,7 @@ pub fn run_layout(root: &BoxNode, viewport: (f32, f32), ctx: &ConversionContext)
 /// Build one taffy node and, recursively, its subtree.
 ///
 /// `inherited_font_size` is the already-resolved (px) font-size of `node`'s
-/// parent: CSS resolves `em` on every layout property against the
+/// parent (RM-26): CSS resolves `em` on every layout property against the
 /// element's *own* computed font-size, and font-size itself inherits down
 /// the tree unless overridden. `to_taffy_style` and [`content_box_inset`]
 /// only ever see the single `ConversionContext` handed to them, so their
diff --git a/crates/rustmotion-core/src/engine/renderer/assets.rs b/crates/rustmotion-core/src/engine/renderer/assets.rs
index 9121f48e..97345599 100644
--- a/crates/rustmotion-core/src/engine/renderer/assets.rs
+++ b/crates/rustmotion-core/src/engine/renderer/assets.rs
@@ -50,7 +50,7 @@ pub fn gif_cache() -> &'static GifCacheMap {
 /// then never answers — or trickles one byte a minute — hangs the calling
 /// thread forever; ureq's 10 MB body cap bounds bytes, not time. On the icon
 /// path that thread can be a render worker with nobody at the keyboard to
-/// notice.
+/// notice (RM-41).
 ///
 /// `Config::builder()` starts from `Config::default()`, which already
 /// resolves a proxy from `HTTPS_PROXY`/`https_proxy`/`HTTP_PROXY`/
@@ -258,7 +258,7 @@ pub fn ffmpeg_available() -> bool {
 /// `rtmp://`, `concat:`, …), which turns an unfiltered `src` into an SSRF
 /// primitive — a scenario author can point it at
 /// `http://169.254.169.254/...` (the cloud metadata endpoint) or an internal
-/// service, and read the exit status as a port-scan oracle. Remote
+/// service, and read the exit status as a port-scan oracle (RM-42). Remote
 /// video was never a designed feature here — this module's own `is_remote`
 /// doc, a few functions below, and `rustmotion info`'s identical assumption
 /// both already treat every `src` as a local path — so this closes an
@@ -276,7 +276,7 @@ fn reject_remote_video_src(src: &str) -> Result<()> {
     if looks_like_scheme {
         return Err(RustmotionError::Generic(format!(
             "video src '{src}' names a '{scheme}://' URL — rustmotion does not fetch video \
-             over the network, only local file paths are accepted"
+             over the network, only local file paths are accepted (RM-42)"
         )));
     }
     Ok(())
diff --git a/crates/rustmotion-core/src/expand.rs b/crates/rustmotion-core/src/expand.rs
index ea153e98..c47860e1 100644
--- a/crates/rustmotion-core/src/expand.rs
+++ b/crates/rustmotion-core/src/expand.rs
@@ -157,7 +157,7 @@ use crate::variables::substitute;
 const MAX_EXPANSION_DEPTH: u32 = 64;
 
 /// Ceiling on the total number of nodes a single document's `for-each`
-/// expansion may produce, across every level of nesting combined.
+/// expansion may produce, across every level of nesting combined (RM-43).
 /// [`MAX_EXPANSION_DEPTH`] bounds how deep directives may nest, not how many
 /// nodes they produce — and nesting one `for-each` inside another's
 /// `template` is explicitly supported (`use_template_can_contain_a_nested_
@@ -306,7 +306,7 @@ pub fn expand_directives(value: &mut Value, file_label: &str) -> Result<()> {
 }
 
 /// Subtracts `n` from the shared expansion-node budget, or fails naming the
-/// limit and where it was hit. See [`MAX_EXPANSION_NODES`] for why
+/// limit and where it was hit (RM-43). See [`MAX_EXPANSION_NODES`] for why
 /// this is checked once per `for-each` directive's item count rather than
 /// once per final node: it is the only point in the recursion where the
 /// multiplicative blow-up can be caught before the work that would produce
diff --git a/crates/rustmotion-core/tests/audit_ws_a.rs b/crates/rustmotion-core/tests/audit_ws_a.rs
index d264fbae..7ad93749 100644
--- a/crates/rustmotion-core/tests/audit_ws_a.rs
+++ b/crates/rustmotion-core/tests/audit_ws_a.rs
@@ -1,5 +1,5 @@
 //! Regression tests for the workstream A (animation & paint) audit findings
-//! tracked in issue #220.
+//! tracked in issue #220: RM-01, RM-09, RM-10, RM-37.
 
 use rustmotion_core::css::style::{
     Background, BackgroundLayer, BoxShadow, Color as CssColor, CssStyle, Display, FlexDirection,
@@ -72,7 +72,7 @@ fn probe(buf: &[u8], w: u32, x: usize, y: usize) -> (u8, u8, u8) {
     (buf[i], buf[i + 1], buf[i + 2])
 }
 
-// ---- opacity layer must not clip the node's own outset box-shadow ----
+// ---- RM-01: opacity layer must not clip the node's own outset box-shadow ----
 
 fn card_with_shadow(opacity: Option<f32>) -> BoxNode {
     let css = CssStyle {
@@ -134,7 +134,7 @@ fn opacity_layer_does_not_clip_own_outset_box_shadow() {
     );
 }
 
-// ---- underdamped spring step response must start from rest ----
+// ---- RM-09: underdamped spring step response must start from rest ----
 
 fn spring_config(damping: f64, stiffness: f64, mass: f64) -> SpringConfig {
     SpringConfig {
@@ -192,7 +192,7 @@ fn underdamped_spring_matches_the_analytic_closed_form() {
     }
 }
 
-// ---- linear-gradient(180deg, ...) must put the first stop at the top ----
+// ---- RM-10: linear-gradient(180deg, ...) must put the first stop at the top ----
 
 fn gradient_card(w: f32, h: f32, angle: f32) -> BoxNode {
     let css = CssStyle {
@@ -243,7 +243,7 @@ fn linear_gradient_180deg_puts_the_first_stop_at_the_top() {
     );
 }
 
-// ---- `spring_settle_time` must not be rescanned on every `spring_value` call ----
+// ---- RM-37: `spring_settle_time` must not be rescanned on every `spring_value` call ----
 
 #[test]
 fn spring_settle_time_is_memoized_not_rescanned_every_call() {
diff --git a/crates/rustmotion-core/tests/audit_ws_h.rs b/crates/rustmotion-core/tests/audit_ws_h.rs
index 0fd3a042..4f02d02f 100644
--- a/crates/rustmotion-core/tests/audit_ws_h.rs
+++ b/crates/rustmotion-core/tests/audit_ws_h.rs
@@ -1,9 +1,9 @@
 //! Regression tests for the workstream H (untrusted scenario ingestion)
-//! audit findings that live in `rustmotion-core`.
+//! audit findings that live in `rustmotion-core`: RM-41, RM-42, RM-43.
 
 use rustmotion_core::engine::renderer::{extract_video_frame, http_agent};
 
-// ---- no timeout on any HTTP call — a bare `ureq::get` always uses
+// ---- RM-41: no timeout on any HTTP call — a bare `ureq::get` always uses
 // the default, untimed agent, so a stalled host hangs a render forever ----
 
 #[test]
@@ -20,7 +20,7 @@ fn shared_http_agent_has_finite_global_and_connect_timeouts() {
     );
 }
 
-// ---- a scenario's `video.src` reaches `ffmpeg -i` verbatim, with no
+// ---- RM-42: a scenario's `video.src` reaches `ffmpeg -i` verbatim, with no
 // protocol allowlist — a remote-looking src turns into an SSRF primitive ----
 
 #[test]
@@ -56,7 +56,7 @@ fn extract_video_frame_does_not_reject_a_plain_local_path() {
     );
 }
 
-// ---- `for-each` expansion has a depth ceiling but no node budget —
+// ---- RM-43: `for-each` expansion has a depth ceiling but no node budget —
 // nesting is multiplicative, so a handful of small arrays nested a few
 // levels deep can declare a product in the millions ----
 
diff --git a/crates/rustmotion-core/tests/audit_ws_j.rs b/crates/rustmotion-core/tests/audit_ws_j.rs
index 6b3501b9..4da80594 100644
--- a/crates/rustmotion-core/tests/audit_ws_j.rs
+++ b/crates/rustmotion-core/tests/audit_ws_j.rs
@@ -1,5 +1,5 @@
 //! Regression tests for the workstream J (layout pass & CSS unit resolution)
-//! audit findings on unit resolution and intrinsic measurement.
+//! audit findings: RM-26, RM-27.
 
 use std::sync::{Arc, Mutex};
 
@@ -9,7 +9,7 @@ use rustmotion_core::css::units::{Length, LengthPercentage as CLP};
 use rustmotion_core::engine::box_tree::{AvailableSpace, BoxNode, IntrinsicMeasure};
 use rustmotion_core::engine::layout_pass::run_layout;
 
-// ---- `em` on layout properties must resolve against the element's
+// ---- RM-26: `em` on layout properties must resolve against the element's
 // own (inherited) font-size, not a constant 16px ----
 
 /// A card sized by its parent's explicit `font-size` (48px) inherits that
@@ -48,7 +48,7 @@ fn em_padding_resolves_against_inherited_font_size_not_a_constant_16px() {
     assert_eq!(content_w, 200.0 - 2.0 * 48.0);
 }
 
-// ---- a leaf's `IntrinsicMeasure::measure` must receive `known` and
+// ---- RM-27: a leaf's `IntrinsicMeasure::measure` must receive `known` and
 // `available` in the same (content-box) coordinate space ----
 
 type RecordedCall = ((Option<f32>, Option<f32>), (AvailableSpace, AvailableSpace));
diff --git a/crates/rustmotion-html/tests/audit_ws_f.rs b/crates/rustmotion-html/tests/audit_ws_f.rs
index e8ab981a..00c40637 100644
--- a/crates/rustmotion-html/tests/audit_ws_f.rs
+++ b/crates/rustmotion-html/tests/audit_ws_f.rs
@@ -1,17 +1,17 @@
 //! Regression tests for workstream F's 4 confirmed audit findings on the
 //! HTML dialect transpiler: an attribute outside a hardcoded allowlist
-//! vanishing with no error, a CSS shorthand transpiling to a string
-//! the core length parser cannot read and silently resolving to 0px,
+//! vanishing with no error (RM-03), a CSS shorthand transpiling to a string
+//! the core length parser cannot read and silently resolving to 0px (RM-04),
 //! `<script>`/`<style>` source getting painted as text while `<img>`/`<svg>`
-//! children vanish inside inline text elements, and the studio's
+//! children vanish inside inline text elements (RM-11), and the studio's
 //! HTML write-back deleting everything outside `<rustmotion>` in the
-//! author's file.
+//! author's file (RM-12).
 
 use rustmotion_html::{html_to_scenario_value, HtmlError};
 use serde_json::json;
 
 // ---------------------------------------------------------------------------
-// <scene> and <rustmotion> read a hardcoded attribute allowlist;
+// RM-03: <scene> and <rustmotion> read a hardcoded attribute allowlist;
 // every other attribute is dropped with no error.
 // ---------------------------------------------------------------------------
 
@@ -97,7 +97,7 @@ fn inert_attributes_stay_inert_on_container_and_text() {
 }
 
 // ---------------------------------------------------------------------------
-// CSS shorthand values transpile to strings the core length parser
+// RM-04: CSS shorthand values transpile to strings the core length parser
 // cannot read, silently resolving to 0px.
 // ---------------------------------------------------------------------------
 
@@ -189,7 +189,7 @@ fn rgba_color_functional_notation_is_not_treated_as_multi_token() {
 }
 
 // ---------------------------------------------------------------------------
-// text-tag children bypass every guard — <script>/<style> source gets
+// RM-11: text-tag children bypass every guard — <script>/<style> source gets
 // painted, <img>/<svg>/<rm-*> vanish silently.
 // ---------------------------------------------------------------------------
 
@@ -265,7 +265,7 @@ fn inline_formatting_tags_still_flatten_into_the_parent_text() {
 }
 
 // ---------------------------------------------------------------------------
-// studio HTML write-back silently deletes everything outside
+// RM-12: studio HTML write-back silently deletes everything outside
 // <rustmotion> in the author's file.
 // ---------------------------------------------------------------------------
 
diff --git a/crates/rustmotion-studio/src/editor/audio.rs b/crates/rustmotion-studio/src/editor/audio.rs
index 59fbed59..7f720c14 100644
--- a/crates/rustmotion-studio/src/editor/audio.rs
+++ b/crates/rustmotion-studio/src/editor/audio.rs
@@ -183,7 +183,9 @@ pub fn prepare(scenario: Arc<ResolvedScenario>, total_duration: f64) {
         match mixed {
             Ok(Some(pcm_bytes)) => {
                 let pcm: Vec<f32> = pcm_bytes
-                    .chunks_exact(2)
+                    .as_chunks::<2>()
+                    .0
+                    .iter()
                     .map(|b| i16::from_le_bytes([b[0], b[1]]) as f32 / 32768.0)
                     .collect();
                 let _ = tx.send(Cmd::Load(Arc::new(pcm), SAMPLE_RATE));
diff --git a/crates/rustmotion-studio/src/scenario/optimistic.rs b/crates/rustmotion-studio/src/scenario/optimistic.rs
index bcc95d17..2d0a6f32 100644
--- a/crates/rustmotion-studio/src/scenario/optimistic.rs
+++ b/crates/rustmotion-studio/src/scenario/optimistic.rs
@@ -382,7 +382,9 @@ mod tests {
             .expect("render")
         };
         let count_red = |rgba: &[u8]| {
-            rgba.chunks_exact(4)
+            rgba.as_chunks::<4>()
+                .0
+                .iter()
                 .filter(|p| p[0] > 180 && p[1] < 90 && p[2] < 90)
                 .count()
         };
diff --git a/crates/rustmotion/src/cli/commands/geometry.rs b/crates/rustmotion/src/cli/commands/geometry.rs
index b502d461..9494bab0 100644
--- a/crates/rustmotion/src/cli/commands/geometry.rs
+++ b/crates/rustmotion/src/cli/commands/geometry.rs
@@ -53,7 +53,7 @@
 use std::collections::HashSet;
 
 use rustmotion::components::box_builder::{
-    build_scene_from_refs, effective_effects, BuildAnimationCtx,
+    build_scene_from_refs, component_kind, effective_effects, BuildAnimationCtx,
 };
 use rustmotion::components::intrinsic::{
     CaptionIntrinsic, CodeblockIntrinsic, GradientTextIntrinsic, RichTextIntrinsic, TableIntrinsic,
@@ -307,15 +307,7 @@ fn walk(
                     out,
                 );
             }
-            check_auto_scroll(
-                &child.component,
-                &child_path,
-                &raw_bbox,
-                viewport,
-                vi,
-                si,
-                out,
-            );
+            check_auto_scroll(&child.component, &child_path, layout, viewport, vi, si, out);
             // Suppressed under a clipping ancestor (parent_clips) exactly
             // like check_viewport, and when the node clips its own overflow
             // (paint_pass applies a node's own `overflow: hidden`/clip/
@@ -474,7 +466,7 @@ fn container_clips(c: &Component) -> bool {
 /// folded separately in `walk_anim`; this only handles what a component
 /// declares directly in `style.transform`.
 ///
-/// `font_size` is the NODE's own resolved font-size
+/// RM-15: `font_size` is the NODE's own resolved font-size
 /// (`css.font_size_px_or(16.0)`), not a hardcoded 16px — an `em` length in
 /// `transform` must scale with the element it's declared on, exactly like
 /// `paint_pass.rs`'s `length_ctx` does for the same field. Percentage
@@ -603,7 +595,7 @@ fn resolve_transform_origin_2d(
 /// `y' = x·sinθ + y·cosθ`); `Skew`/`SkewX`/`SkewY` match `Canvas::skew`
 /// (`x' = x + y·tan(skew_x)`, `y' = y + x·tan(skew_y)`).
 ///
-/// `ctx_x`/`ctx_y` are separate contexts differing only in
+/// RM-15: `ctx_x`/`ctx_y` are separate contexts differing only in
 /// `parent_size` (the box's own width / height respectively), used for
 /// `Translate`/`TranslateX`/`TranslateY`/`Translate3d`'s percentage
 /// resolution — CSS resolves a translate's x-component percentage against
@@ -791,7 +783,7 @@ fn measurer_and_nowrap(component: &Component) -> Option<(Box<dyn IntrinsicMeasur
     }
 }
 
-/// natural (unwrapped) width vs the node's own CONTENT box, not its
+/// RM-31: natural (unwrapped) width vs the node's own CONTENT box, not its
 /// border box. `LegacyPaintDispatcher::dispatch` hands every non-codeblock
 /// painter (`Text`/`GradientText`/`Caption` included) a synthetic
 /// `BoxLayout` built from `layout.content_box()`, translated to the
@@ -873,14 +865,24 @@ fn check_unwrappable_text(
 /// (`codeblock`/`terminal` are deliberately excluded: their `auto_scroll`
 /// escape hatch makes a smaller-than-natural box intentional).
 ///
-/// Complementary to `check_unwrappable_text`, not overlapping with it:
-/// that one covers `white-space: nowrap`/`pre` (single unwrapped line, width
-/// only, measured at natural/unconstrained width). This one covers the
-/// default wrapping case — measured at the width the box actually *has*
-/// (`content_box().2`, unconstrained height) so it also catches a single
-/// unbreakable word/token/URL that's wider than the box even though wrap is
-/// on (wrapping can't break within a word), plus the width axis stays
-/// consistent with what will actually be painted.
+/// Complementary to `check_unwrappable_text`, not overlapping with it on the
+/// WIDTH axis: that one covers `white-space: nowrap`/`pre` (single unwrapped
+/// line, measured at natural/unconstrained width). This function covers the
+/// default wrapping case's width — measured at the width the box actually
+/// *has* (`content_box().2`, unconstrained height) so it also catches a
+/// single unbreakable word/token/URL that's wider than the box even though
+/// wrap is on (wrapping can't break within a word), plus the width axis
+/// stays consistent with what will actually be painted.
+///
+/// RM-32: the HEIGHT axis is this function's job regardless of `nowrap` — a
+/// nowrap node used to return here before measuring height at all, so a
+/// single unwrapped line taller than its box validated clean. Re-measuring
+/// nowrap's WIDTH at a constrained space would wrap text that actually
+/// paints as one (too-wide) line, which is exactly why `check_unwrappable_
+/// text` owns that axis instead — but a single line's height is exactly one
+/// `line_height`, independent of any width constraint, so it's measured at
+/// `(MaxContent, Definite(ch))` and reported on `Axis::Y` only, leaving
+/// `Axis::X` to `check_unwrappable_text`.
 fn check_content_overflows_box(
     component: &Component,
     path: &str,
@@ -893,19 +895,44 @@ fn check_content_overflows_box(
     let Some((intrinsic, nowrap)) = measurer_and_nowrap(component) else {
         return;
     };
-    // nowrap/pre is check_unwrappable_text's territory: re-measuring it
-    // here at a constrained width would wrap text that will actually
-    // paint as one (too-wide) line, producing a height number that
-    // doesn't correspond to anything that gets painted.
-    if nowrap {
-        return;
-    }
 
     let (cx, cy, cw, ch) = layout.content_box();
     if cw <= 0.0 || ch <= 0.0 {
         return;
     }
 
+    if nowrap {
+        let (_, natural_h) = intrinsic.measure(
+            (None, None),
+            (AvailableSpace::MaxContent, AvailableSpace::Definite(ch)),
+        );
+        let eps = 0.5;
+        if natural_h <= ch + eps {
+            return;
+        }
+        let kind = component_kind(component);
+        out.push(GeometryViolation {
+            view_index: vi,
+            scene_index: si,
+            path: path.to_string(),
+            component: kind.to_string(),
+            axis: Axis::Y,
+            kind: ViolationKind::ContentOverflowsBox,
+            bbox: BBox {
+                x: cx,
+                y: cy,
+                w: cw,
+                h: ch,
+            },
+            viewport,
+            hint: format!(
+                "{kind} line is {natural_h:.0}px tall but its box is only {:.0}px tall — increase style.height (or the parent's), or reduce style.font-size",
+                ch
+            ),
+        });
+        return;
+    }
+
     // Height is bounded by the node's own resolved content-box height `ch`
     // (not `MaxContent`) for the same reason width is bounded by `cw`: a
     // `text-autofit: true` node can only try to shrink into a target it's
@@ -982,10 +1009,20 @@ fn check_content_overflows_box(
 /// `(None, None)`/`MaxContent` yields each component's natural (unbounded)
 /// size, exactly like `check_unwrappable_text`/`check_content_overflows_box`
 /// already do for the text-family intrinsics.
+///
+/// RM-33: the codeblock and terminal arms compare against different boxes,
+/// on purpose. `LegacyPaintDispatcher::is_self_padding` matches only
+/// `Component::Codeblock` — a codeblock is handed the raw (border) layout
+/// box and paints its own padding inside it (`compute_code_dimensions`
+/// already bakes `style.padding_px()` into `natural_h`, so comparing against
+/// the border box is the byte-for-byte-correct pairing). Every other
+/// painter, terminal included, is handed `layout.content_box()` instead —
+/// so the terminal arm compares against that, not the border box, or it
+/// under-reports by exactly the node's own padding.
 fn check_auto_scroll(
     component: &Component,
     path: &str,
-    bbox: &BBox,
+    layout: &BoxLayout,
     viewport: (u32, u32),
     vi: usize,
     si: usize,
@@ -996,6 +1033,7 @@ fn check_auto_scroll(
         Component::Codeblock(cb) if !cb.auto_scroll => {
             let (_, natural_h) =
                 CodeblockIntrinsic::from_codeblock(cb).measure((None, None), max_content);
+            let bbox = bbox_of(layout);
             if natural_h > bbox.h + 0.5 {
                 out.push(GeometryViolation {
                     view_index: vi,
@@ -1004,7 +1042,7 @@ fn check_auto_scroll(
                     component: "codeblock".to_string(),
                     axis: Axis::Y,
                     kind: ViolationKind::AutoScrollDisabledOverflow,
-                    bbox: *bbox,
+                    bbox,
                     viewport,
                     hint: format!(
                         "codeblock content needs ~{:.0}px but box is {:.0}px — enable auto_scroll or shorten code",
@@ -1016,7 +1054,8 @@ fn check_auto_scroll(
         Component::Terminal(t) if !t.auto_scroll => {
             let (_, natural_h) =
                 TerminalIntrinsic::from_terminal(t).measure((None, None), max_content);
-            if natural_h > bbox.h + 0.5 {
+            let (cx, cy, cw, ch) = layout.content_box();
+            if natural_h > ch + 0.5 {
                 out.push(GeometryViolation {
                     view_index: vi,
                     scene_index: si,
@@ -1024,11 +1063,16 @@ fn check_auto_scroll(
                     component: "terminal".to_string(),
                     axis: Axis::Y,
                     kind: ViolationKind::AutoScrollDisabledOverflow,
-                    bbox: *bbox,
+                    bbox: BBox {
+                        x: cx,
+                        y: cy,
+                        w: cw,
+                        h: ch,
+                    },
                     viewport,
                     hint: format!(
                         "terminal content needs ~{:.0}px but box is {:.0}px — enable auto_scroll or remove lines",
-                        natural_h, bbox.h
+                        natural_h, ch
                     ),
                 });
             }
@@ -1211,71 +1255,6 @@ fn text_sizes(component: &Component) -> Vec<(&'static str, f32)> {
     }
 }
 
-fn component_kind(c: &Component) -> &'static str {
-    match c {
-        Component::Text(_) => "text",
-        Component::Shape(_) => "shape",
-        Component::Image(_) => "image",
-        Component::Icon(_) => "icon",
-        Component::Svg(_) => "svg",
-        Component::Video(_) => "video",
-        Component::Gif(_) => "gif",
-        Component::Counter(_) => "counter",
-        Component::Cursor(_) => "cursor",
-        Component::Pointer(_) => "pointer",
-        Component::NumberWheel(_) => "number_wheel",
-        Component::SuccessCheck(_) => "success_check",
-        Component::Caption(_) => "caption",
-        Component::Codeblock(_) => "codeblock",
-        Component::Avatar(_) => "avatar",
-        Component::AvatarGroup(_) => "avatar_group",
-        Component::Arrow(_) => "arrow",
-        Component::Connector(_) => "connector",
-        Component::Badge(_) => "badge",
-        Component::Callout(_) => "callout",
-        Component::Chart(_) => "chart",
-        Component::Comparison(_) => "comparison",
-        Component::Countdown(_) => "countdown",
-        Component::Divider(_) => "divider",
-        Component::DotMap(_) => "dot_map",
-        Component::Gauge(_) => "gauge",
-        Component::GradientText(_) => "gradient_text",
-        Component::Heatmap(_) => "heatmap",
-        Component::Kbd(_) => "kbd",
-        Component::Line(_) => "line",
-        Component::List(_) => "list",
-        Component::Lottie(_) => "lottie",
-        Component::Marquee(_) => "marquee",
-        Component::Mockup(_) => "mockup",
-        Component::Notification(_) => "notification",
-        Component::Particle(_) => "particle",
-        Component::PillNav(_) => "pill_nav",
-        Component::Progress(_) => "progress",
-        Component::QrCode(_) => "qrcode",
-        Component::Rating(_) => "rating",
-        Component::Skeleton(_) => "skeleton",
-        Component::Slider(_) => "slider",
-        Component::Sparkline(_) => "sparkline",
-        Component::Stat(_) => "stat",
-        Component::Stepper(_) => "stepper",
-        Component::Switch(_) => "switch",
-        Component::RichText(_) => "rich_text",
-        Component::Table(_) => "table",
-        Component::TagCloud(_) => "tag_cloud",
-        Component::Terminal(_) => "terminal",
-        Component::Timeline(_) => "timeline",
-        Component::Tooltip(_) => "tooltip",
-        Component::Treemap(_) => "treemap",
-        Component::Positioned(_) => "positioned",
-        Component::Flex(_) => "flex",
-        Component::Grid(_) => "grid",
-        Component::Card(_) => "card",
-        Component::Container(_) => "container",
-        Component::AudioSpectrum(_) => "audio_spectrum",
-        Component::Waveform(_) => "waveform",
-    }
-}
-
 // ─── Animated overflow sampling (--strict-anim) ─────────────────────────────
 
 /// Samples per second of scene duration. ~8/s (125ms resolution) is dense
diff --git a/crates/rustmotion/src/encode/video/formats.rs b/crates/rustmotion/src/encode/video/formats.rs
index 8cad2f02..b3ab8730 100644
--- a/crates/rustmotion/src/encode/video/formats.rs
+++ b/crates/rustmotion/src/encode/video/formats.rs
@@ -359,12 +359,11 @@ mod tests {
     /// (an odd width rejected by libx264) doesn't apply here (the `gif`
     /// crate has no such constraint), so this drives the failure the one
     /// way this pure Rust path can actually fail without external tools:
-    /// `total_frames == 0`.
-    /// That returns before any file is touched either way, so what this
-    /// test really pins is the *shape* of the fix — `encode_gif` must never
-    /// promote a partial onto `output_path` when its inner call errors —
-    /// exercised by asserting the scratch/partial path used internally is
-    /// never left behind either.
+    /// `total_frames == 0`. That returns before any file is touched either
+    /// way, so what this test really pins is the *shape* of the fix —
+    /// `encode_gif` must never promote a partial onto `output_path` when its
+    /// inner call errors — exercised by asserting the scratch/partial path
+    /// used internally is never left behind either.
     #[test]
     fn encode_gif_leaves_no_partial_file_behind_on_an_empty_scenario() {
         let json = r#"{"video": {"width": 8, "height": 8, "fps": 10}, "scenes": []}"#;
diff --git a/crates/rustmotion/src/encode/video/tasks.rs b/crates/rustmotion/src/encode/video/tasks.rs
index ca6f8e6f..378174f5 100644
--- a/crates/rustmotion/src/encode/video/tasks.rs
+++ b/crates/rustmotion/src/encode/video/tasks.rs
@@ -1,3 +1,4 @@
+use crate::engine::animator::ease;
 use crate::engine::transition::{apply_transition, camera_pan_transition, TransitionOptions};
 use crate::error::{Result, RustmotionError};
 use crate::schema::{
@@ -296,6 +297,7 @@ pub fn render_frame_task_scaled(
             // Rationale: the transition is the "entry" of scene_b; its post-effects
             // (e.g. vignette) should appear on the blended frames to avoid a
             // jarring pop when the transition ends and Normal frames begin.
+            let progress = eased_transition_progress(progress, easing);
             let mut composited = apply_transition(
                 &frame_a,
                 &frame_b,
@@ -360,7 +362,7 @@ pub fn render_frame_task_scaled(
             transition_type,
             options,
             transition_duration,
-            easing: _,
+            easing,
         } => {
             let scenario_time = *global_frame as f64 / config.fps as f64;
             let scaled_w = (config.width as f32 * scale_factor) as u32;
@@ -372,6 +374,7 @@ pub fn render_frame_task_scaled(
             // does not.
             let progress =
                 view_transition_progress(*frame_in_transition, *transition_duration, fps);
+            let progress = eased_transition_progress(progress, easing);
 
             let view_a = &scenario.views[*view_a_idx];
             let view_b = &scenario.views[*view_b_idx];
@@ -427,6 +430,18 @@ fn transition_progress(frame_in_transition: u32, transition_duration: f64, fps:
     frame_in_transition as f64 / transition_frames.saturating_sub(1).max(1) as f64
 }
 
+/// Reshapes a transition's raw linear `progress` by its declared
+/// `transition.easing` before it reaches `apply_transition`, which composites
+/// pixels at exactly the fraction it's handed and has no notion of easing on
+/// its own. Every transition arm that calls `apply_transition` needs this —
+/// `SlideTransition`'s `CameraPan` case is the one exception, since it never
+/// reaches `apply_transition` at all: it hands its own `easing` straight into
+/// `camera_pan_transition`, which applies it internally, so routing it
+/// through here first would ease that progress twice.
+fn eased_transition_progress(progress: f64, easing: &EasingType) -> f64 {
+    ease(progress, easing)
+}
+
 /// Frame index within a *view* transition → progress in the OPEN interval
 /// `(0.0, 1.0)`, excluding both endpoints.
 ///
diff --git a/crates/rustmotion/src/include.rs b/crates/rustmotion/src/include.rs
index dacb953d..78d474a2 100644
--- a/crates/rustmotion/src/include.rs
+++ b/crates/rustmotion/src/include.rs
@@ -12,7 +12,7 @@ use crate::schema::{
 
 const MAX_INCLUDE_DEPTH: u8 = 8;
 
-/// Response-size cap for a remote `include` fetch. Scenario JSON is
+/// Response-size cap for a remote `include` fetch (RM-46). Scenario JSON is
 /// not expected to be large; this is deliberately far below ureq's own 10 MB
 /// default for `read_to_vec`/`read_to_string`.
 const MAX_REMOTE_INCLUDE_BYTES: u64 = 4 * 1024 * 1024;
@@ -25,7 +25,7 @@ const MAX_REMOTE_INCLUDE_BYTES: u64 = 4 * 1024 * 1024;
 const ALLOW_REMOTE_INCLUDE_FLAG: &str = "--allow-remote-include";
 
 /// Whether a [`resolve_includes_with_policy`] pass may perform outbound
-/// network requests for `include: "https://..."` directives ( remote
+/// network requests for `include: "https://..."` directives (RM-46: remote
 /// fetching is deliberate design, but it previously had no allowlist and no
 /// opt-out — any scenario, including one merely being `validate`d, could
 /// make this process issue arbitrary GETs). Defaults to [`Self::Deny`].
@@ -50,7 +50,7 @@ pub enum IncludeSource {
 /// [`resolve_includes_with_policy`] to opt in. This is exactly
 /// `resolve_includes_with_policy(scenario, source, RemoteIncludePolicy::Deny)`,
 /// kept as its own entry point so every existing caller stays secure by
-/// default without having to be rewritten to pass a policy.
+/// default without having to be rewritten to pass a policy (RM-46).
 pub fn resolve_includes(scenario: Scenario, source: &IncludeSource) -> Result<ResolvedScenario> {
     resolve_includes_with_policy(scenario, source, RemoteIncludePolicy::Deny)
 }
@@ -188,7 +188,7 @@ fn fetch_and_resolve(
         if remote_policy != RemoteIncludePolicy::Allow {
             return Err(RustmotionError::Generic(format!(
                 "include '{}' is a remote URL, but remote includes are disabled by default \
- — pass {ALLOW_REMOTE_INCLUDE_FLAG} to opt in",
+                 (RM-46) — pass {ALLOW_REMOTE_INCLUDE_FLAG} to opt in",
                 directive.include
             )));
         }
@@ -302,7 +302,7 @@ impl VerifiedRemoteUrl {
 
 /// Resolves `url`'s host and rejects it if any resolved address is not
 /// publicly routable: loopback, link-local (169.254.169.254, the cloud
-/// metadata endpoint, included), or an RFC1918/ULA private range.
+/// metadata endpoint, included), or an RFC1918/ULA private range (RM-46).
 ///
 /// This check runs once, ahead of the request `fetch_remote` makes moments
 /// later; a DNS answer that changes between this resolution and that
diff --git a/crates/rustmotion/tests/audit_ws_b.rs b/crates/rustmotion/tests/audit_ws_b.rs
index 7d550394..cf773941 100644
--- a/crates/rustmotion/tests/audit_ws_b.rs
+++ b/crates/rustmotion/tests/audit_ws_b.rs
@@ -9,8 +9,8 @@
 //! output — is the only externally-observable contract for what the
 //! validator decided (mirrors `motion_path_strict_anim.rs`'s reasoning).
 //!
-//! One section per finding, in briefing order: viewport units, transform
-//! lengths, path rewriting, the three box-model checks, and helper reuse.
+//! One section per finding (RM-05, RM-15, RM-16, RM-31, RM-32, RM-33,
+//! RM-40), in briefing order.
 
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
@@ -40,7 +40,7 @@ impl Drop for ScratchFile {
 }
 
 /// Minimal RAII scratch directory — mirrors `skill_files_match_disk.rs`'s
-/// `ScratchDir`. Only the path-rewriting case needs a directory (a file plus a
+/// `ScratchDir`. Only RM-16 needs a directory (a scenario file plus a
 /// sibling asset file).
 struct ScratchDir(PathBuf);
 
@@ -108,7 +108,7 @@ fn find_kind<'a>(report: &'a serde_json::Value, kind: &str) -> Option<&'a serde_
     violations(report).iter().find(|v| v["kind"] == kind)
 }
 
-// ─── vw/vh must resolve against the scenario's real viewport ───────
+// ─── RM-05: vw/vh must resolve against the scenario's real viewport ───────
 
 /// A `width: "90vw"` shape on a 1080×1920 scenario, positioned so its right
 /// edge crosses the viewport edge at EITHER candidate width — 972px (90% of
@@ -195,7 +195,7 @@ fn strict_anim_also_measures_vw_against_the_real_viewport_width() {
     );
 }
 
-// ─── static transform lengths use the node's own font-size and per-axis size ───
+// ─── RM-15: static transform lengths use the node's own font-size and per-axis size ───
 
 /// `translateX(-10em)` on a 96px-font node must resolve against ITS OWN
 /// font-size (960px), not the hardcoded 16px `apply_static_node_transform`
@@ -283,7 +283,7 @@ fn static_translate_percent_resolves_per_axis_not_against_max_of_both() {
     );
 }
 
-// ─── --fix must not bake in machine-absolute asset paths ───────────
+// ─── RM-16: --fix must not bake in machine-absolute asset paths ───────────
 
 /// `--fix` used to serialise `LoadedScenario::raw`, captured AFTER
 /// `rustmotion::assets::rebase_relative_paths` rewrites every existing-file
@@ -355,7 +355,7 @@ fn fix_leaves_relative_asset_paths_untouched() {
     );
 }
 
-// ─── unwrappable_text_overflow must measure the CONTENT box ────────
+// ─── RM-31: unwrappable_text_overflow must measure the CONTENT box ────────
 
 /// A nowrap text's own painter draws inside its CONTENT box
 /// (`LegacyPaintDispatcher` hands it `layout.content_box()`, not the raw
@@ -405,3 +405,196 @@ fn unwrappable_text_overflow_is_measured_against_the_content_box() {
         "violation bbox should be the 100px CONTENT box, not the 2000px border box: {report_json}"
     );
 }
+
+// ─── RM-32: white-space: nowrap must not silence the height check ─────────
+
+/// A single unwrapped 120px-font line is ~144px tall, well past a 40px-tall
+/// box — the exact case `content_overflows_box` already catches for
+/// wrapping text. `white-space: nowrap` used to return before measuring
+/// height at all, so this validated clean.
+#[test]
+fn nowrap_text_taller_than_its_box_is_still_flagged() {
+    let scenario = ScratchFile::new("rm32-scenario");
+    let report = ScratchFile::new("rm32-report");
+    let json = r##"{
+        "video": { "width": 1920, "height": 1080 },
+        "scenes": [{
+            "duration": 1.0,
+            "children": [{
+                "type": "text",
+                "content": "Hi",
+                "position": "absolute",
+                "x": 50, "y": 50,
+                "style": {
+                    "width": "500px", "height": "40px",
+                    "white-space": "nowrap",
+                    "font-size": "120px",
+                    "color": "#ffffff"
+                }
+            }]
+        }]
+    }"##;
+    std::fs::write(&scenario.0, json).expect("write scenario");
+
+    let output = run_validate(&scenario.0, Some(&report.0), false, false);
+    let report_json = read_report(&report.0);
+    assert!(
+        !output.status.success(),
+        "a 120px-font single line is far taller than a 40px box; report={report_json}"
+    );
+    let violation = find_kind(&report_json, "content_overflows_box")
+        .expect("expected a content_overflows_box violation");
+    assert_eq!(violation["axis"], "y", "{report_json}");
+}
+
+// ─── RM-33: auto_scroll_disabled_overflow must use the terminal's CONTENT box height ───
+
+/// A terminal's own painter is NOT self-padding
+/// (`LegacyPaintDispatcher::is_self_padding` matches only `Codeblock`) — it
+/// paints inside its content box, so `auto_scroll: false` must compare
+/// natural height against that, not the border box. 10 lines ≈ 288px
+/// natural height (36px chrome + 32px internal terminal padding + 10×22px
+/// lines at the default 14px font); border box height is 400px, content box
+/// height is 400 - 300 (150px top+bottom CSS padding) = 100px.
+#[test]
+fn terminal_auto_scroll_disabled_overflow_is_measured_against_the_content_box() {
+    let scenario = ScratchFile::new("rm33-scenario");
+    let report = ScratchFile::new("rm33-report");
+    let lines: String = (1..=10)
+        .map(|i| format!(r##"{{ "text": "line {i}" }}"##))
+        .collect::<Vec<_>>()
+        .join(",");
+    let json = format!(
+        r##"{{
+            "video": {{ "width": 1920, "height": 1080 }},
+            "scenes": [{{
+                "duration": 1.0,
+                "children": [{{
+                    "type": "terminal",
+                    "lines": [{lines}],
+                    "auto_scroll": false,
+                    "position": "absolute",
+                    "x": 50, "y": 50,
+                    "style": {{
+                        "width": "800px", "height": "400px",
+                        "padding": {{ "top": "150px", "bottom": "150px" }}
+                    }}
+                }}]
+            }}]
+        }}"##
+    );
+    std::fs::write(&scenario.0, json).expect("write scenario");
+
+    let output = run_validate(&scenario.0, Some(&report.0), false, false);
+    let report_json = read_report(&report.0);
+    assert!(
+        !output.status.success(),
+        "~288px of natural content is far past a 100px content box (400px border box minus \
+         300px of padding); report={report_json}"
+    );
+    let violation = find_kind(&report_json, "auto_scroll_disabled_overflow")
+        .expect("expected an auto_scroll_disabled_overflow violation");
+    let height = violation["bbox"]["h"].as_f64().expect("bbox.h is a number");
+    assert!(
+        (height - 100.0).abs() < 1.0,
+        "violation bbox should be the 100px CONTENT box, not the 400px border box: {report_json}"
+    );
+}
+
+/// Negative control: a codeblock genuinely IS self-padding
+/// (`LegacyPaintDispatcher::is_self_padding`), so its own natural-height
+/// formula already bakes its padding in — the codeblock arm must keep
+/// comparing against the BORDER box, unaffected by this fix. Same 60px
+/// padding fixture as the pre-existing
+/// `codeblock_auto_scroll_check_honours_explicit_padding_not_a_hardcoded_16px`
+/// internal test, driven through the CLI instead.
+#[test]
+fn codeblock_auto_scroll_disabled_overflow_still_uses_the_border_box() {
+    let scenario = ScratchFile::new("rm33-codeblock-scenario");
+    let report = ScratchFile::new("rm33-codeblock-report");
+    let code_lines: String = (1..=10)
+        .map(|i| i.to_string())
+        .collect::<Vec<_>>()
+        .join("\\n");
+    let json = format!(
+        r##"{{
+            "video": {{ "width": 1920, "height": 1080 }},
+            "scenes": [{{
+                "duration": 1.0,
+                "children": [{{
+                    "type": "codeblock",
+                    "code": "{code_lines}",
+                    "auto_scroll": false,
+                    "style": {{ "width": "600px", "height": "250px", "padding": "60px" }}
+                }}]
+            }}]
+        }}"##
+    );
+    std::fs::write(&scenario.0, json).expect("write scenario");
+
+    let output = run_validate(&scenario.0, Some(&report.0), false, false);
+    let report_json = read_report(&report.0);
+    assert!(!output.status.success(), "report={report_json}");
+    let violation = find_kind(&report_json, "auto_scroll_disabled_overflow")
+        .expect("expected an auto_scroll_disabled_overflow violation");
+    let height = violation["bbox"]["h"].as_f64().expect("bbox.h is a number");
+    assert!(
+        (height - 250.0).abs() < 1.0,
+        "codeblock is self-padding: the reported bbox must stay the 250px BORDER box, \
+         not a content box: {report_json}"
+    );
+}
+
+// ─── RM-40: geometry.rs must not duplicate box_builder's component_kind ───
+
+/// `rustmotion_components::box_builder::component_kind` is already `pub`
+/// and already imported into this same binary crate elsewhere
+/// (`engine/render/scene.rs:719`) — geometry.rs must reuse it instead of
+/// carrying its own private 60-arm copy that can silently drift from it on
+/// a rename. `rustmotion::cli::commands` is a private module, so this
+/// checks the SOURCE FILE directly rather than calling the (unreachable)
+/// function itself — see this file's own top-of-file doc comment for why
+/// every other test here goes through the CLI subprocess instead.
+#[test]
+fn geometry_does_not_redefine_component_kind() {
+    let source = include_str!("../src/cli/commands/geometry.rs");
+    assert!(
+        !source.contains("fn component_kind"),
+        "geometry.rs must not define its own component_kind — it should call \
+         rustmotion::components::box_builder::component_kind instead"
+    );
+    assert!(
+        source.contains("box_builder"),
+        "geometry.rs must import component_kind from box_builder"
+    );
+}
+
+/// Smoke test: violations must still carry a sensible `component` label
+/// after the switch to the shared helper — proves the dedup didn't silently
+/// break the import wiring.
+#[test]
+fn violation_component_label_still_resolves_after_dedup() {
+    let scenario = ScratchFile::new("rm40-scenario");
+    let report = ScratchFile::new("rm40-report");
+    let json = r##"{
+        "video": { "width": 1920, "height": 1080 },
+        "scenes": [{
+            "duration": 1.0,
+            "children": [{
+                "type": "shape",
+                "shape": "rect",
+                "position": "absolute",
+                "x": 1900, "y": 100,
+                "style": { "width": "100px", "height": "100px" },
+                "fill": "#ff0000"
+            }]
+        }]
+    }"##;
+    std::fs::write(&scenario.0, json).expect("write scenario");
+
+    let output = run_validate(&scenario.0, Some(&report.0), false, false);
+    assert!(!output.status.success());
+    let report_json = read_report(&report.0);
+    let violation = find_kind(&report_json, "viewport_overflow").expect("violation present");
+    assert_eq!(violation["component"], "shape", "{report_json}");
+}
diff --git a/crates/rustmotion/tests/audit_ws_c.rs b/crates/rustmotion/tests/audit_ws_c.rs
index 0b18c5b3..a7db3ecd 100644
--- a/crates/rustmotion/tests/audit_ws_c.rs
+++ b/crates/rustmotion/tests/audit_ws_c.rs
@@ -154,3 +154,144 @@ fn atempo_guard_rejects_non_positive_and_non_finite_rates_without_hanging() {
         }
     }
 }
+
+// ─── A transition's declared easing must actually reshape its progress ────
+//
+// `transition_progress`/`view_transition_progress` hand a raw *linear*
+// fraction to `apply_transition`, which composites pixels at exactly the
+// fraction it's given — it has no notion of the scenario's declared
+// `transition.easing` on its own. Before this fix, that raw linear fraction
+// reached `apply_transition` unmodified for every transition type except
+// `camera_pan` (which threads easing through a different function,
+// `camera_pan_transition`, that already applies it internally), so
+// `"easing": "ease_in"`/`"ease_out"` on a `fade`, wipe, iris, or a
+// between-view transition was silently a no-op.
+//
+// A `fade` between a solid-black and a solid-white full-canvas frame turns
+// this into an exact, predictable pixel value: at the frame whose *linear*
+// position in the transition is precisely 0.5, an eased blend must land at
+// `255 * ease(0.5)`, not at the unequal, easing-blind `255 * 0.5 = 128`.
+// `ease_in_cubic(0.5) = 0.125` and `ease_out_cubic(0.5) = 0.875` are both far
+// enough from `0.5` that no rendering noise/antialiasing could produce a
+// false pass.
+
+fn center_pixel_red(rgba: &[u8], width: u32, height: u32) -> u8 {
+    let idx = ((height / 2 * width + width / 2) * 4) as usize;
+    rgba[idx]
+}
+
+#[test]
+fn a_fade_transitions_easing_reshapes_its_progress_not_just_camera_pan() {
+    let width = 64u32;
+    let height = 64u32;
+    let fps = 11u32;
+
+    for (easing, expected_u8) in [("ease_in", 32u8), ("ease_out", 224u8)] {
+        let json = format!(
+            r##"{{"video": {{"width": {width}, "height": {height}, "fps": {fps}}},
+            "scenes": [
+                {{"duration": 1.0, "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#000000",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}},
+                {{"duration": 1.0,
+                  "transition": {{"type": "fade", "duration": 1.0, "easing": "{easing}"}},
+                  "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#ffffff",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}}
+            ]}}"##
+        );
+        let scenario =
+            rustmotion::loader::load_scenario_from_source(None, Some(&json)).expect("load");
+
+        let tasks = rustmotion::encode::video::build_frame_tasks(&scenario);
+        let target = tasks
+            .iter()
+            .find(|t| {
+                matches!(
+                    t,
+                    rustmotion::encode::video::FrameTask::SlideTransition {
+                        frame_in_transition: 5,
+                        ..
+                    }
+                )
+            })
+            .unwrap_or_else(|| panic!("{easing}: expected a mid-transition frame at index 5"));
+
+        let rgba = rustmotion::encode::video::render_frame_task(&scenario.video, &scenario, target)
+            .unwrap_or_else(|e| panic!("{easing}: render failed: {e}"));
+        let red = center_pixel_red(&rgba, width, height);
+
+        assert!(
+            (red as i32 - expected_u8 as i32).abs() <= 4,
+            "{easing}: at the transition's linear midpoint, the eased blend must land near \
+             {expected_u8}, got {red}"
+        );
+        assert!(
+            (red as i32 - 128).abs() > 20,
+            "{easing}: {red} is too close to 128 — the raw, unequal linear-progress blend an \
+             easing-blind composite would produce"
+        );
+    }
+}
+
+#[test]
+fn a_between_view_fade_transitions_easing_reshapes_its_progress() {
+    let width = 64u32;
+    let height = 64u32;
+    let fps = 11u32;
+
+    let json = format!(
+        r##"{{"video": {{"width": {width}, "height": {height}, "fps": {fps}}},
+        "composition": [
+            {{"type": "slide", "scenes": [
+                {{"duration": 1.0, "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#000000",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}}
+            ]}},
+            {{"type": "slide",
+              "transition": {{"type": "fade", "duration": 1.0, "easing": "ease_in"}},
+              "scenes": [
+                {{"duration": 1.0, "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#ffffff",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}}
+            ]}}
+        ]}}"##
+    );
+    let scenario = rustmotion::loader::load_scenario_from_source(None, Some(&json)).expect("load");
+
+    let tasks = rustmotion::encode::video::build_frame_tasks(&scenario);
+    let target = tasks
+        .iter()
+        .find(|t| {
+            matches!(
+                t,
+                rustmotion::encode::video::FrameTask::ViewTransition {
+                    frame_in_transition: 5,
+                    ..
+                }
+            )
+        })
+        .expect("expected a mid-view-transition frame at index 5");
+
+    let rgba = rustmotion::encode::video::render_frame_task(&scenario.video, &scenario, target)
+        .expect("render");
+    let red = center_pixel_red(&rgba, width, height);
+
+    assert!(
+        (red as i32 - 32).abs() <= 4,
+        "ease_in at the view transition's linear midpoint must land near 32, got {red}"
+    );
+    assert!(
+        (red as i32 - 128).abs() > 20,
+        "{red} is too close to 128 — the raw, unequal linear-progress blend an easing-blind \
+         composite would produce"
+    );
+}
diff --git a/crates/rustmotion/tests/audit_ws_e.rs b/crates/rustmotion/tests/audit_ws_e.rs
index 9b0e92ab..d5638db0 100644
--- a/crates/rustmotion/tests/audit_ws_e.rs
+++ b/crates/rustmotion/tests/audit_ws_e.rs
@@ -37,7 +37,9 @@ fn render_world_frame(scenario_json: &serde_json::Value, frame_in_view: u32) ->
 /// for "is the decorative child visible in this frame" that doesn't depend
 /// on knowing any particle's exact on-screen position.
 fn green_pixel_count(buf: &[u8]) -> usize {
-    buf.chunks_exact(4)
+    buf.as_chunks::<4>()
+        .0
+        .iter()
         .filter(|px| px[1] > 100 && px[0] < 80 && px[2] < 80)
         .count()
 }
diff --git a/crates/rustmotion/tests/audit_ws_h.rs b/crates/rustmotion/tests/audit_ws_h.rs
index 1a83b147..81899ab3 100644
--- a/crates/rustmotion/tests/audit_ws_h.rs
+++ b/crates/rustmotion/tests/audit_ws_h.rs
@@ -1,5 +1,5 @@
 //! Regression tests for the workstream H (untrusted scenario ingestion)
-//! audit finding that lives in the `rustmotion` crate:.
+//! audit finding that lives in the `rustmotion` crate: RM-46.
 //!
 //! Remote fetching for `include: "https://..."` is deliberate design; the
 //! finding is the absence of any control around it. These tests exercise
@@ -20,7 +20,7 @@ fn scenario_with_remote_include(url: &str) -> Scenario {
     .expect("scenario with a remote include parses")
 }
 
-// ----, part 1: remote includes are denied by default ----
+// ---- RM-46, part 1: remote includes are denied by default ----
 
 #[test]
 fn remote_include_is_denied_by_default() {
@@ -46,7 +46,7 @@ fn remote_include_denial_names_the_opt_in() {
     );
 }
 
-// ----, part 2: once opted in, resolved addresses are still checked
+// ---- RM-46, part 2: once opted in, resolved addresses are still checked
 // against loopback/link-local/private ranges before any request is made ----
 
 #[test]