Move a subtree by writing one slot

`try_reuse`'s pure-translation case now writes the widget's move slot
instead of remapping every primitive in its subtree. Counted on a span
of 20 rows, each five primitives deep, when the row above them changes
height:

  before   100 primitive region writes
  now        0, and 20 slot writes -- one per row the span re-placed

`window_region` walks the same chain on the CPU, so hit testing and
anyone asking in window pixels see a widget where the shader draws it.
`Moves::resolve` stops at `CHAIN_LIMIT` like the shader, and asserts in
debug that it got to the end rather than running out.

Two things fall out of it. Rewriting a region is the one thing a slot
cannot express, so `mov` zeroes the slots of everything it rewrites: a
region is what its slot was a delta from. And `try_reuse` loses its
`old == region` shortcut, which was wrong once a slot exists -- a widget
offered exactly the box it drew against has to have its delta cleared,
not skipped.

`Moves` lives on `UiRenderState` rather than `UiData`, because the draw
is what produces it and `window_region` should not need the ui's
resources to answer where something is. The renderer already takes both.

A slot is retired in `remove_rec`, after the descendants whose slots
name it as their parent. Either order is correct here -- nothing can
claim a freed index while a subtree is coming down, since `on_undraw`
cannot reach the slots -- but this way `remove`'s `undraw` flag only
notifies rather than also deciding slot lifetime, and the retirement
sits beside the recursion it follows.

Checked: fmt, clippy and 41 tests. `tabs` (with the image replay),
`view`, `minimal` and `text` all still render byte-identical, and the
live sway resize round trip -- which re-places most of the tree at the
same size, so it is the slot path throughout -- matches a cold start at
each size.

Cargo.lock

@@ -567,9 +567,9 @@ dependencies = [
 
 [[package]]
 name = "dlib"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
+checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"
 dependencies = [
  "libloading",
 ]
@@ -2158,9 +2158,9 @@ checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quick-xml"
-version = "0.38.4"
+version = "0.41.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+checksum = "e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1"
 dependencies = [
  "memchr",
 ]
@@ -2353,6 +2353,15 @@ version = "0.8.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce"
 
+[[package]]
+name = "rig-input"
+version = "0.1.0"
+dependencies = [
+ "iris",
+ "wayland-client",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "roxmltree"
 version = "0.21.1"
@@ -2909,9 +2918,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-backend"
-version = "0.3.12"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fee64194ccd96bf648f42a65a7e589547096dfa702f7cadef84347b66ad164f9"
+checksum = "38a91b4eaddff87b1cd1074985e3713da4af2c49742d1b356b2c01670a67a078"
 dependencies = [
  "cc",
  "downcast-rs",
@@ -2923,9 +2932,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-client"
-version = "0.31.12"
+version = "0.31.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e6faa537fbb6c186cb9f1d41f2f811a4120d1b57ec61f50da451a0c5122bec"
+checksum = "e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073"
 dependencies = [
  "bitflags 2.10.0",
  "rustix 1.1.3",
@@ -2957,9 +2966,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols"
-version = "0.32.10"
+version = "0.32.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baeda9ffbcfc8cd6ddaade385eaf2393bd2115a69523c735f12242353c3df4f3"
+checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6"
 dependencies = [
  "bitflags 2.10.0",
  "wayland-backend",
@@ -2982,9 +2991,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols-wlr"
-version = "0.3.10"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9597cdf02cf0c34cd5823786dce6b5ae8598f05c2daf5621b6e178d4f7345f3"
+checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"
 dependencies = [
  "bitflags 2.10.0",
  "wayland-backend",
@@ -2995,9 +3004,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-scanner"
-version = "0.31.8"
+version = "0.31.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5423e94b6a63e68e439803a3e153a9252d5ead12fd853334e2ad33997e3889e3"
+checksum = "338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0"
 dependencies = [
  "proc-macro2",
  "quick-xml",
@@ -3006,9 +3015,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-sys"
-version = "0.31.8"
+version = "0.31.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6dbfc3ac5ef974c92a2235805cc0114033018ae1290a72e474aa8b28cbbdfd"
+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
 dependencies = [
  "dlib",
  "log",

Cargo.toml

@@ -20,7 +20,7 @@ tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread"] }
 tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"] }
 
 [workspace]
-members = ["core", "macro"]
+members = ["core", "macro", "rig-input"]
 
 [workspace.package]
 version = "0.1.0"
@@ -40,3 +40,5 @@ arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }
 tokio = "1.49.0"
+wayland-client = "0.31.15"
+wayland-protocols-wlr = { version = "0.3.12", features = ["client"] }

core/src/render/data.rs

@@ -1,11 +1,10 @@
-use crate::{UiRegion, util::Id};
+use crate::{UiRegion, util::Id, util::Vec2};
 use wgpu::*;
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable, Default)]
 pub struct WindowUniform {
-    pub width: f32,
+    pub dim: Vec2,
-    pub height: f32,
 }
 
 #[repr(C)]
@@ -13,15 +12,17 @@ pub struct WindowUniform {
 pub struct PrimitiveInstance {
     pub region: UiRegion,
     pub mask_idx: MaskIdx,
+    pub move_idx: MoveIdx,
 }
 
 impl PrimitiveInstance {
-    const ATTRIBS: [VertexAttribute; 5] = vertex_attr_array![
+    const ATTRIBS: [VertexAttribute; 6] = vertex_attr_array![
         0 => Float32x2,
         1 => Float32x2,
         2 => Float32x2,
         3 => Float32x2,
         4 => Uint32,
+        5 => Uint32,
     ];
 
     pub fn desc() -> VertexBufferLayout<'static> {
@@ -43,4 +44,45 @@ impl MaskIdx {
 #[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct Mask {
     pub region: UiRegion,
+    pub move_idx: MoveIdx,
+}
+
+/// Its own type rather than another `Id<u32>`, because it sits beside
+/// `MaskIdx` in an instance and the two must not be swappable.
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct MoveIdx(u32);
+
+impl MoveIdx {
+    pub const NONE: Self = Self(u32::MAX);
+
+    pub(crate) fn slot(idx: usize) -> Self {
+        Self(idx as u32)
+    }
+
+    pub(crate) fn idx(self) -> usize {
+        self.0 as usize
+    }
+}
+
+/// One link of the chain a primitive's position is resolved through: a
+/// translation in physical pixels, and the slot it is relative to. Moving a
+/// subtree writes its own slot and nothing else.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct MoveOffset {
+    pub delta: Vec2,
+    pub parent: MoveIdx,
+}
+
+unsafe impl bytemuck::Pod for MoveOffset {}
+unsafe impl bytemuck::Zeroable for MoveOffset {}
+
+impl MoveOffset {
+    pub fn root(parent: MoveIdx) -> Self {
+        Self {
+            delta: Vec2::ZERO,
+            parent,
+        }
+    }
 }

core/src/render/mod.rs

@@ -17,7 +17,7 @@ mod texture;
 mod util;
 
 pub use atlas::*;
-pub use data::{Mask, MaskIdx};
+pub use data::{Mask, MaskIdx, MoveIdx, MoveOffset};
 pub use primitive::*;
 
 const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
@@ -34,6 +34,7 @@ pub struct UiRenderNode {
     active: Vec<usize>,
     window_buffer: Buffer,
     masks: ArrBuf<Mask>,
+    moves: ArrBuf<MoveOffset>,
 }
 
 struct RenderLayer {
@@ -127,32 +128,35 @@ impl UiRenderNode {
         for primitive in &mut self.primitives {
             primitive.render.update(ui);
         }
+        let mut regroup = false;
         if ui.masks.changed {
             ui.masks.changed = false;
-            if self.masks.update(device, queue, &ui.masks[..]) {
+            regroup |= self.masks.update(device, queue, &ui.masks[..]);
+        }
+        if ui_render.moves.changed {
+            ui_render.moves.changed = false;
+            regroup |= self.moves.update(device, queue, ui_render.moves.entries());
+        }
+        if regroup {
             self.shared_group = Self::shared_group(
                 device,
                 &self.shared_layout,
                 &self.window_buffer,
                 &self.masks,
+                &self.moves,
             );
         }
     }
-    }
 
     pub fn resize(&mut self, size: impl Into<Vec2>, queue: &Queue) {
         let size = size.into();
-        let slice = &[WindowUniform {
+        let slice = &[WindowUniform { dim: size }];
-            width: size.x,
-            height: size.y,
-        }];
         queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice));
     }
 
     pub fn new(device: &Device, config: &SurfaceConfiguration) -> Self {
         let window_uniform = WindowUniform {
-            width: config.width as f32,
+            dim: Vec2::new(config.width as f32, config.height as f32),
-            height: config.height as f32,
         };
         let window_buffer = device.create_buffer_init(&BufferInitDescriptor {
             label: Some("window"),
@@ -166,7 +170,13 @@ impl UiRenderNode {
             BufferUsages::STORAGE | BufferUsages::COPY_DST,
             "ui masks",
         );
-        let shared_group = Self::shared_group(device, &shared_layout, &window_buffer, &masks);
+        let moves = ArrBuf::new(
+            device,
+            BufferUsages::STORAGE | BufferUsages::COPY_DST,
+            "ui move offsets",
+        );
+        let shared_group =
+            Self::shared_group(device, &shared_layout, &window_buffer, &masks, &moves);
 
         Self {
             shared_layout,
@@ -177,6 +187,7 @@ impl UiRenderNode {
             layers: HashMap::default(),
             active: Vec::new(),
             masks,
+            moves,
         }
     }
 
@@ -252,7 +263,8 @@ impl UiRenderNode {
         })
     }
 
-    /// What every draw in the ui is given: the window and the masks.
+    /// What every draw in the ui is given: the window, the masks and the
+    /// move chain every position is resolved through.
     fn shared_layout(device: &Device) -> BindGroupLayout {
         device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
@@ -276,6 +288,16 @@ impl UiRenderNode {
                     },
                     count: None,
                 },
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(size_of::<MoveOffset>() as u64),
+                    },
+                    count: None,
+                },
             ],
             label: Some("ui shared"),
         })
@@ -286,6 +308,7 @@ impl UiRenderNode {
         layout: &BindGroupLayout,
         window: &Buffer,
         masks: &ArrBuf<Mask>,
+        moves: &ArrBuf<MoveOffset>,
     ) -> BindGroup {
         device.create_bind_group(&BindGroupDescriptor {
             layout,
@@ -298,6 +321,10 @@ impl UiRenderNode {
                     binding: 1,
                     resource: masks.buffer.as_entire_binding(),
                 },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: moves.buffer.as_entire_binding(),
+                },
             ],
             label: Some("ui shared"),
         })

core/src/render/primitive.rs

@@ -3,7 +3,7 @@ use std::{any::TypeId, marker::PhantomData};
 use crate::{
     Color, TextureHandle, UiData, UiRegion, WidgetId,
     render::{
-        data::{MaskIdx, PrimitiveInstance},
+        data::{MaskIdx, MoveIdx, PrimitiveInstance},
         page::GlyphRender,
         texture::ImageRender,
     },
@@ -246,6 +246,7 @@ impl LayerDraws {
             primitive,
             region,
             mask_idx,
+            move_idx,
         }: PrimitiveInst<P>,
     ) -> PrimitiveHandle {
         self.updated = true;
@@ -258,7 +259,11 @@ impl LayerDraws {
             .get_or_insert_with(InstanceList::new::<P>)
             .push(
                 id,
-                PrimitiveInstance { region, mask_idx },
+                PrimitiveInstance {
+                    region,
+                    mask_idx,
+                    move_idx,
+                },
                 bytemuck::bytes_of(&primitive),
             );
         PrimitiveHandle {
@@ -304,6 +309,7 @@ pub struct PrimitiveInst<P> {
     pub primitive: P,
     pub region: UiRegion,
     pub mask_idx: MaskIdx,
+    pub move_idx: MoveIdx,
 }
 
 pub struct PrimitiveChange {
@@ -347,7 +353,7 @@ impl RectPrimitive {
 
 /// `color` is multiplied by the atlas alpha for a mask glyph; a colour glyph
 /// takes the texel unchanged, which `GlyphEntry::IS_COLORED` selects.
-#[repr(C, align(8))]
+#[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct GlyphPrimitive {
     pub uv_min: Vec2,
@@ -358,8 +364,8 @@ pub struct GlyphPrimitive {
     pub flags: u32,
 }
 
-// Manual rather than derived: the align(8) leaves four bytes of padding, which
+// Manual rather than derived: `Vec2`'s alignment leaves four bytes of padding
-// is how WGSL lays the struct out.
+// here, which is how WGSL lays the struct out.
 unsafe impl bytemuck::Pod for GlyphPrimitive {}
 unsafe impl bytemuck::Zeroable for GlyphPrimitive {}
 impl Primitive for GlyphPrimitive {

core/src/render/shader/prelude.wgsl

@@ -7,6 +7,8 @@
 var<uniform> window: WindowUniform;
 @group(0) @binding(1)
 var<storage> masks: array<Mask>;
+@group(0) @binding(2)
+var<storage> move_offsets: array<MoveOffset>;
 
 struct WindowUniform {
     dim: vec2<f32>,
@@ -15,6 +17,32 @@ struct WindowUniform {
 struct Mask {
     x: UiSpan,
     y: UiSpan,
+    move_idx: u32,
+}
+
+struct MoveOffset {
+    delta: vec2<f32>,
+    parent: u32,
+}
+
+const MOVE_NONE: u32 = 4294967295u;
+// Keep in step with `iris_core::CHAIN_LIMIT`. It bounds a malformed cycle
+// rather than any real tree, and the CPU walk uses the same number so both
+// resolve a deep one the same way.
+const CHAIN_LIMIT: u32 = 64u;
+
+fn resolve_move(idx: u32) -> vec2<f32> {
+    var total = vec2<f32>(0.0, 0.0);
+    var at = idx;
+    for (var step = 0u; step < CHAIN_LIMIT; step++) {
+        if at == MOVE_NONE {
+            break;
+        }
+        let entry = move_offsets[at];
+        total += entry.delta;
+        at = entry.parent;
+    }
+    return total;
 }
 
 struct UiSpan {
@@ -33,6 +61,7 @@ struct InstanceInput {
     @location(2) y_start: vec2<f32>,
     @location(3) y_end: vec2<f32>,
     @location(4) mask_idx: u32,
+    @location(5) move_idx: u32,
 }
 
 struct VertexOutput {
@@ -57,8 +86,9 @@ fn vs_main(
     let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
     let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
 
-    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
+    let moved = resolve_move(in.move_idx);
-    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
+    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs + moved);
+    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs + moved);
     let size = bot_right - top_left;
 
     let uv = vec2<f32>(
@@ -86,8 +116,11 @@ fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
     let br = vec2(mask.x.end.rel, mask.y.end.rel);
     let br_abs = vec2(mask.x.end.abs, mask.y.end.abs);
 
-    let top_left = floor(tl * window.dim) + floor(tl_abs);
+    // Its own chain, not the drawn primitive's, so a stationary viewport
-    let bot_right = floor(br * window.dim) + floor(br_abs);
+    // clips content that moves inside it.
+    let moved = resolve_move(mask.move_idx);
+    let top_left = floor(tl * window.dim) + floor(tl_abs + moved);
+    let bot_right = floor(br * window.dim) + floor(br_abs + moved);
     let pos = in.clip_position.xy;
     if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
         return color * 0.0;

core/src/ui/active.rs

@@ -1,4 +1,4 @@
-use crate::{LayerId, MaskIdx, PrimitiveHandle, Size, TextureHandle, UiRegion, WidgetId};
+use crate::{LayerId, MaskIdx, MoveIdx, PrimitiveHandle, Size, TextureHandle, UiRegion, WidgetId};
 
 /// important non rendering data for retained drawing
 #[derive(Debug)]
@@ -15,6 +15,8 @@ pub struct ActiveData {
     pub size_deps: Vec<WidgetId>,
     /// Whether it read the output's size, and so is wrong when that changes.
     pub reads_output: bool,
+    /// The move slot its primitives are positioned through.
+    pub move_idx: MoveIdx,
     pub mask: MaskIdx,
     pub layer: LayerId,
 }

core/src/ui/mod.rs

@@ -1,7 +1,14 @@
 use crate::{
-    Mask, PrimitiveRegistry, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena,
+    Mask, MoveIdx, MoveOffset, PrimitiveRegistry, TextData, Textures, WeakWidget, WidgetId,
+    Widgets,
+    util::{Arena, Id, TrackedArena, Vec2},
 };
 
+/// How far the shader will walk a move chain. It bounds a malformed cycle
+/// rather than any real tree; `Moves::resolve` uses the same number so the
+/// two agree on what a deep tree resolves to.
+pub const CHAIN_LIMIT: u32 = 64;
+
 mod active;
 mod painter;
 mod render_state;
@@ -20,6 +27,65 @@ pub struct UiData {
     pub masks: TrackedArena<Mask, u32>,
 }
 
+/// Where each widget's drawing sits relative to its parent's slot, so moving
+/// a subtree writes one entry rather than every descendant's primitives.
+#[derive(Default)]
+pub struct Moves {
+    arena: Arena<MoveOffset, u32>,
+    pub changed: bool,
+}
+
+impl Moves {
+    pub fn push(&mut self, parent: MoveIdx) -> MoveIdx {
+        self.changed = true;
+        MoveIdx::slot(self.arena.push(MoveOffset::root(parent)).idx())
+    }
+
+    pub fn remove(&mut self, idx: MoveIdx) {
+        self.changed = true;
+        self.arena.remove(Id::preset(idx.idx() as u32));
+    }
+
+    /// Sets a slot's translation, in physical pixels, relative to its parent.
+    pub fn set(&mut self, idx: MoveIdx, delta: Vec2) {
+        let entry = self.arena.get_mut(Id::preset(idx.idx() as u32));
+        if entry.delta != delta {
+            entry.delta = delta;
+            self.changed = true;
+        }
+    }
+
+    /// The translation a primitive in `idx` has accumulated, which is the
+    /// same walk the vertex shader does.
+    pub fn resolve(&self, idx: MoveIdx) -> Vec2 {
+        let mut total = Vec2::ZERO;
+        let mut at = idx;
+        for _ in 0..CHAIN_LIMIT {
+            if at == MoveIdx::NONE {
+                return total;
+            }
+            let entry = self.arena[at.idx()];
+            total += entry.delta;
+            at = entry.parent;
+        }
+        debug_assert!(
+            at == MoveIdx::NONE,
+            "a move chain longer than {CHAIN_LIMIT} resolves to the wrong place, \
+             and the shader stops at the same depth"
+        );
+        total
+    }
+
+    pub fn entries(&self) -> &[MoveOffset] {
+        &self.arena
+    }
+
+    pub fn clear(&mut self) {
+        self.changed = true;
+        self.arena = Arena::default();
+    }
+}
+
 pub trait UiRsc {
     fn ui(&self) -> &UiData;
     fn ui_mut(&mut self) -> &mut UiData;

core/src/ui/painter.rs

@@ -2,8 +2,8 @@ use crate::{
     Axis, Len, RenderedText, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
     UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, WidgetId,
     render::{
-        GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, PrimitiveKind,
+        GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveHandle, PrimitiveInst,
-        TexturePrimitive,
+        PrimitiveKind, TexturePrimitive,
     },
     util::Vec2,
 };
@@ -21,6 +21,8 @@ pub struct Painter<'a> {
     /// The children whose size this widget read while drawing.
     pub(super) size_deps: Vec<WidgetId>,
     pub(super) reads_output: bool,
+    /// The move slot this widget's primitives are positioned through.
+    pub(super) move_idx: MoveIdx,
     pub layer: usize,
     pub(super) id: WidgetId,
 }
@@ -41,6 +43,7 @@ impl<'a> Painter<'a> {
                 primitive,
                 region,
                 mask_idx: self.mask,
+                move_idx: self.move_idx,
             },
         );
         self.push_primitive(h);
@@ -67,7 +70,10 @@ impl<'a> Painter<'a> {
 
     pub fn set_mask(&mut self, region: UiRegion) {
         assert!(self.mask == MaskIdx::NONE);
-        self.mask = self.rsc.ui_mut().masks.push(Mask { region });
+        self.mask = self.rsc.ui_mut().masks.push(Mask {
+            region,
+            move_idx: self.move_idx,
+        });
     }
 
     /// Draws a widget within this widget's region.

core/src/ui/render_state.rs

@@ -1,6 +1,6 @@
 use crate::{
-    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, OnResize, Painter, PixelRegion, Remap, Size,
+    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, MoveIdx, Moves, OnResize, Painter, PixelRegion,
-    StrongWidget, UiRegion, UiRsc, WidgetId, Widgets,
+    Remap, Size, StrongWidget, UiRegion, UiRsc, WidgetId, Widgets,
     util::{HashMap, HashSet, Vec2, forget_ref},
 };
 
@@ -12,6 +12,10 @@ pub struct UiRenderState {
     old_root: Option<WidgetId>,
     resized: bool,
     draw_started: HashSet<WidgetId>,
+    /// A widget's move slot, which outlives any one `ActiveData`: a redraw
+    /// replaces that while its children go on pointing at the slot.
+    slots: HashMap<WidgetId, MoveIdx>,
+    pub moves: Moves,
 }
 
 impl UiRenderState {
@@ -23,6 +27,8 @@ impl UiRenderState {
             old_root: None,
             resized: false,
             draw_started: Default::default(),
+            slots: Default::default(),
+            moves: Default::default(),
         }
     }
 
@@ -103,6 +109,8 @@ impl UiRenderState {
         }
 
         // draw widget
+        let move_idx = self.move_slot(id, parent);
+        self.moves.set(move_idx, Vec2::ZERO);
         rsc.widgets_mut().needs_redraw.remove(&id);
         self.draw_started.insert(id);
 
@@ -117,6 +125,7 @@ impl UiRenderState {
             children: Vec::new(),
             size_deps: Vec::new(),
             reads_output: false,
+            move_idx,
             rsc,
         };
 
@@ -134,6 +143,7 @@ impl UiRenderState {
             children,
             size_deps,
             reads_output,
+            move_idx,
             layer,
             id,
         } = painter;
@@ -155,6 +165,7 @@ impl UiRenderState {
             children,
             size_deps,
             reads_output,
+            move_idx,
             mask,
             layer,
         };
@@ -171,6 +182,20 @@ impl UiRenderState {
         size
     }
 
+    /// The slot a widget's drawing is positioned through, made on its first
+    /// draw and kept until it stops being drawn.
+    fn move_slot(&mut self, id: WidgetId, parent: Option<WidgetId>) -> MoveIdx {
+        if let Some(&idx) = self.slots.get(&id) {
+            return idx;
+        }
+        let parent = parent
+            .and_then(|p| self.slots.get(&p).copied())
+            .unwrap_or(MoveIdx::NONE);
+        let idx = self.moves.push(parent);
+        self.slots.insert(id, idx);
+        idx
+    }
+
     /// The drawing a widget already has, kept for a new box if the box has not
     /// changed in a way it depends on.
     fn try_reuse(&mut self, id: WidgetId, region: UiRegion, rsc: &dyn UiRsc) -> Option<Size> {
@@ -178,12 +203,18 @@ impl UiRenderState {
             return None;
         }
         let active = self.active.get(&id)?;
-        let (size, old) = (active.size, active.region);
+        let (size, old, slot) = (active.size, active.region, active.move_idx);
-        if old == region {
+        // TODO: epsilon?
+        if old.size() == region.size() {
+            // The right shape and only somewhere else, which is one slot to
+            // write however much is under it. Both boxes are in the
+            // coordinates its parent drew, so the chain above applies alike.
+            let moved =
+                region.to_px(self.output_size).top_left - old.to_px(self.output_size).top_left;
+            self.moves.set(slot, moved);
             return Some(size);
         }
-        // TODO: epsilon?
+        if !self.reusable(id, region, rsc) {
-        if old.size() != region.size() && !self.reusable(id, region, rsc) {
             return None;
         }
         // Its drawing stands, if the new box can be reached from the old one.
@@ -228,6 +259,9 @@ impl UiRenderState {
         })
     }
 
+    /// Rewrites a subtree's regions into a new box, for a change a slot
+    /// cannot express. Every region it rewrites is a region some slot was a
+    /// delta from, so those go back to zero.
     fn mov(&mut self, id: WidgetId, remap: &Remap) {
         let active = self.active.get_mut(&id).unwrap();
         for h in &active.primitives {
@@ -235,6 +269,7 @@ impl UiRenderState {
             *region = remap.apply(*region);
         }
         active.region = remap.apply(active.region);
+        self.moves.set(active.move_idx, Vec2::ZERO);
         // SAFETY: children cannot be recursive
         let children = unsafe { forget_ref(&active.children) };
         for child in children {
@@ -268,6 +303,10 @@ impl UiRenderState {
                 self.remove_rec(*c, rsc);
             }
         }
+        // After the descendants, whose slots name this one as their parent.
+        if let Some(idx) = self.slots.remove(&id) {
+            self.moves.remove(idx);
+        }
         inst
     }
 
@@ -275,6 +314,8 @@ impl UiRenderState {
         for (_, active) in self.active.drain() {
             rsc.on_undraw(&active);
         }
+        self.slots.clear();
+        self.moves.clear();
         self.layers.clear();
         rsc.widgets_mut().needs_redraw.clear();
         rsc.free();
@@ -322,9 +363,16 @@ impl UiRenderState {
         }
     }
 
+    /// Where a widget is on screen: the box it drew against plus whatever the
+    /// chain above has moved since, which is the walk the vertex shader does.
     pub fn window_region(&self, id: &impl IdLike) -> Option<PixelRegion> {
-        let region = self.active.get(&id.id())?.region;
+        let active = self.active.get(&id.id())?;
-        Some(region.to_px(self.output_size))
+        let moved = self.moves.resolve(active.move_idx);
+        let region = active.region.to_px(self.output_size);
+        Some(PixelRegion {
+            top_left: region.top_left + moved,
+            bot_right: region.bot_right + moved,
+        })
     }
 
     /// redraws a widget that's currently active (drawn)

core/src/util/arena.rs

@@ -34,6 +34,10 @@ impl<T, I: IdNum> Arena<T, I> {
         self.tracker.free(id);
         self.data[i]
     }
+
+    pub fn get_mut(&mut self, id: Id<I>) -> &mut T {
+        &mut self.data[id.idx()]
+    }
 }
 
 impl<T, I: IdNum> Default for Arena<T, I> {

core/src/util/vec2.rs

@@ -1,7 +1,11 @@
 use crate::util::impl_op;
 use std::{hash::Hash, ops::*};
 
-#[repr(C)]
+/// `align(8)` because that is WGSL's alignment for a `vec2<f32>`, so any GPU
+/// struct holding one is laid out the way its shader reads it without having
+/// to say so itself. Those structs still need a manual `unsafe impl Pod`,
+/// since the trailing padding this introduces is what `derive(Pod)` refuses.
+#[repr(C, align(8))]
 #[derive(Clone, Copy, PartialEq, Default, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct Vec2 {
     pub x: f32,

rig-input/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rig-input"
+version.workspace = true
+edition.workspace = true
+
+# Replays `.touch` recordings through Wayland's virtual-pointer protocol;
+# headless sway has no input devices for coordinate-driving tools to move.
+[[bin]]
+name = "replay-touch"
+path = "src/main.rs"
+
+[dependencies]
+# Share the harness parser so both ways of replaying read a file the same.
+iris = { path = ".." }
+wayland-client = { workspace = true }
+wayland-protocols-wlr = { workspace = true }

rig-input/src/main.rs

@@ -0,0 +1,141 @@
+use iris::harness::{TouchAction, TouchScript};
+use std::time::Duration;
+use wayland_client::protocol::wl_pointer::ButtonState;
+use wayland_client::protocol::{wl_registry, wl_seat};
+use wayland_client::{Connection, Dispatch, QueueHandle, delegate_noop};
+use wayland_protocols_wlr::virtual_pointer::v1::client::{
+    zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1,
+    zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1,
+};
+
+const BTN_LEFT: u32 = 0x110;
+
+const SETTLE: Duration = Duration::from_millis(200);
+
+#[derive(Default)]
+struct Globals {
+    seat: Option<wl_seat::WlSeat>,
+    manager: Option<ZwlrVirtualPointerManagerV1>,
+}
+
+impl Dispatch<wl_registry::WlRegistry, ()> for Globals {
+    fn event(
+        state: &mut Self,
+        registry: &wl_registry::WlRegistry,
+        event: wl_registry::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
+    ) {
+        let wl_registry::Event::Global {
+            name,
+            interface,
+            version,
+        } = event
+        else {
+            return;
+        };
+        match interface.as_str() {
+            "wl_seat" => {
+                state.seat = Some(registry.bind(name, version.min(7), qh, ()));
+            }
+            "zwlr_virtual_pointer_manager_v1" => {
+                state.manager = Some(registry.bind(name, version.min(2), qh, ()));
+            }
+            _ => {}
+        }
+    }
+}
+
+delegate_noop!(Globals: ignore wl_seat::WlSeat);
+delegate_noop!(Globals: ZwlrVirtualPointerManagerV1);
+delegate_noop!(Globals: ZwlrVirtualPointerV1);
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let [width, height, path] = args.as_slice() else {
+        eprintln!("usage: replay-touch WIDTH HEIGHT FILE");
+        std::process::exit(2);
+    };
+    let (width, height) = (parse(width, "WIDTH"), parse(height, "HEIGHT"));
+    let text = std::fs::read_to_string(path)
+        .unwrap_or_else(|e| fail(&format!("could not read {path}: {e}")));
+    let script = TouchScript::parse(&text).unwrap_or_else(|e| fail(&e));
+
+    let conn = Connection::connect_to_env().unwrap_or_else(|e| {
+        fail(&format!(
+            "no wayland display ({e}); is WAYLAND_DISPLAY set?"
+        ))
+    });
+    let mut queue = conn.new_event_queue();
+    let qh = queue.handle();
+    let display = conn.display();
+    display.get_registry(&qh, ());
+    let mut globals = Globals::default();
+    queue
+        .roundtrip(&mut globals)
+        .unwrap_or_else(|e| fail(&format!("wayland roundtrip failed: {e}")));
+
+    let manager = globals.manager.as_ref().unwrap_or_else(|| {
+        fail(
+            "this compositor does not offer zwlr_virtual_pointer_manager_v1, so a pointer cannot \
+             be synthesised; sway and every wlroots compositor do",
+        )
+    });
+    let pointer = manager.create_virtual_pointer(globals.seat.as_ref(), &qh, ());
+
+    // Put the pointer where the gesture starts and let the compositor
+    // settle before anything is pressed. Without this the press is
+    // dropped: sway has just learned about this pointer, and a button
+    // sent in the same breath as the motion that first puts it over a
+    // window arrives before there is a focused surface to send it to --
+    // winit sees `CursorEntered`, the moves and the *release*, never the
+    // press, so the gesture reads as a hover and nothing scrolls. Found
+    // by printing winit's own events; the settle is what fixed it.
+    if let Some(first) = script.samples.first() {
+        pointer.motion_absolute(0, first.pos.x as u32, first.pos.y as u32, width, height);
+        pointer.frame();
+        conn.flush()
+            .unwrap_or_else(|e| fail(&format!("flush: {e}")));
+        std::thread::sleep(SETTLE);
+    }
+
+    let mut previous = 0;
+    for sample in &script.samples {
+        std::thread::sleep(Duration::from_millis(sample.t_ms - previous));
+        previous = sample.t_ms;
+        let t = sample.t_ms as u32;
+        pointer.motion_absolute(t, sample.pos.x as u32, sample.pos.y as u32, width, height);
+        pointer.frame();
+        // The button goes in a frame of its own, *after* the motion has
+        // been committed. Sent in the same frame as the motion that
+        // first puts the pointer over the window, sway drops it: the
+        // client sees `CursorEntered` and the moves but never a
+        // `MouseInput { state: Pressed }`, so the whole gesture reads as
+        // a hover and nothing scrolls. Found exactly that way, by
+        // printing winit's events.
+        let state = match sample.action {
+            TouchAction::Down => Some(ButtonState::Pressed),
+            TouchAction::Up => Some(ButtonState::Released),
+            TouchAction::Move => None,
+        };
+        if let Some(state) = state {
+            pointer.button(t, BTN_LEFT, state);
+            pointer.frame();
+        }
+        conn.flush()
+            .unwrap_or_else(|e| fail(&format!("flush: {e}")));
+    }
+    pointer.destroy();
+    conn.flush().ok();
+}
+
+fn parse(text: &str, what: &str) -> u32 {
+    text.parse()
+        .unwrap_or_else(|_| fail(&format!("{what} is not a whole number: {text:?}")))
+}
+
+fn fail(message: &str) -> ! {
+    eprintln!("replay-touch: {message}");
+    std::process::exit(1);
+}

scripts/headless.conf

@@ -0,0 +1,14 @@
+# The compositor `scripts/run-headless.sh` starts, so that an example has a
+# surface where there is no display. Nothing here is meant to be looked at
+# directly; `grim` is.
+#
+# No Xwayland: winit talks Wayland natively, so an X server is a second thing
+# to go wrong for no gain.
+xwayland disable
+
+# The default output, overridden per run by `--mode`. Larger than the window
+# an example opens, so nothing is scaled or clipped.
+output HEADLESS-1 mode 1920x1200@60Hz
+
+default_border none
+focus_follows_mouse no

scripts/run-headless.sh

@@ -0,0 +1,170 @@
+#!/bin/sh
+# Run an iris example on a machine with no display.
+#
+#   ./scripts/run-headless.sh tabs
+#   ./scripts/run-headless.sh tabs --shot /tmp/tabs.png --seconds 4
+#   ./scripts/run-headless.sh tabs --replay taps.touch --shot /tmp/tabs.png
+#   ./scripts/run-headless.sh app --dir ../elsewhere --mode 1080x2424@120Hz
+#
+# `--dir DIR` names the workspace to build in, defaulting to this one, so a
+# project that depends on iris can be run through the same rig. `--bin` runs a
+# crate binary rather than an example, and takes its own argv from
+# `$RUN_HEADLESS_ARGS`, word-split on purpose.
+#
+# `--mode` sets the output, for running something at a size other than a
+# desktop's -- a phone's, say. Set every run rather than only when it changes:
+# the compositor is reused between runs, so a default-shaped run after a
+# custom one would otherwise inherit the other's output and quietly screenshot
+# the wrong size.
+#
+# `--replay FILE` drives a `.touch` recording into the window through
+# `replay-touch`, which reads it with the same parser `iris::harness` uses. A
+# recording is `<ms> down|move|up <x> <y>` in the output's own pixels. With
+# `--shot` it also writes `<shot>-before.png` from just before the gesture,
+# since "it moved" is a claim about two pictures.
+#
+# What it supplies is a compositor for winit to open a surface on: a headless
+# sway, and `grim` to screenshot it. Sway gets its own socket and runtime
+# directory rather than joining whatever else is running, because it tiles --
+# adding a window to someone else's compositor resizes theirs.
+set -eu
+
+need() {
+    command -v "$1" >/dev/null 2>&1 || {
+        echo "run-headless: $1 is not installed ($2)" >&2
+        exit 127
+    }
+}
+need sway "the compositor an example opens its window on"
+need swaymsg "sway's control socket"
+
+scripts=$(cd "$(dirname "$0")" && pwd)
+root=$(cd "$scripts/.." && pwd)
+workdir="$root"
+cd "$root"
+run="${XDG_RUNTIME_DIR:-/tmp}/iris-headless"
+seconds=3
+shot=""
+replay=""
+example=""
+kind=example
+mode=1920x1200@60Hz
+
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --shot) shot=$2; shift 2 ;;
+        --seconds) seconds=$2; shift 2 ;;
+        --bin) kind=bin; shift ;;
+        --mode) mode=$2; shift 2 ;;
+        --replay) replay=$2; shift 2 ;;
+        --dir) workdir=$(cd "$2" && pwd); shift 2 ;;
+        --) shift; break ;;
+        *) example=$1; shift ;;
+    esac
+done
+[ -n "$example" ] || { echo "usage: $0 NAME [--bin] [--dir DIR] [--mode WxH@Hz] [--replay TOUCH] [--shot PNG] [--seconds N] [-- cargo args]" >&2; exit 2; }
+[ -z "$replay" ] || [ -f "$replay" ] || { echo "run-headless: no touch script at $replay" >&2; exit 2; }
+[ -z "$shot" ] || need grim "the screenshot --shot writes"
+
+mkdir -p "$run"
+export SWAYSOCK="$run/sway.sock"
+
+# Named rather than left to sway's pid-based default, so a second run reuses
+# this compositor instead of starting another beside it.
+if ! swaymsg -t get_version >/dev/null 2>&1; then
+    rm -f "$SWAYSOCK"
+    WLR_BACKENDS=headless WLR_LIBINPUT_NO_DEVICES=1 LIBSEAT_BACKEND=noop \
+        setsid sway -c "$scripts/headless.conf" >"$run/sway.log" 2>&1 &
+    i=0
+    while [ $i -lt 20 ]; do
+        swaymsg -t get_version >/dev/null 2>&1 && break
+        i=$((i + 1)); sleep 0.5
+    done
+    swaymsg -t get_version >/dev/null 2>&1 || {
+        echo "run-headless: compositor did not start; see $run/sway.log" >&2
+        exit 1
+    }
+fi
+
+rm -f "$run/display"
+swaymsg exec -- "sh -c 'printf %s \"\$WAYLAND_DISPLAY\" > $run/display'" >/dev/null
+i=0
+while [ $i -lt 20 ]; do
+    [ -s "$run/display" ] && break
+    i=$((i + 1)); sleep 0.5
+done
+[ -s "$run/display" ] || { echo "run-headless: could not read WAYLAND_DISPLAY" >&2; exit 1; }
+WAYLAND_DISPLAY=$(cat "$run/display")
+export WAYLAND_DISPLAY
+
+echo "run-headless: $WAYLAND_DISPLAY (sway $(swaymsg -t get_version --raw | sed -n 's/.*"human_readable":"\([^"]*\)".*/\1/p'))" >&2
+
+swaymsg output HEADLESS-1 mode "$mode" >/dev/null
+# The extent `replay-touch` positions against, so a script's coordinates
+# are the output's own pixels.
+out_w=${mode%x*}
+out_h=${mode#*x}; out_h=${out_h%@*}
+
+# Built before the app starts, so a compile error is not reported as a
+# window that failed to move.
+[ -z "$replay" ] || (cd "$root" && cargo build --bin replay-touch -p rig-input) >&2
+
+cd "$workdir"
+if [ "$kind" = bin ]; then
+    cargo build --bin "$example" "$@" >&2
+    bin="$workdir/target/debug/$example"
+else
+    cargo build --example "$example" "$@" >&2
+    bin="$workdir/target/debug/examples/$example"
+fi
+
+# Deliberately word-split: this is the binary's own argv, not a single path.
+# shellcheck disable=SC2086
+"$bin" ${RUN_HEADLESS_ARGS:-} >"$run/$example.log" 2>&1 &
+pid=$!
+trap 'kill "$pid" 2>/dev/null || true' EXIT INT TERM
+
+# Wait for the window to be mapped rather than for a number of seconds. A
+# fixed sleep took an all-black screenshot the first time this ran, when sway
+# had started in the same invocation and had not composited its output yet --
+# which is indistinguishable from an app that draws nothing.
+i=0
+while [ $i -lt 40 ]; do
+    kill -0 "$pid" 2>/dev/null || break
+    swaymsg -t get_tree --raw 2>/dev/null | grep -q "\"pid\":$pid," && break
+    i=$((i + 1)); sleep 0.25
+done
+
+i=0
+while [ $i -lt "$((seconds * 2))" ]; do
+    kill -0 "$pid" 2>/dev/null || break
+    i=$((i + 1)); sleep 0.5
+done
+
+if [ -n "$replay" ] && kill -0 "$pid" 2>/dev/null; then
+    if [ -n "$shot" ]; then
+        grim "${shot%.png}-before.png"
+        echo "run-headless: wrote ${shot%.png}-before.png (before the gesture)" >&2
+    fi
+    "$root/target/debug/replay-touch" "$out_w" "$out_h" "$replay"
+    # A fling outlives the finger: the gesture's own last sample is not
+    # when the list stops. Long enough for Android's spline to settle
+    # (`FlingCalculator::duration` tops out around a second and a half).
+    sleep 2
+fi
+
+if kill -0 "$pid" 2>/dev/null; then
+    [ -n "$shot" ] && grim "$shot" && echo "run-headless: wrote $shot" >&2
+    kill "$pid" 2>/dev/null || true
+    wait "$pid" 2>/dev/null || true
+    status=0
+else
+    wait "$pid" 2>/dev/null || status=$?
+    echo "run-headless: $example exited early (status ${status:-0})" >&2
+    status=${status:-1}
+fi
+
+echo "--- $example output ---" >&2
+cat "$run/$example.log" >&2
+exit "$status"

src/harness.rs

@@ -37,6 +37,81 @@ macro_rules! assert_corners {
 }
 pub use crate::assert_corners;
 
+/// One replayed pointer sample, cut down to what a window delivers: where the
+/// pointer is, and whether the button changed.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TouchAction {
+    Down,
+    Move,
+    Up,
+}
+
+impl TouchAction {
+    fn parse(word: &str) -> Option<Self> {
+        match word {
+            "down" => Some(Self::Down),
+            "move" => Some(Self::Move),
+            "up" => Some(Self::Up),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct TouchSample {
+    pub t_ms: u64,
+    pub action: TouchAction,
+    pub pos: Vec2,
+}
+
+/// A recorded gesture, in the output's own pixels: `<ms> down|move|up <x> <y>`
+/// a line, `#` to end of line ignored.
+///
+/// One parser for both ways of replaying a recording -- into a harness, and
+/// into a real window -- so the two cannot read the same file differently.
+pub struct TouchScript {
+    pub samples: Vec<TouchSample>,
+}
+
+impl TouchScript {
+    pub fn parse(text: &str) -> Result<Self, String> {
+        let mut samples: Vec<TouchSample> = Vec::new();
+        for (i, line) in text.lines().enumerate() {
+            let line = line.split('#').next().unwrap_or("").trim();
+            if line.is_empty() {
+                continue;
+            }
+            let at = |what: &str| format!("touch script line {}: {what}: {line:?}", i + 1);
+            let mut words = line.split_whitespace();
+            let (Some(t), Some(action), Some(x), Some(y), None) = (
+                words.next(),
+                words.next(),
+                words.next(),
+                words.next(),
+                words.next(),
+            ) else {
+                return Err(at("expected `t_ms action x y`"));
+            };
+            let t_ms: u64 = t.parse().map_err(|_| at("t_ms is not a whole number"))?;
+            let action =
+                TouchAction::parse(action).ok_or_else(|| at("action is not down/move/up"))?;
+            let x: f32 = x.parse().map_err(|_| at("x is not a number"))?;
+            let y: f32 = y.parse().map_err(|_| at("y is not a number"))?;
+            if let Some(last) = samples.last()
+                && t_ms < last.t_ms
+            {
+                return Err(at("samples must be in time order"));
+            }
+            samples.push(TouchSample {
+                t_ms,
+                action,
+                pos: Vec2::new(x, y),
+            });
+        }
+        Ok(Self { samples })
+    }
+}
+
 #[derive(Default)]
 pub struct HarnessState {
     pub root: Option<StrongWidget>,
@@ -160,6 +235,23 @@ impl Harness {
         self.release(CursorButton::Left);
     }
 
+    /// Drives a recorded gesture through the harness.
+    pub fn replay(&mut self, script: &TouchScript) {
+        for sample in &script.samples {
+            match sample.action {
+                TouchAction::Down => {
+                    self.move_to(sample.pos);
+                    self.press(CursorButton::Left);
+                }
+                TouchAction::Move => self.move_to(sample.pos),
+                TouchAction::Up => {
+                    self.move_to(sample.pos);
+                    self.release(CursorButton::Left);
+                }
+            }
+        }
+    }
+
     fn button(&mut self, button: CursorButton) -> &mut ActivationState {
         let buttons = &mut self.cursor.buttons;
         match button {
@@ -178,3 +270,51 @@ impl Harness {
         self.cursor.end_frame();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parse(text: &str) -> Result<Vec<(u64, TouchAction, f32, f32)>, String> {
+        Ok(TouchScript::parse(text)?
+            .samples
+            .iter()
+            .map(|s| (s.t_ms, s.action, s.pos.x, s.pos.y))
+            .collect())
+    }
+
+    #[test]
+    fn a_recording_is_time_action_and_a_point() {
+        assert_eq!(
+            parse("0 down 10 20\n16 move 10.5 24\n32 up 10.5 24").unwrap(),
+            [
+                (0, TouchAction::Down, 10.0, 20.0),
+                (16, TouchAction::Move, 10.5, 24.0),
+                (32, TouchAction::Up, 10.5, 24.0),
+            ]
+        );
+    }
+
+    #[test]
+    fn blank_lines_and_comments_are_not_samples() {
+        assert_eq!(
+            parse("# a flick\n\n 0 down 1 2   # the finger lands\n\n").unwrap(),
+            [(0, TouchAction::Down, 1.0, 2.0)]
+        );
+    }
+
+    #[test]
+    fn a_recording_that_goes_backwards_is_rejected() {
+        // Replay waits out the gap between samples, so time running backwards
+        // would silently become no wait at all.
+        let err = parse("16 down 1 2\n0 up 1 2").unwrap_err();
+        assert!(err.contains("time order"), "{err}");
+    }
+
+    #[test]
+    fn a_line_that_is_not_a_sample_says_which_line() {
+        let err = parse("0 down 1 2\n16 wiggle 1 2").unwrap_err();
+        assert!(err.contains("line 2"), "{err}");
+        assert!(err.contains("down/move/up"), "{err}");
+    }
+}

tests/draw_cost.rs

@@ -22,8 +22,8 @@ use std::time::Instant;
 
 use iris::prelude::*;
 use iris_core::{
-    GlyphPrimitive, MaskIdx, PrimitiveInst, RectPrimitive, TextureHandle, TexturePrimitive, UiData,
+    GlyphPrimitive, MaskIdx, MoveIdx, PrimitiveInst, RectPrimitive, TextureHandle,
-    UiRegion, UiRenderNode, UiRenderState,
+    TexturePrimitive, UiData, UiRegion, UiRenderNode, UiRenderState,
 };
 use wgpu::{Color as GpuColor, *};
 
@@ -95,6 +95,7 @@ fn fill(
                     primitive: RectPrimitive::color(UiColor::WHITE),
                     region: UiRegion::FULL,
                     mask_idx: MaskIdx::NONE,
+                    move_idx: MoveIdx::NONE,
                 },
             );
             render.layers.write(
@@ -111,6 +112,7 @@ fn fill(
                     },
                     region: UiRegion::FULL,
                     mask_idx: MaskIdx::NONE,
+                    move_idx: MoveIdx::NONE,
                 },
             );
         }
@@ -123,6 +125,7 @@ fn fill(
                     primitive: TexturePrimitive::from(h),
                     region: UiRegion::FULL,
                     mask_idx: MaskIdx::NONE,
+                    move_idx: MoveIdx::NONE,
                 },
             );
         }

tests/layout.rs

@@ -109,3 +109,20 @@ fn a_fixed_box_is_drawn_again_rather_than_stretched() {
 
     assert_corners!(h, panel, (0, 0), (400, 250));
 }
+
+#[test]
+fn a_moved_subtree_takes_its_children_with_it() {
+    let mut h = Harness::new((400, 400));
+    let first = rect(Color::RED).height(40).add(&mut h.rsc);
+    let inner = rect(Color::BLUE).add(&mut h.rsc);
+    let row = inner.pad(10).height(40).add(&mut h.rsc);
+    h.set_root((first, row).span(Dir::DOWN));
+    assert_corners!(h, inner, (10, 50), (390, 70));
+
+    h.rsc[first].y = Some(Len::abs(80));
+    h.frame();
+
+    // The row is the same shape somewhere else, so one slot moved it and
+    // `inner`'s own region was never rewritten.
+    assert_corners!(h, inner, (10, 90), (390, 110));
+}

tests/pointer.rs

@@ -2,7 +2,7 @@
 
 use std::{cell::RefCell, rc::Rc};
 
-use iris::harness::Harness;
+use iris::harness::{Harness, TouchScript};
 use iris::prelude::*;
 
 #[test]
@@ -58,3 +58,28 @@ fn hover_ends_when_the_cursor_leaves_the_window() {
     h.leave();
     assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 1));
 }
+
+#[test]
+fn a_recorded_gesture_presses_where_it_says() {
+    let mut h = Harness::new((400, 200));
+    let clicks = Rc::new(RefCell::new(Vec::new()));
+
+    let (on_left, on_right) = (clicks.clone(), clicks.clone());
+    let left = rect(Color::RED)
+        .width(100)
+        .on(CursorSense::click(), move |_, _| {
+            on_left.borrow_mut().push("left")
+        })
+        .add(&mut h.rsc);
+    let right = rect(Color::BLUE)
+        .on(CursorSense::click(), move |_, _| {
+            on_right.borrow_mut().push("right")
+        })
+        .add(&mut h.rsc);
+    h.set_root((left, right).span(Dir::RIGHT));
+
+    let script = TouchScript::parse("0 down 300 100\n80 up 300 100").unwrap();
+    h.replay(&script);
+
+    assert_eq!(*clicks.borrow(), ["right"]);
+}