diff --git a/Cargo.toml b/Cargo.toml
index 90abcd3c..6b7e16a2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,7 @@ repository = "https://github.com/adam-Vandervorst/pathMap/"
 keywords = ["trie", "MORK", "path", "algebra"]
 categories = ["algorithms", "data-structures", "database-implementations"]
 readme = "README.md"
-exclude = ["target/", "benches/", "pathmap-book/", ".*"]
+exclude = ["target/", "benches/", "pathmap-book/", "tools/", ".*"]
 
 [package.metadata.docs.rs]
 rustc-args = ["-C", "target-feature=+aes,+sse2"]
@@ -151,5 +151,5 @@ name = "act_line_cache"
 required-features = ["arena_compact", "serialization"]
 
 [workspace]
-members = ["pathmap-derive", "examples/sampling", "examples/arena_compact_tests", "differential"]
+members = ["pathmap-derive", "examples/sampling", "examples/arena_compact_tests", "differential", "tools/tracer"]
 resolver = "2"
diff --git a/src/utils/debug/mod.rs b/src/utils/debug/mod.rs
index 7006d22f..9e28bd1c 100644
--- a/src/utils/debug/mod.rs
+++ b/src/utils/debug/mod.rs
@@ -3,6 +3,9 @@
 mod diff_zipper;
 pub use diff_zipper::DiffZipper;
 
+pub mod zipper_tracing;
+pub use zipper_tracing::TraceZipper;
+
 mod morphism_debug;
 pub use morphism_debug::CatamorphismDebug;
 
diff --git a/src/utils/debug/zipper_tracing.rs b/src/utils/debug/zipper_tracing.rs
new file mode 100644
index 00000000..26ca5983
--- /dev/null
+++ b/src/utils/debug/zipper_tracing.rs
@@ -0,0 +1,1075 @@
+
+//! Records every call made on traced zippers into a single shared binary trace, so a run can later
+//! be replayed for debugging or visualization
+//!
+//! Usage:
+//! 1. Call [open] (or [open_file]) once, to supply the writer and the value type `V` for the trace
+//! 2. Wrap each zipper of interest in a [TraceZipper], giving it an id.  Every zipper writes to the same trace
+//! 3. Call [close] to flush the trace
+//!
+//! The trace is a header followed by a stream of `(seq, zipper_id, TraceOp)` events, which [decode_trace]
+//! turns back into [TraceOp]s.  `seq` numbers the events of a trace in the order they were recorded, starting
+//! from 0, so an event can be referred to even if the stream is later filtered.
+//!
+//! An event is written as a call begins, so the trace records which operations were called and with
+//! what arguments, but not their results.  A player needs its own copy of the trie to follow along.
+//!
+//! Calls made on a `TraceZipper` while another traced call on the same thread is in progress are not
+//! recorded, because they're the inner workings of the outer call.  For example, when a traced write
+//! zipper grafts from a traced read zipper, only the graft is recorded.  The same applies to calls
+//! made from user code that runs inside a traced call, such as a [PathObserver], or the closure passed
+//! to [ZipperWriting::get_val_or_set_mut_with].
+//!
+//! When an operation takes another zipper as an argument, such as [ZipperWriting::graft], the argument
+//! is recorded by id if it's also a `TraceZipper`, or by its contents if it isn't (see [TraceSrc]).
+//! A traced argument is recognized by probing its [Zipper::path_exists] method, so any wrapper that forwards
+//! `path_exists` to a `TraceZipper` is reported as that zipper.  That's right for transparent wrappers like
+//! `&mut` and `Box`, but an abstract zipper such as a [PrefixZipper] around a `TraceZipper` will be
+//! misreported as the `TraceZipper` it wraps.
+//!
+//! The internal accessor methods (e.g. [ZipperInfallibleSubtries::get_focus]), [ZipperConcrete],
+//! [ZipperPathBuffer], and [ZipperReadOnlySubtries] are forwarded without being recorded.
+
+use core::any::{type_name, TypeId};
+use core::cell::Cell;
+use core::sync::atomic::{AtomicBool, Ordering};
+use std::fs::File;
+use std::io::{self, BufWriter, Write};
+use std::path::Path;
+use std::sync::{Mutex, MutexGuard};
+
+use crate::alloc::Allocator;
+use crate::ring::{AlgebraicStatus, DistributiveLattice, Lattice};
+use crate::trie_node::{TaggedNodeRef, TrieNodeODRc};
+use crate::utils::ByteMask;
+use crate::write_zipper::write_zipper_priv::WriteZipperPriv;
+use crate::zipper::*;
+use crate::zipper::read_zipper_core::ReadZipperCore;
+use crate::zipper::zipper_priv::ZipperReadOnlyPriv;
+use crate::PathMap;
+
+const TRACE_MAGIC: &[u8; 8] = b"PMTRACE\0";
+const TRACE_VERSION: u64 = 2;
+
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+// Encoding
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+
+/// A type that can be written into, and read back from, a zipper trace
+///
+/// Implemented for the value types expected to be used with tracing, and for the types that make up a [TraceOp]
+pub trait TraceValue: Sized + 'static {
+    fn encode(&self, out: &mut Vec<u8>);
+    /// Decodes a value from the front of `input`, advancing `input` past it
+    fn decode(input: &mut &[u8]) -> Option<Self>;
+}
+
+impl TraceValue for () {
+    fn encode(&self, _out: &mut Vec<u8>) {}
+    fn decode(_input: &mut &[u8]) -> Option<Self> { Some(()) }
+}
+
+impl TraceValue for u8 {
+    fn encode(&self, out: &mut Vec<u8>) { out.push(*self) }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        let (&byte, rest) = input.split_first()?;
+        *input = rest;
+        Some(byte)
+    }
+}
+
+impl TraceValue for bool {
+    fn encode(&self, out: &mut Vec<u8>) { out.push(*self as u8) }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        match u8::decode(input)? {
+            0 => Some(false),
+            1 => Some(true),
+            _ => None
+        }
+    }
+}
+
+/// LEB128 encoding
+impl TraceValue for u64 {
+    fn encode(&self, out: &mut Vec<u8>) {
+        let mut x = *self;
+        loop {
+            let byte = (x & 0x7f) as u8;
+            x >>= 7;
+            if x == 0 {
+                out.push(byte);
+                return
+            }
+            out.push(byte | 0x80);
+        }
+    }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        let mut x = 0u64;
+        let mut shift = 0;
+        loop {
+            let byte = u8::decode(input)?;
+            if shift >= 64 {
+                return None
+            }
+            x |= ((byte & 0x7f) as u64) << shift;
+            if byte & 0x80 == 0 {
+                return Some(x)
+            }
+            shift += 7;
+        }
+    }
+}
+
+macro_rules! impl_trace_value_via_u64 {
+    ($($t:ty),*) => {$(
+        impl TraceValue for $t {
+            fn encode(&self, out: &mut Vec<u8>) { (*self as u64).encode(out) }
+            fn decode(input: &mut &[u8]) -> Option<Self> { u64::decode(input)?.try_into().ok() }
+        }
+    )*};
+}
+impl_trace_value_via_u64!(u16, u32, usize);
+
+impl TraceValue for ByteMask {
+    fn encode(&self, out: &mut Vec<u8>) {
+        for word in self.0 {
+            out.extend_from_slice(&word.to_le_bytes());
+        }
+    }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        let mut mask = ByteMask::new();
+        for word in mask.0.iter_mut() {
+            let (bytes, rest) = input.split_first_chunk::<8>()?;
+            *word = u64::from_le_bytes(*bytes);
+            *input = rest;
+        }
+        Some(mask)
+    }
+}
+
+impl<T: TraceValue> TraceValue for Option<T> {
+    fn encode(&self, out: &mut Vec<u8>) {
+        match self {
+            None => out.push(0),
+            Some(val) => {
+                out.push(1);
+                val.encode(out);
+            }
+        }
+    }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        match u8::decode(input)? {
+            0 => Some(None),
+            1 => Some(Some(T::decode(input)?)),
+            _ => None
+        }
+    }
+}
+
+impl<T: TraceValue> TraceValue for Vec<T> {
+    fn encode(&self, out: &mut Vec<u8>) {
+        self.len().encode(out);
+        for item in self {
+            item.encode(out);
+        }
+    }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        let len = usize::decode(input)?;
+        //Don't trust `len` for the allocation, in case the input is corrupt
+        let mut items = Vec::with_capacity(len.min(input.len()));
+        for _ in 0..len {
+            items.push(T::decode(input)?);
+        }
+        Some(items)
+    }
+}
+
+impl<T0: TraceValue, T1: TraceValue> TraceValue for (T0, T1) {
+    fn encode(&self, out: &mut Vec<u8>) {
+        self.0.encode(out);
+        self.1.encode(out);
+    }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        Some((T0::decode(input)?, T1::decode(input)?))
+    }
+}
+
+impl TraceValue for String {
+    fn encode(&self, out: &mut Vec<u8>) { self.as_bytes().to_vec().encode(out) }
+    fn decode(input: &mut &[u8]) -> Option<Self> { String::from_utf8(Vec::<u8>::decode(input)?).ok() }
+}
+
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+// Opcodes
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+
+/// The source argument of an operation that reads from another zipper, such as [ZipperWriting::graft]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum TraceSrc<V> {
+    /// The source is the [TraceZipper] with this id
+    Traced(u64),
+    /// The source isn't traced, so its contents are recorded instead.  The `(path, value)` pairs are
+    /// relative to the source's focus, and a value at the focus itself has an empty path
+    Unknown(Vec<(Vec<u8>, V)>),
+}
+
+impl<V: TraceValue> TraceValue for TraceSrc<V> {
+    fn encode(&self, out: &mut Vec<u8>) {
+        match self {
+            Self::Traced(id) => {
+                out.push(0);
+                id.encode(out);
+            },
+            Self::Unknown(entries) => {
+                out.push(1);
+                entries.encode(out);
+            }
+        }
+    }
+    fn decode(input: &mut &[u8]) -> Option<Self> {
+        match u8::decode(input)? {
+            0 => Some(Self::Traced(u64::decode(input)?)),
+            1 => Some(Self::Unknown(Vec::decode(input)?)),
+            _ => None
+        }
+    }
+}
+
+/// Defines [TraceOp], with an explicit opcode for each variant, so the encoding stays stable as ops are added
+macro_rules! trace_ops {
+    ($( $(#[$attr:meta])* $code:literal => $name:ident $({ $($field:ident : $ty:ty),* $(,)? })? ),* $(,)?) => {
+        /// One call recorded in a zipper trace.  Most variants correspond to the zipper method with the same name
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub enum TraceOp<V> {
+            $( $(#[$attr])* $name $({ $($field: $ty),* })? ),*
+        }
+
+        impl<V: TraceValue> TraceValue for TraceOp<V> {
+            fn encode(&self, out: &mut Vec<u8>) {
+                match self {
+                    $( Self::$name $({ $($field),* })? => {
+                        out.push($code);
+                        $($( $field.encode(out); )*)?
+                    } )*
+                }
+            }
+            fn decode(input: &mut &[u8]) -> Option<Self> {
+                match u8::decode(input)? {
+                    $( $code => Some(Self::$name $({ $($field: <$ty>::decode(input)?),* })?), )*
+                    _ => None
+                }
+            }
+        }
+    };
+}
+
+trace_ops! {
+    /// A [TraceZipper] was created around a zipper of type `type_name`
+    0 => Created { type_name: String, root_prefix_path: Vec<u8>, path: Vec<u8> },
+    /// The [TraceZipper] was dropped
+    1 => Dropped,
+    /// The value at the focus was modified through a reference returned by an earlier call, such as
+    /// [ZipperWriting::get_val_mut].  `val` is the value once the reference was released
+    2 => ValWritten { val: V },
+
+    //Zipper
+    3 => PathExists,
+    4 => IsVal,
+    5 => ChildCount,
+    6 => ChildMask,
+
+    //ZipperValues, ZipperValuesAt
+    7 => Val,
+    8 => ValAt { path: Vec<u8> },
+
+    //ZipperSubtries
+    9 => NativeSubtries,
+    10 => TryMakeMap,
+    11 => TrieRef,
+
+    //ZipperMoving
+    12 => Depth,
+    13 => AtRoot,
+    14 => FocusByte,
+    15 => Reset,
+    16 => ValCount,
+    17 => DescendTo { path: Vec<u8> },
+    18 => DescendToCheck { path: Vec<u8> },
+    19 => DescendToExisting { path: Vec<u8> },
+    20 => DescendToVal { path: Vec<u8> },
+    21 => DescendToByte { byte: u8 },
+    22 => DescendToExistingByte { byte: u8 },
+    23 => DescendIndexedByte { idx: usize },
+    24 => DescendFirstByte,
+    25 => DescendLastByte,
+    26 => DescendUntil,
+    27 => DescendUntilMaxBytes { max_bytes: usize },
+    28 => Ascend { steps: usize },
+    29 => AscendByte,
+    30 => AscendUntil,
+    31 => AscendUntilBranch,
+    32 => ToNextSiblingByte,
+    33 => ToPrevSiblingByte,
+    34 => ToNextStep,
+
+    //ZipperIteration
+    35 => ToNextVal,
+    36 => DescendLastPath,
+    37 => DescendFirstKPath { k: usize },
+    38 => ToNextKPath { k: usize },
+
+    //ZipperPath, ZipperAbsolutePath
+    39 => Path,
+    40 => MoveToPath { path: Vec<u8> },
+    41 => OriginPath,
+    42 => RootPrefixPath,
+
+    //ZipperReadOnlyValues, ZipperReadOnlyIteration, and their conditional (witness) forms
+    43 => GetVal,
+    44 => GetValAt { path: Vec<u8> },
+    45 => ToNextGetVal,
+
+    //ZipperInfallibleSubtries
+    46 => MakeMap,
+    47 => GetTrieRef,
+
+    //ZipperProduct
+    48 => FocusFactor,
+    49 => FactorCount,
+    50 => PathIndices,
+
+    //ZipperWriting
+    51 => GetValMut,
+    52 => GetValOrSetMut { default: V },
+    53 => GetValOrSetMutWith,
+    54 => SetVal { val: V },
+    55 => SetValAt { path: Vec<u8>, val: V },
+    56 => RemoveVal { prune: bool },
+    57 => ZipperHead,
+    58 => Graft { src: TraceSrc<V> },
+    59 => GraftSrcAt { src: TraceSrc<V>, path: Vec<u8> },
+    /// `map` holds the map's `(path, value)` pairs, as in [TraceSrc::Unknown]
+    60 => GraftMap { map: Vec<(Vec<u8>, V)> },
+    61 => GraftChildMaps { child_mask: ByteMask, maps: Vec<Vec<(Vec<u8>, V)>>, remove_unset: bool },
+    62 => GraftMaskedBranches { src: TraceSrc<V>, child_mask: ByteMask, remove_unset: bool },
+    63 => JoinInto { src: TraceSrc<V> },
+    64 => JoinMapInto { map: Vec<(Vec<u8>, V)> },
+    65 => JoinIntoTake { src: TraceSrc<V>, prune: bool },
+    66 => JoinKPathInto { byte_cnt: usize, prune: bool },
+    67 => MeetKPathInto { byte_cnt: usize, prune: bool },
+    68 => InsertPrefix { prefix: Vec<u8> },
+    69 => RemovePrefix { n: usize },
+    70 => MeetInto { src: TraceSrc<V>, prune: bool },
+    71 => Meet2 { src_a: TraceSrc<V>, src_b: TraceSrc<V> },
+    72 => SubtractInto { src: TraceSrc<V>, prune: bool },
+    73 => Restrict { src: TraceSrc<V> },
+    74 => Restricting { src: TraceSrc<V> },
+    75 => TakeMap { prune: bool },
+    76 => RemoveBranches { prune: bool },
+    77 => RemoveSubtrie { prune: bool },
+    78 => RemoveUnmaskedBranches { mask: ByteMask, prune: bool },
+    79 => CreatePath,
+    80 => PrunePath,
+    81 => PruneAscend,
+}
+
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+// Trace sink
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+
+struct TraceSink {
+    out: Box<dyn Write + Send>,
+    val_type: TypeId,
+    val_type_name: &'static str,
+    /// The `seq` of the next event
+    next_seq: u64,
+}
+
+static SINK: Mutex<Option<TraceSink>> = Mutex::new(None);
+
+thread_local! {
+    /// Set while a traced call is running on this thread
+    static IN_TRACED_OP: Cell<bool> = const { Cell::new(false) };
+    /// `Some` while an argument is being probed (see [probe_trace_id]).  A probed `TraceZipper` fills in its id
+    static PROBE: Cell<Option<Option<u64>>> = const { Cell::new(None) };
+}
+
+fn lock_sink() -> MutexGuard<'static, Option<TraceSink>> {
+    //A panic while holding the lock leaves the sink usable, and the trace is most valuable after a panic
+    SINK.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+/// Starts a new trace, writing to `out`.  Every [TraceZipper] must use `V` as its value type
+///
+/// Panics if a trace is already open
+pub fn open<V: TraceValue>(mut out: impl Write + Send + 'static) -> io::Result<()> {
+    let mut sink = lock_sink();
+    assert!(sink.is_none(), "zipper_tracing: a trace is already open");
+    let mut header = TRACE_MAGIC.to_vec();
+    TRACE_VERSION.encode(&mut header);
+    type_name::<V>().to_string().encode(&mut header);
+    out.write_all(&header)?;
+    *sink = Some(TraceSink { out: Box::new(out), val_type: TypeId::of::<V>(), val_type_name: type_name::<V>(), next_seq: 0 });
+    Ok(())
+}
+
+/// Starts a new trace, writing to a newly created file at `path`.  See [open]
+pub fn open_file<V: TraceValue, P: AsRef<Path>>(path: P) -> io::Result<()> {
+    open::<V>(BufWriter::new(File::create(path)?))
+}
+
+/// Flushes and closes the trace.  Calls on [TraceZipper]s that are still alive afterwards are not recorded
+pub fn close() -> io::Result<()> {
+    match lock_sink().take() {
+        Some(mut sink) => sink.out.flush(),
+        None => Ok(())
+    }
+}
+
+fn is_open() -> bool {
+    lock_sink().is_some()
+}
+
+/// Writes one event to the trace, if a trace is open.  `typed` events may contain `W` values, so
+/// `W` must match the trace's value type
+fn write_event<W: TraceValue>(id: u64, op: &TraceOp<W>, typed: bool) {
+    let mut body = Vec::new();
+    id.encode(&mut body);
+    op.encode(&mut body);
+    let mut sink = lock_sink();
+    if let Some(sink) = sink.as_mut() {
+        if typed {
+            assert!(sink.val_type == TypeId::of::<W>(), "zipper_tracing: trace was opened for values of type {}, but a TraceZipper has values of type {}", sink.val_type_name, type_name::<W>());
+        }
+        //The seq is assigned under the lock, so it orders events from all threads
+        let mut buf = Vec::with_capacity(body.len() + 2);
+        sink.next_seq.encode(&mut buf);
+        sink.next_seq += 1;
+        buf.extend_from_slice(&body);
+        if let Err(err) = sink.out.write_all(&buf) {
+            //Avoid a double-panic (and abort) when this is a drop during unwinding
+            if !std::thread::panicking() {
+                panic!("zipper_tracing: failed to write trace: {err}");
+            }
+        }
+    }
+}
+
+fn flush_sink() {
+    if let Some(sink) = lock_sink().as_mut() {
+        let _ = sink.out.flush();
+    }
+}
+
+/// Decodes a complete trace into `(seq, zipper_id, op)` events
+pub fn decode_trace<V: TraceValue>(mut bytes: &[u8]) -> io::Result<Vec<(u64, u64, TraceOp<V>)>> {
+    let invalid = |msg: &str| io::Error::new(io::ErrorKind::InvalidData, format!("zipper_tracing: {msg}"));
+    let input = &mut bytes;
+    let (magic, rest) = input.split_first_chunk::<8>().ok_or_else(|| invalid("truncated header"))?;
+    if magic != TRACE_MAGIC {
+        return Err(invalid("not a zipper trace"))
+    }
+    *input = rest;
+    if u64::decode(input) != Some(TRACE_VERSION) {
+        return Err(invalid("unsupported trace version"))
+    }
+    let val_type_name = String::decode(input).ok_or_else(|| invalid("truncated header"))?;
+    if val_type_name != type_name::<V>() {
+        return Err(invalid(&format!("trace has values of type {val_type_name}, not {}", type_name::<V>())))
+    }
+    let mut events = Vec::new();
+    while !input.is_empty() {
+        let seq = u64::decode(input).ok_or_else(|| invalid("truncated event"))?;
+        let id = u64::decode(input).ok_or_else(|| invalid("truncated event"))?;
+        let op = TraceOp::decode(input).ok_or_else(|| invalid("invalid or truncated op"))?;
+        events.push((seq, id, op));
+    }
+    Ok(events)
+}
+
+/// Marks this thread as being inside a traced call, until dropped
+struct InOpGuard;
+
+impl InOpGuard {
+    /// Returns `None` if the thread is already inside a traced call
+    fn enter() -> Option<Self> {
+        IN_TRACED_OP.with(|in_op| {
+            if in_op.get() {
+                None
+            } else {
+                in_op.set(true);
+                Some(InOpGuard)
+            }
+        })
+    }
+}
+
+impl Drop for InOpGuard {
+    fn drop(&mut self) {
+        IN_TRACED_OP.with(|in_op| in_op.set(false))
+    }
+}
+
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+// TraceZipper
+// ***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---***---
+
+/// A [Zipper] type that wraps another zipper and records every call made on it into the trace.  See
+/// the [module documentation](self)
+pub struct TraceZipper<Z> {
+    z: Z,
+    id: u64,
+    /// Set when a `&mut V` was handed out, so the value can be recorded once the reference is released
+    val_mut_ref_outstanding: AtomicBool,
+    /// Records the value at the focus.  Set alongside `val_mut_ref_outstanding`, from a context that knows `V`
+    write_back: Option<fn(&Z, u64)>,
+}
+
+impl<Z: ZipperAbsolutePath> TraceZipper<Z> {
+    /// Wraps `z`, so calls on it will be recorded as coming from zipper `id`
+    ///
+    /// Panics if no trace is open
+    pub fn new(id: u64, z: Z) -> Self {
+        assert!(is_open(), "zipper_tracing: open must be called before creating a TraceZipper");
+        if let Some(_guard) = InOpGuard::enter() {
+            let op = TraceOp::<()>::Created {
+                type_name: type_name::<Z>().to_string(),
+                root_prefix_path: z.root_prefix_path().to_vec(),
+                path: z.path().to_vec(),
+            };
+            write_event(id, &op, false);
+        }
+        Self { z, id, val_mut_ref_outstanding: AtomicBool::new(false), write_back: None }
+    }
+}
+
+impl<Z> TraceZipper<Z> {
+    /// Returns the id that identifies this zipper in the trace
+    pub fn id(&self) -> u64 {
+        self.id
+    }
+
+    /// Records an op that contains no values.  The returned guard must be held for the duration of the call
+    #[inline]
+    fn begin(&self, op: impl FnOnce() -> TraceOp<()>) -> Option<InOpGuard> {
+        self.begin_inner(op, false)
+    }
+
+    /// Records an op that may contain values of type `V`
+    #[inline]
+    fn begin_v<V: TraceValue>(&self, op: impl FnOnce() -> TraceOp<V>) -> Option<InOpGuard> {
+        self.begin_inner(op, true)
+    }
+
+    fn begin_inner<W: TraceValue>(&self, op: impl FnOnce() -> TraceOp<W>, typed: bool) -> Option<InOpGuard> {
+        //The guard is entered before building the op, so calls made on other zippers to capture
+        // arguments aren't recorded
+        let guard = InOpGuard::enter()?;
+        self.flush_val_write();
+        write_event(self.id, &op(), typed);
+        Some(guard)
+    }
+
+    fn flush_val_write(&self) {
+        if self.val_mut_ref_outstanding.swap(false, Ordering::Relaxed) {
+            if let Some(write_back) = self.write_back {
+                write_back(&self.z, self.id);
+            }
+        }
+    }
+
+    /// Answers a probe with this zipper's id, if a probe is active.  Returns `true` if it answered
+    fn answer_probe(&self) -> bool {
+        PROBE.with(|probe| {
+            if probe.get() == Some(None) {
+                //This zipper is about to be read as another op's argument, so its value needs to be current in the trace
+                self.flush_val_write();
+                probe.set(Some(Some(self.id)));
+                true
+            } else {
+                false
+            }
+        })
+    }
+
+    /// Call after recording an op that hands out a `&mut V` to the value at the focus
+    fn arm_write_back<V: TraceValue + Clone>(&mut self) where Z: ZipperValues<V> {
+        self.write_back = Some(write_back_val::<V, Z>);
+        self.val_mut_ref_outstanding.store(true, Ordering::Relaxed);
+    }
+}
+
+fn write_back_val<V: TraceValue + Clone, Z: ZipperValues<V>>(z: &Z, id: u64) {
+    if let Some(val) = z.val() {
+        write_event(id, &TraceOp::ValWritten { val: val.clone() }, true);
+    }
+}
+
+impl<Z> Drop for TraceZipper<Z> {
+    fn drop(&mut self) {
+        if let Some(_guard) = InOpGuard::enter() {
+            self.flush_val_write();
+            write_event(self.id, &TraceOp::<()>::Dropped, false);
+            flush_sink();
+        }
+    }
+}
+
+fn map_entries<V: Clone + Send + Sync + Unpin, A: Allocator>(map: &PathMap<V, A>) -> Vec<(Vec<u8>, V)> {
+    map.iter().map(|(path, val)| (path, val.clone())).collect()
+}
+
+/// Returns the id of `src` if it's a [TraceZipper] (or forwards `path_exists` to one).  See the module documentation
+fn probe_trace_id<Z: Zipper>(src: &Z) -> Option<u64> {
+    struct ProbeGuard;
+    impl Drop for ProbeGuard {
+        fn drop(&mut self) {
+            PROBE.with(|probe| probe.set(None))
+        }
+    }
+    PROBE.with(|probe| probe.set(Some(None)));
+    let _guard = ProbeGuard;
+    src.path_exists();
+    PROBE.with(|probe| probe.get()).flatten()
+}
+
+fn trace_src<V: Clone + Send + Sync + Unpin, A: Allocator, S: ZipperInfallibleSubtries<V, A>>(src: &S) -> TraceSrc<V> {
+    match probe_trace_id(src) {
+        Some(id) => TraceSrc::Traced(id),
+        None => TraceSrc::Unknown(map_entries(&src.make_map())),
+    }
+}
+
+impl<Z: Zipper> Zipper for TraceZipper<Z> {
+    fn path_exists(&self) -> bool {
+        if self.answer_probe() {
+            return false
+        }
+        let _g = self.begin(|| TraceOp::PathExists);
+        self.z.path_exists()
+    }
+    fn is_val(&self) -> bool { let _g = self.begin(|| TraceOp::IsVal); self.z.is_val() }
+    fn child_count(&self) -> usize { let _g = self.begin(|| TraceOp::ChildCount); self.z.child_count() }
+    fn child_mask(&self) -> ByteMask { let _g = self.begin(|| TraceOp::ChildMask); self.z.child_mask() }
+}
+
+impl<V, Z: ZipperValues<V>> ZipperValues<V> for TraceZipper<Z> {
+    fn val(&self) -> Option<&V> { let _g = self.begin(|| TraceOp::Val); self.z.val() }
+}
+
+impl<V, Z: ZipperValuesAt<V>> ZipperValuesAt<V> for TraceZipper<Z> {
+    fn val_at<K: AsRef<[u8]>>(&self, path: K) -> Option<&V> {
+        let path = path.as_ref();
+        let _g = self.begin(|| TraceOp::ValAt { path: path.to_vec() });
+        self.z.val_at(path)
+    }
+}
+
+impl<V: Clone + Send + Sync, A: Allocator, Z: ZipperSubtries<V, A>> ZipperSubtries<V, A> for TraceZipper<Z> {
+    fn native_subtries(&self) -> bool { let _g = self.begin(|| TraceOp::NativeSubtries); self.z.native_subtries() }
+    fn try_make_map(&self) -> Option<PathMap<V, A>> { let _g = self.begin(|| TraceOp::TryMakeMap); self.z.try_make_map() }
+    fn trie_ref(&self) -> Option<TrieRef<'_, V, A>> { let _g = self.begin(|| TraceOp::TrieRef); self.z.trie_ref() }
+    fn alloc(&self) -> A { self.z.alloc() }
+}
+
+impl<Z: ZipperMoving> ZipperMoving for TraceZipper<Z> {
+    fn depth(&self) -> usize { let _g = self.begin(|| TraceOp::Depth); self.z.depth() }
+    fn at_root(&self) -> bool { let _g = self.begin(|| TraceOp::AtRoot); self.z.at_root() }
+    fn focus_byte(&self) -> Option<u8> { let _g = self.begin(|| TraceOp::FocusByte); self.z.focus_byte() }
+    fn reset(&mut self) { let _g = self.begin(|| TraceOp::Reset); self.z.reset() }
+    fn val_count(&self) -> usize { let _g = self.begin(|| TraceOp::ValCount); self.z.val_count() }
+    fn descend_to<K: AsRef<[u8]>>(&mut self, k: K) {
+        let k = k.as_ref();
+        let _g = self.begin(|| TraceOp::DescendTo { path: k.to_vec() });
+        self.z.descend_to(k)
+    }
+    fn descend_to_check<K: AsRef<[u8]>>(&mut self, k: K) -> bool {
+        let k = k.as_ref();
+        let _g = self.begin(|| TraceOp::DescendToCheck { path: k.to_vec() });
+        self.z.descend_to_check(k)
+    }
+    fn descend_to_existing<K: AsRef<[u8]>>(&mut self, k: K) -> usize {
+        let k = k.as_ref();
+        let _g = self.begin(|| TraceOp::DescendToExisting { path: k.to_vec() });
+        self.z.descend_to_existing(k)
+    }
+    fn descend_to_val<K: AsRef<[u8]>>(&mut self, k: K) -> usize {
+        let k = k.as_ref();
+        let _g = self.begin(|| TraceOp::DescendToVal { path: k.to_vec() });
+        self.z.descend_to_val(k)
+    }
+    fn descend_to_byte(&mut self, k: u8) { let _g = self.begin(|| TraceOp::DescendToByte { byte: k }); self.z.descend_to_byte(k) }
+    fn descend_to_existing_byte(&mut self, k: u8) -> bool { let _g = self.begin(|| TraceOp::DescendToExistingByte { byte: k }); self.z.descend_to_existing_byte(k) }
+    fn descend_indexed_byte(&mut self, idx: usize) -> Option<u8> { let _g = self.begin(|| TraceOp::DescendIndexedByte { idx }); self.z.descend_indexed_byte(idx) }
+    fn descend_first_byte(&mut self) -> Option<u8> { let _g = self.begin(|| TraceOp::DescendFirstByte); self.z.descend_first_byte() }
+    fn descend_last_byte(&mut self) -> Option<u8> { let _g = self.begin(|| TraceOp::DescendLastByte); self.z.descend_last_byte() }
+    fn descend_until(&mut self) -> bool { let _g = self.begin(|| TraceOp::DescendUntil); self.z.descend_until() }
+    fn descend_until_observed<Obs: PathObserver>(&mut self, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::DescendUntil); self.z.descend_until_observed(obs) }
+    fn descend_until_max_bytes(&mut self, max_bytes: usize) -> bool { let _g = self.begin(|| TraceOp::DescendUntilMaxBytes { max_bytes }); self.z.descend_until_max_bytes(max_bytes) }
+    fn descend_until_max_bytes_observed<Obs: PathObserver>(&mut self, max_bytes: usize, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::DescendUntilMaxBytes { max_bytes }); self.z.descend_until_max_bytes_observed(max_bytes, obs) }
+    fn ascend(&mut self, steps: usize) -> usize { let _g = self.begin(|| TraceOp::Ascend { steps }); self.z.ascend(steps) }
+    fn ascend_byte(&mut self) -> bool { let _g = self.begin(|| TraceOp::AscendByte); self.z.ascend_byte() }
+    fn ascend_until(&mut self) -> usize { let _g = self.begin(|| TraceOp::AscendUntil); self.z.ascend_until() }
+    fn ascend_until_branch(&mut self) -> usize { let _g = self.begin(|| TraceOp::AscendUntilBranch); self.z.ascend_until_branch() }
+    fn to_next_sibling_byte(&mut self) -> Option<u8> { let _g = self.begin(|| TraceOp::ToNextSiblingByte); self.z.to_next_sibling_byte() }
+    fn to_prev_sibling_byte(&mut self) -> Option<u8> { let _g = self.begin(|| TraceOp::ToPrevSiblingByte); self.z.to_prev_sibling_byte() }
+    fn to_next_step(&mut self) -> bool { let _g = self.begin(|| TraceOp::ToNextStep); self.z.to_next_step() }
+    fn to_next_step_observed<Obs: PathObserver>(&mut self, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::ToNextStep); self.z.to_next_step_observed(obs) }
+}
+
+impl<Z: ZipperIteration> ZipperIteration for TraceZipper<Z> {
+    fn to_next_val(&mut self) -> bool { let _g = self.begin(|| TraceOp::ToNextVal); self.z.to_next_val() }
+    fn to_next_val_observed<Obs: PathObserver>(&mut self, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::ToNextVal); self.z.to_next_val_observed(obs) }
+    fn descend_last_path(&mut self) -> bool { let _g = self.begin(|| TraceOp::DescendLastPath); self.z.descend_last_path() }
+    fn descend_last_path_observed<Obs: PathObserver>(&mut self, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::DescendLastPath); self.z.descend_last_path_observed(obs) }
+    fn descend_first_k_path(&mut self, k: usize) -> bool { let _g = self.begin(|| TraceOp::DescendFirstKPath { k }); self.z.descend_first_k_path(k) }
+    fn descend_first_k_path_observed<Obs: PathObserver>(&mut self, k: usize, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::DescendFirstKPath { k }); self.z.descend_first_k_path_observed(k, obs) }
+    fn to_next_k_path(&mut self, k: usize) -> bool { let _g = self.begin(|| TraceOp::ToNextKPath { k }); self.z.to_next_k_path(k) }
+    fn to_next_k_path_observed<Obs: PathObserver>(&mut self, k: usize, obs: &mut Obs) -> bool { let _g = self.begin(|| TraceOp::ToNextKPath { k }); self.z.to_next_k_path_observed(k, obs) }
+}
+
+impl<Z: ZipperPath> ZipperPath for TraceZipper<Z> {
+    fn path(&self) -> &[u8] { let _g = self.begin(|| TraceOp::Path); self.z.path() }
+    fn move_to_path<K: AsRef<[u8]>>(&mut self, path: K) -> usize {
+        let path = path.as_ref();
+        let _g = self.begin(|| TraceOp::MoveToPath { path: path.to_vec() });
+        self.z.move_to_path(path)
+    }
+}
+
+impl<Z: ZipperAbsolutePath> ZipperAbsolutePath for TraceZipper<Z> {
+    fn origin_path(&self) -> &[u8] { let _g = self.begin(|| TraceOp::OriginPath); self.z.origin_path() }
+    fn root_prefix_path(&self) -> &[u8] { let _g = self.begin(|| TraceOp::RootPrefixPath); self.z.root_prefix_path() }
+}
+
+impl<Z: ZipperPathBuffer> ZipperPathBuffer for TraceZipper<Z> {
+    unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
+    fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
+    fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
+}
+
+impl<Z: ZipperConcrete> ZipperConcrete for TraceZipper<Z> {
+    fn shared_node_id(&self) -> Option<u64> { self.z.shared_node_id() }
+    fn is_shared(&self) -> bool { self.z.is_shared() }
+}
+
+impl<'a, V, Z> ZipperReadOnlyValues<'a, V> for TraceZipper<Z> where Z: ZipperReadOnlyValues<'a, V> {
+    fn get_val(&self) -> Option<&'a V> { let _g = self.begin(|| TraceOp::GetVal); self.z.get_val() }
+    fn get_val_at<K: AsRef<[u8]>>(&self, path: K) -> Option<&'a V> {
+        let path = path.as_ref();
+        let _g = self.begin(|| TraceOp::GetValAt { path: path.to_vec() });
+        self.z.get_val_at(path)
+    }
+}
+
+impl<'a, V, Z> ZipperReadOnlyConditionalValues<'a, V> for TraceZipper<Z> where Z: ZipperReadOnlyConditionalValues<'a, V> {
+    type WitnessT = Z::WitnessT;
+    fn witness<'w>(&self) -> Self::WitnessT { self.z.witness() }
+    fn get_val_with_witness<'w>(&self, witness: &'w Self::WitnessT) -> Option<&'w V> where 'a: 'w {
+        let _g = self.begin(|| TraceOp::GetVal);
+        self.z.get_val_with_witness(witness)
+    }
+}
+
+impl<'a, V, Z> ZipperReadOnlyIteration<'a, V> for TraceZipper<Z> where Z: ZipperReadOnlyIteration<'a, V> {
+    fn to_next_get_val(&mut self) -> Option<&'a V> { let _g = self.begin(|| TraceOp::ToNextGetVal); self.z.to_next_get_val() }
+    fn to_next_get_val_observed<Obs: PathObserver>(&mut self, obs: &mut Obs) -> Option<&'a V> { let _g = self.begin(|| TraceOp::ToNextGetVal); self.z.to_next_get_val_observed(obs) }
+}
+
+impl<'a, V, Z> ZipperReadOnlyConditionalIteration<'a, V> for TraceZipper<Z> where Z: ZipperReadOnlyConditionalIteration<'a, V> {
+    fn to_next_get_val_with_witness<'w>(&mut self, witness: &'w Self::WitnessT) -> Option<&'w V> where 'a: 'w {
+        let _g = self.begin(|| TraceOp::ToNextGetVal);
+        self.z.to_next_get_val_with_witness(witness)
+    }
+    fn to_next_get_val_with_witness_observed<'w, Obs: PathObserver>(&mut self, witness: &'w Self::WitnessT, obs: &mut Obs) -> Option<&'w V> where 'a: 'w {
+        let _g = self.begin(|| TraceOp::ToNextGetVal);
+        self.z.to_next_get_val_with_witness_observed(witness, obs)
+    }
+}
+
+impl<V: Clone + Send + Sync, A: Allocator, Z: ZipperInfallibleSubtries<V, A>> ZipperInfallibleSubtries<V, A> for TraceZipper<Z> {
+    fn make_map(&self) -> PathMap<V, A> { let _g = self.begin(|| TraceOp::MakeMap); self.z.make_map() }
+    fn get_trie_ref(&self) -> TrieRef<'_, V, A> { let _g = self.begin(|| TraceOp::GetTrieRef); self.z.get_trie_ref() }
+    fn get_focus(&self) -> OpaqueAbstractNodeRef<'_, V, A> { self.z.get_focus() }
+    fn get_focus_at<K: AsRef<[u8]>>(&self, path: K) -> OpaqueAbstractNodeRef<'_, V, A> { self.z.get_focus_at(path) }
+    fn try_borrow_focus(&self) -> Option<OpaqueTrieNodeRef<'_, V, A>> { self.z.try_borrow_focus() }
+}
+
+impl<'a, V: Clone + Send + Sync + 'a, A: Allocator + 'a, Z> ZipperReadOnlySubtries<'a, V, A> for TraceZipper<Z>
+    where Z: ZipperReadOnlySubtries<'a, V, A>, Self: ZipperReadOnlyPriv<'a, V, A> + ZipperSubtries<V, A>
+{
+    type TrieRefT = <Z as ZipperReadOnlySubtries<'a, V, A>>::TrieRefT;
+    fn trie_ref_at_path<K: AsRef<[u8]>>(&self, path: K) -> Self::TrieRefT { self.z.trie_ref_at_path(path) }
+}
+
+impl<'a, V: Clone + Send + Sync, A: Allocator, Z: ZipperReadOnlyPriv<'a, V, A>> ZipperReadOnlyPriv<'a, V, A> for TraceZipper<Z> {
+    fn borrow_raw_parts<'z>(&'z self) -> (TaggedNodeRef<'z, V, A>, &'z [u8], Option<&'z V>) { self.z.borrow_raw_parts() }
+    fn take_core(&mut self) -> Option<ReadZipperCore<'a, 'static, V, A>> { self.z.take_core() }
+}
+
+impl<Z: ZipperProduct> ZipperProduct for TraceZipper<Z> {
+    fn factor_count(&self) -> usize { let _g = self.begin(|| TraceOp::FactorCount); self.z.factor_count() }
+    fn focus_factor(&self) -> usize { let _g = self.begin(|| TraceOp::FocusFactor); self.z.focus_factor() }
+    fn path_indices(&self) -> &[usize] { let _g = self.begin(|| TraceOp::PathIndices); self.z.path_indices() }
+}
+
+impl<V: Clone + Send + Sync, A: Allocator, Z: WriteZipperPriv<V, A>> WriteZipperPriv<V, A> for TraceZipper<Z> {
+    fn take_focus(&mut self, prune: bool) -> Option<TrieNodeODRc<V, A>> { self.z.take_focus(prune) }
+    fn take_root_prefix_path(&mut self) -> Vec<u8> { self.z.take_root_prefix_path() }
+    fn alloc(&self) -> A { WriteZipperPriv::alloc(&self.z) }
+}
+
+impl<V, A, Z> ZipperWriting<V, A> for TraceZipper<Z>
+    where V: TraceValue + Clone + Send + Sync + Unpin, A: Allocator, Z: ZipperWriting<V, A> + ZipperValues<V>
+{
+    type ZipperHead<'z> = Z::ZipperHead<'z> where Self: 'z;
+    fn get_val_mut(&mut self) -> Option<&mut V> {
+        let g = self.begin(|| TraceOp::GetValMut);
+        if g.is_some() {
+            self.arm_write_back::<V>();
+        }
+        self.z.get_val_mut()
+    }
+    fn get_val_or_set_mut(&mut self, default: V) -> &mut V {
+        let g = self.begin_v(|| TraceOp::GetValOrSetMut { default: default.clone() });
+        if g.is_some() {
+            self.arm_write_back::<V>();
+        }
+        self.z.get_val_or_set_mut(default)
+    }
+    fn get_val_or_set_mut_with<F>(&mut self, func: F) -> &mut V where F: FnOnce() -> V {
+        let g = self.begin(|| TraceOp::GetValOrSetMutWith);
+        if g.is_some() {
+            self.arm_write_back::<V>();
+        }
+        self.z.get_val_or_set_mut_with(func)
+    }
+    fn set_val(&mut self, val: V) -> Option<V> { let _g = self.begin_v(|| TraceOp::SetVal { val: val.clone() }); self.z.set_val(val) }
+    fn set_val_at<K: AsRef<[u8]>>(&mut self, path: K, val: V) -> Option<V> {
+        let path = path.as_ref();
+        let _g = self.begin_v(|| TraceOp::SetValAt { path: path.to_vec(), val: val.clone() });
+        self.z.set_val_at(path, val)
+    }
+    fn remove_val(&mut self, prune: bool) -> Option<V> { let _g = self.begin(|| TraceOp::RemoveVal { prune }); self.z.remove_val(prune) }
+    fn zipper_head<'z>(&'z mut self) -> Self::ZipperHead<'z> { let _g = self.begin(|| TraceOp::ZipperHead); self.z.zipper_head() }
+    fn graft<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, read_zipper: &RZ) {
+        let _g = self.begin_v(|| TraceOp::Graft { src: trace_src(read_zipper) });
+        self.z.graft(read_zipper)
+    }
+    fn graft_src_at<RZ: ZipperInfallibleSubtries<V, A>, K: AsRef<[u8]>>(&mut self, src: &RZ, path: K) {
+        let path = path.as_ref();
+        let _g = self.begin_v(|| TraceOp::GraftSrcAt { src: trace_src(src), path: path.to_vec() });
+        self.z.graft_src_at(src, path)
+    }
+    fn graft_map(&mut self, map: PathMap<V, A>) {
+        let _g = self.begin_v(|| TraceOp::GraftMap { map: map_entries(&map) });
+        self.z.graft_map(map)
+    }
+    fn graft_child_maps<I: IntoIterator<Item=PathMap<V, A>>>(&mut self, child_mask: ByteMask, maps: I, remove_unset: bool) {
+        let maps: Vec<PathMap<V, A>> = maps.into_iter().collect();
+        let _g = self.begin_v(|| TraceOp::GraftChildMaps { child_mask, maps: maps.iter().map(map_entries).collect(), remove_unset });
+        self.z.graft_child_maps(child_mask, maps, remove_unset)
+    }
+    fn graft_masked_branches<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, src: &RZ, child_mask: ByteMask, remove_unset: bool) {
+        let _g = self.begin_v(|| TraceOp::GraftMaskedBranches { src: trace_src(src), child_mask, remove_unset });
+        self.z.graft_masked_branches(src, child_mask, remove_unset)
+    }
+    fn join_into<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, read_zipper: &RZ) -> AlgebraicStatus where V: Lattice {
+        let _g = self.begin_v(|| TraceOp::JoinInto { src: trace_src(read_zipper) });
+        self.z.join_into(read_zipper)
+    }
+    fn join_map_into(&mut self, map: PathMap<V, A>) -> AlgebraicStatus where V: Lattice {
+        let _g = self.begin_v(|| TraceOp::JoinMapInto { map: map_entries(&map) });
+        self.z.join_map_into(map)
+    }
+    fn join_into_take<RZ: ZipperInfallibleSubtries<V, A> + ZipperWriting<V, A>>(&mut self, src_zipper: &mut RZ, prune: bool) -> AlgebraicStatus where V: Lattice {
+        let _g = self.begin_v(|| TraceOp::JoinIntoTake { src: trace_src(&*src_zipper), prune });
+        self.z.join_into_take(src_zipper, prune)
+    }
+    fn join_k_path_into(&mut self, byte_cnt: usize, prune: bool) -> bool where V: Lattice {
+        let _g = self.begin(|| TraceOp::JoinKPathInto { byte_cnt, prune });
+        self.z.join_k_path_into(byte_cnt, prune)
+    }
+    fn meet_k_path_into(&mut self, byte_cnt: usize, prune: bool) -> bool where V: Lattice {
+        let _g = self.begin(|| TraceOp::MeetKPathInto { byte_cnt, prune });
+        self.z.meet_k_path_into(byte_cnt, prune)
+    }
+    fn insert_prefix<K: AsRef<[u8]>>(&mut self, prefix: K) -> bool {
+        let prefix = prefix.as_ref();
+        let _g = self.begin(|| TraceOp::InsertPrefix { prefix: prefix.to_vec() });
+        self.z.insert_prefix(prefix)
+    }
+    fn remove_prefix(&mut self, n: usize) -> bool { let _g = self.begin(|| TraceOp::RemovePrefix { n }); self.z.remove_prefix(n) }
+    fn meet_into<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, read_zipper: &RZ, prune: bool) -> AlgebraicStatus where V: Lattice {
+        let _g = self.begin_v(|| TraceOp::MeetInto { src: trace_src(read_zipper), prune });
+        self.z.meet_into(read_zipper, prune)
+    }
+    fn meet_2<RZA: ZipperInfallibleSubtries<V, A>, RZB: ZipperInfallibleSubtries<V, A>>(&mut self, rz_a: &RZA, rz_b: &RZB) -> AlgebraicStatus where V: Lattice {
+        let _g = self.begin_v(|| TraceOp::Meet2 { src_a: trace_src(rz_a), src_b: trace_src(rz_b) });
+        self.z.meet_2(rz_a, rz_b)
+    }
+    fn subtract_into<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, read_zipper: &RZ, prune: bool) -> AlgebraicStatus where V: DistributiveLattice {
+        let _g = self.begin_v(|| TraceOp::SubtractInto { src: trace_src(read_zipper), prune });
+        self.z.subtract_into(read_zipper, prune)
+    }
+    fn restrict<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, read_zipper: &RZ) -> AlgebraicStatus {
+        let _g = self.begin_v(|| TraceOp::Restrict { src: trace_src(read_zipper) });
+        self.z.restrict(read_zipper)
+    }
+    fn restricting<RZ: ZipperInfallibleSubtries<V, A>>(&mut self, read_zipper: &RZ) -> bool {
+        let _g = self.begin_v(|| TraceOp::Restricting { src: trace_src(read_zipper) });
+        self.z.restricting(read_zipper)
+    }
+    fn take_map(&mut self, prune: bool) -> Option<PathMap<V, A>> { let _g = self.begin(|| TraceOp::TakeMap { prune }); self.z.take_map(prune) }
+    fn remove_branches(&mut self, prune: bool) -> bool { let _g = self.begin(|| TraceOp::RemoveBranches { prune }); self.z.remove_branches(prune) }
+    fn remove_subtrie(&mut self, prune: bool) -> bool { let _g = self.begin(|| TraceOp::RemoveSubtrie { prune }); self.z.remove_subtrie(prune) }
+    fn remove_unmasked_branches(&mut self, mask: ByteMask, prune: bool) {
+        let _g = self.begin(|| TraceOp::RemoveUnmaskedBranches { mask, prune });
+        self.z.remove_unmasked_branches(mask, prune)
+    }
+    fn create_path(&mut self) -> bool { let _g = self.begin(|| TraceOp::CreatePath); self.z.create_path() }
+    fn prune_path(&mut self) -> usize { let _g = self.begin(|| TraceOp::PrunePath); self.z.prune_path() }
+    fn prune_ascend(&mut self) -> usize { let _g = self.begin(|| TraceOp::PruneAscend); self.z.prune_ascend() }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use super::*;
+
+    /// The trace is global, so tests that use it must not overlap
+    static TEST_LOCK: Mutex<()> = Mutex::new(());
+
+    #[derive(Clone, Default)]
+    struct SharedBuf(Arc<Mutex<Vec<u8>>>);
+
+    impl Write for SharedBuf {
+        fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.lock().unwrap().extend_from_slice(buf); Ok(buf.len()) }
+        fn flush(&mut self) -> io::Result<()> { Ok(()) }
+    }
+
+    /// Runs `f` with a trace open, and returns the decoded trace's `(zipper_id, op)` events, after
+    /// checking they're numbered in order
+    fn traced(f: impl FnOnce()) -> Vec<(u64, TraceOp<u64>)> {
+        let _lock = TEST_LOCK.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        let buf = SharedBuf::default();
+        open::<u64>(buf.clone()).unwrap();
+        f();
+        close().unwrap();
+        let bytes = buf.0.lock().unwrap().clone();
+        let events = decode_trace(&bytes).unwrap();
+        for (idx, (seq, _, _)) in events.iter().enumerate() {
+            assert_eq!(*seq, idx as u64);
+        }
+        events.into_iter().map(|(_, id, op)| (id, op)).collect()
+    }
+
+    #[test]
+    fn trace_zipper_moves() {
+        let map: PathMap<u64> = [("apple", 1), ("apricot", 2), ("banana", 3)].into_iter().collect();
+        let events = traced(|| {
+            let mut rz = TraceZipper::new(7, map.read_zipper());
+            rz.descend_to(b"ap");
+            assert!(rz.path_exists());
+            assert_eq!(rz.descend_first_byte(), Some(b'p'));
+            assert_eq!(rz.ascend(2), 2);
+            assert!(rz.to_next_val());
+            assert_eq!(rz.val(), Some(&1));
+        });
+        let ops: Vec<TraceOp<u64>> = events.iter().map(|(id, op)| { assert_eq!(*id, 7); op.clone() }).collect();
+        assert!(matches!(&ops[0], TraceOp::Created { root_prefix_path, path, .. } if root_prefix_path.is_empty() && path.is_empty()));
+        assert_eq!(&ops[1..], &[
+            TraceOp::DescendTo { path: b"ap".to_vec() },
+            TraceOp::PathExists,
+            TraceOp::DescendFirstByte,
+            TraceOp::Ascend { steps: 2 },
+            TraceOp::ToNextVal,
+            TraceOp::Val,
+            TraceOp::Dropped,
+        ]);
+    }
+
+    #[test]
+    fn trace_zipper_writes() {
+        let mut dst: PathMap<u64> = PathMap::new();
+        let src: PathMap<u64> = [("a", 1), ("ab", 2)].into_iter().collect();
+        let events = traced(|| {
+            let mut wz = TraceZipper::new(1, dst.write_zipper());
+            let rz = TraceZipper::new(2, src.read_zipper());
+            wz.descend_to(b"x");
+            *wz.get_val_or_set_mut(5) += 10;
+            wz.descend_to_byte(b'y');
+            //Graft from a traced zipper is recorded by id, and the graft's reads of `rz` aren't recorded
+            wz.graft(&rz);
+            wz.reset();
+            //Graft from an untraced zipper records the source's contents
+            let mut untraced = src.read_zipper();
+            untraced.descend_to(b"a");
+            wz.descend_to(b"z");
+            wz.graft(&untraced);
+            drop(rz);
+        });
+        let expected: Vec<(u64, TraceOp<u64>)> = vec![
+            (1, TraceOp::DescendTo { path: b"x".to_vec() }),
+            (1, TraceOp::GetValOrSetMut { default: 5 }),
+            (1, TraceOp::ValWritten { val: 15 }),
+            (1, TraceOp::DescendToByte { byte: b'y' }),
+            (1, TraceOp::Graft { src: TraceSrc::Traced(2) }),
+            (1, TraceOp::Reset),
+            (1, TraceOp::DescendTo { path: b"z".to_vec() }),
+            (1, TraceOp::Graft { src: TraceSrc::Unknown(vec![(vec![], 1), (b"b".to_vec(), 2)]) }),
+            (2, TraceOp::Dropped),
+            (1, TraceOp::Dropped),
+        ];
+        let events: Vec<_> = events.into_iter().filter(|(_, op)| !matches!(op, TraceOp::Created { .. })).collect();
+        assert_eq!(events, expected);
+        assert_eq!(dst.get(b"x"), Some(&15));
+        assert_eq!(dst.get(b"xyab"), Some(&2));
+        assert_eq!(dst.get(b"zb"), Some(&2));
+    }
+
+    #[test]
+    fn trace_zipper_probe() {
+        let mut dst: PathMap<u64> = PathMap::new();
+        let mut src: PathMap<u64> = PathMap::new();
+        let events = traced(|| {
+            let mut wz = TraceZipper::new(1, dst.write_zipper());
+            let mut src_wz = TraceZipper::new(2, src.write_zipper());
+            src_wz.descend_to(b"s");
+            *src_wz.get_val_or_set_mut(1) = 3;
+            src_wz.reset();
+            *src_wz.get_val_or_set_mut(4) = 5;
+            //The source's pending write is recorded before the graft, and a transparent wrapper reports the inner id
+            wz.graft(&&mut src_wz);
+        });
+        let events: Vec<_> = events.into_iter().filter(|(_, op)| !matches!(op, TraceOp::Created { .. })).collect();
+        assert_eq!(&events[2..], &[
+            (2, TraceOp::ValWritten { val: 3 }),
+            (2, TraceOp::Reset),
+            (2, TraceOp::GetValOrSetMut { default: 4 }),
+            (2, TraceOp::ValWritten { val: 5 }),
+            (1, TraceOp::Graft { src: TraceSrc::Traced(2) }),
+            (2, TraceOp::Dropped),
+            (1, TraceOp::Dropped),
+        ]);
+    }
+
+    #[test]
+    fn trace_round_trip() {
+        let ops: Vec<TraceOp<u64>> = vec![
+            TraceOp::Created { type_name: "Z".to_string(), root_prefix_path: vec![1, 2], path: vec![] },
+            TraceOp::DescendIndexedByte { idx: 300 },
+            TraceOp::GraftChildMaps { child_mask: [b'a', b'z'].into_iter().collect(), maps: vec![vec![(vec![], u64::MAX)], vec![]], remove_unset: true },
+            TraceOp::Meet2 { src_a: TraceSrc::Traced(u64::MAX), src_b: TraceSrc::Unknown(vec![(b"q".to_vec(), 0)]) },
+        ];
+        let mut bytes = Vec::new();
+        for op in &ops {
+            op.encode(&mut bytes);
+        }
+        let mut input = &bytes[..];
+        for op in &ops {
+            assert_eq!(&TraceOp::<u64>::decode(&mut input).unwrap(), op);
+        }
+        assert!(input.is_empty());
+    }
+}
diff --git a/tools/tracer/Cargo.toml b/tools/tracer/Cargo.toml
new file mode 100644
index 00000000..4a0d10e3
--- /dev/null
+++ b/tools/tracer/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "tracer"
+version = "0.1.0"
+edition = "2024"
+publish = false
+description = "Inspects and replays trace files written by pathmap's TraceZipper, rendering them as an animated HTML page"
+
+[dependencies]
+pathmap = { path = "../..", features = ["arena_compact"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
diff --git a/tools/tracer/src/annotations.rs b/tools/tracer/src/annotations.rs
new file mode 100644
index 00000000..374ddae6
--- /dev/null
+++ b/tools/tracer/src/annotations.rs
@@ -0,0 +1,267 @@
+//! Annotations steer the playback of an animation: captions over ranges of events, playback speed, zooming
+//! in on part of a map, labels on subtries, and chapter marks.  They're written as JSON, and refer to events
+//! by their `seq`
+//!
+//! ```json
+//! {
+//!   "start": 0,
+//!   "ranges": [
+//!     { "events": [0, 86], "speed": 4, "caption": "Invert the \"parent\" paths to create the \"child\" subtrie" },
+//!     { "events": 472, "zoom": { "path": "out/aunt/" }, "hold": 4, "caption": "Everyone's aunts" }
+//!   ],
+//!   "labels": [ { "path": "out/aunt/", "text": "aunts" } ],
+//!   "marks": [ { "event": 340, "label": "aunts" } ]
+//! }
+//! ```
+//!
+//! Places in a map, as zoomed on or labeled, are given by `path`, or by `path_hex` for paths that aren't
+//! text.  `map` is the map's index, and may be omitted to mean the first map showing the path.
+//!
+//! When ranges overlap, the later range wins for each setting it specifies.  Any object may also have a
+//! `"comment"`, which is ignored.
+
+use serde::Deserialize;
+use serde_json::{json, Value};
+
+use crate::{Replay, ReplayValue};
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Annotations {
+    /// The event the page opens at.  Defaults to the state before the first event
+    pub start: Option<u64>,
+    #[serde(default)]
+    pub ranges: Vec<RangeNote>,
+    #[serde(default)]
+    pub labels: Vec<Label>,
+    #[serde(default)]
+    pub marks: Vec<Mark>,
+    #[serde(default)]
+    pub comment: Option<String>,
+}
+
+/// A name shown on a subtrie, and around its extent, whenever it's on screen
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Label {
+    pub map: Option<usize>,
+    pub path: Option<String>,
+    pub path_hex: Option<String>,
+    pub text: String,
+    /// Limits the label to a range of events
+    pub events: Option<EventRange>,
+    #[serde(default)]
+    pub comment: Option<String>,
+}
+
+/// Settings for a range of events
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct RangeNote {
+    pub events: EventRange,
+    /// Shown over the animation while playback is in the range
+    pub caption: Option<String>,
+    /// Multiplies the playback speed in the range
+    pub speed: Option<f64>,
+    /// Plays the range as a single transition, from the event before it to its last event
+    #[serde(default)]
+    pub collapse: bool,
+    /// Points the camera at part of a map
+    pub zoom: Option<Zoom>,
+    /// Seconds to pause on each event in the range during playback
+    pub hold: Option<f64>,
+    #[serde(default)]
+    pub comment: Option<String>,
+}
+
+/// An event `seq`, or an inclusive `[first, last]` range of them
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(untagged)]
+pub enum EventRange {
+    One(u64),
+    Span([u64; 2]),
+}
+
+impl EventRange {
+    fn bounds(&self) -> (u64, u64) {
+        match *self {
+            EventRange::One(seq) => (seq, seq),
+            EventRange::Span([first, last]) => (first, last),
+        }
+    }
+}
+
+/// The subtrie at a place in a map
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Zoom {
+    pub map: Option<usize>,
+    pub path: Option<String>,
+    pub path_hex: Option<String>,
+    /// The most the subtrie is magnified, which limits zooming in on a small subtrie.  Defaults to 4
+    pub max_scale: Option<f64>,
+}
+
+/// A named point in the animation, which can be jumped to
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Mark {
+    pub event: u64,
+    pub label: String,
+    #[serde(default)]
+    pub comment: Option<String>,
+}
+
+impl Annotations {
+    pub fn from_json(text: &str) -> Result<Self, String> {
+        serde_json::from_str(text).map_err(|err| format!("annotations: {err}"))
+    }
+}
+
+fn hex(path: &[u8]) -> String {
+    path.iter().map(|byte| format!("{byte:02x}")).collect()
+}
+
+fn decode_hex(text: &str) -> Option<Vec<u8>> {
+    if text.len() % 2 != 0 {
+        return None
+    }
+    (0..text.len()).step_by(2).map(|idx| u8::from_str_radix(text.get(idx..idx + 2)?, 16).ok()).collect()
+}
+
+/// Finds the place named by `map`, `path`, and `path_hex`, which must be on screen in some frame of `frames`
+fn resolve_place<V: ReplayValue>(replay: &Replay<V>, frames: (usize, usize), map: Option<usize>, path: &Option<String>, path_hex: &Option<String>, what: &str) -> Result<(usize, Vec<u8>), String> {
+    let path = match (path, path_hex) {
+        (Some(path), None) => path.as_bytes().to_vec(),
+        (None, Some(path_hex)) => decode_hex(path_hex).ok_or_else(|| format!("annotations: {what} has an invalid path_hex"))?,
+        _ => return Err(format!("annotations: {what} needs exactly one of path or path_hex")),
+    };
+    let shown_on = |map: usize| replay.frames[frames.0..=frames.1].iter().any(|frame| {
+        frame.maps.iter().any(|view| view.map == map && view.nodes.contains_key(&path))
+    });
+    let map = match map {
+        Some(map) if map < replay.map_labels.len() => map,
+        Some(map) => return Err(format!("annotations: {what} refers to map {map}, but there are only {} maps", replay.map_labels.len())),
+        None => (0..replay.map_labels.len()).find(|&map| shown_on(map))
+            .ok_or_else(|| format!("annotations: {what} refers to {}, which isn't shown during its events", crate::quote_path(&path)))?,
+    };
+    if !shown_on(map) {
+        return Err(format!("annotations: {what} refers to {} in map {map}, which isn't shown during its events", crate::quote_path(&path)))
+    }
+    Ok((map, path))
+}
+
+/// Checks the annotations against a replay, and converts them to the form the page uses, where events are
+/// replaced by frame indices
+pub(crate) fn resolve<V: ReplayValue>(ann: &Annotations, replay: &Replay<V>) -> Result<Value, String> {
+    let frame_of = |seq: u64| replay.frames.iter().position(|frame| frame.event == Some(seq));
+    let find = |seq: u64, what: &str| frame_of(seq).ok_or_else(|| format!("annotations: {what} refers to event {seq}, which isn't in the trace"));
+    let find_range = |events: &EventRange, what: &str| -> Result<(usize, usize), String> {
+        let (first, last) = events.bounds();
+        if first > last {
+            return Err(format!("annotations: {what} begins at event {first}, after it ends at {last}"))
+        }
+        Ok((find(first, what)?, find(last, what)?))
+    };
+
+    let start = match ann.start {
+        Some(seq) => find(seq, "start")?,
+        None => 0,
+    };
+    let mut ranges = Vec::new();
+    for (idx, range) in ann.ranges.iter().enumerate() {
+        let what = format!("ranges[{idx}]");
+        let (from, to) = find_range(&range.events, &what)?;
+        if let Some(speed) = range.speed {
+            if !(speed > 0.0) {
+                return Err(format!("annotations: {what} has speed {speed}, which isn't positive"))
+            }
+        }
+        if let Some(hold) = range.hold {
+            if !(hold >= 0.0) {
+                return Err(format!("annotations: {what} has hold {hold}, which is negative"))
+            }
+        }
+        let zoom = match &range.zoom {
+            None => Value::Null,
+            Some(zoom) => {
+                let (map, path) = resolve_place(replay, (from, to), zoom.map, &zoom.path, &zoom.path_hex, &format!("{what}'s zoom"))?;
+                if let Some(max_scale) = zoom.max_scale {
+                    if !(max_scale > 0.0) {
+                        return Err(format!("annotations: {what}'s zoom has max_scale {max_scale}, which isn't positive"))
+                    }
+                }
+                json!({ "map": map, "path": hex(&path), "max_scale": zoom.max_scale })
+            }
+        };
+        ranges.push(json!({
+            "from": from,
+            "to": to,
+            "caption": range.caption,
+            "speed": range.speed,
+            "collapse": range.collapse,
+            "hold": range.hold,
+            "zoom": zoom,
+        }));
+    }
+    let mut labels = Vec::new();
+    for (idx, label) in ann.labels.iter().enumerate() {
+        let what = format!("labels[{idx}]");
+        let (from, to) = match &label.events {
+            Some(events) => find_range(events, &what)?,
+            None => (0, replay.frames.len() - 1),
+        };
+        let (map, path) = resolve_place(replay, (from, to), label.map, &label.path, &label.path_hex, &what)?;
+        labels.push(json!({ "from": from, "to": to, "map": map, "path": hex(&path), "text": label.text }));
+    }
+    let mut marks = Vec::new();
+    for (idx, mark) in ann.marks.iter().enumerate() {
+        marks.push(json!({ "frame": find(mark.event, &format!("marks[{idx}]"))?, "label": mark.label }));
+    }
+    Ok(json!({ "start": start, "ranges": ranges, "labels": labels, "marks": marks }))
+}
+
+#[cfg(test)]
+mod tests {
+    use pathmap::utils::debug::zipper_tracing::TraceOp;
+
+    use super::*;
+    use crate::{replay, ReplayConfig};
+
+    fn small_replay() -> Replay<u64> {
+        let events = vec![
+            (10, 1, TraceOp::Created { type_name: "Z".to_string(), root_prefix_path: b"ab/".to_vec(), path: vec![] }),
+            (11, 1, TraceOp::SetValAt { path: b"cd".to_vec(), val: 1 }),
+            (12, 1, TraceOp::Dropped),
+        ];
+        replay(&events, vec![], &ReplayConfig::default())
+    }
+
+    fn check(json: &str) -> Result<Value, String> {
+        resolve(&Annotations::from_json(json)?, &small_replay())
+    }
+
+    #[test]
+    fn events_become_frames() {
+        let resolved = check(r#"{ "start": 11, "ranges": [{ "events": [10, 12], "speed": 2, "zoom": { "path": "ab/c" } }], "labels": [{ "path": "ab/", "text": "ab" }], "marks": [{ "event": 12, "label": "end" }] }"#).unwrap();
+        assert_eq!(resolved["labels"][0], json!({ "from": 0, "to": 3, "map": 0, "path": "61622f", "text": "ab" }));
+        //Frame 0 is the state before the first event
+        assert_eq!(resolved["start"], 2);
+        assert_eq!(resolved["ranges"][0]["from"], 1);
+        assert_eq!(resolved["ranges"][0]["to"], 3);
+        assert_eq!(resolved["ranges"][0]["zoom"], json!({ "map": 0, "path": "61622f63", "max_scale": null }));
+        assert_eq!(resolved["marks"][0]["frame"], 3);
+    }
+
+    #[test]
+    fn invalid_annotations() {
+        assert!(check(r#"{ "start": 9 }"#).unwrap_err().contains("event 9"));
+        assert!(check(r#"{ "ranges": [{ "events": [12, 10] }] }"#).unwrap_err().contains("after it ends"));
+        assert!(check(r#"{ "ranges": [{ "events": 11, "speed": 0 }] }"#).unwrap_err().contains("isn't positive"));
+        assert!(check(r#"{ "ranges": [{ "events": 11, "zoom": { "path": "zz" } }] }"#).unwrap_err().contains("isn't shown"));
+        assert!(check(r#"{ "ranges": [{ "events": 11, "zoom": { "map": 3, "path": "ab" } }] }"#).unwrap_err().contains("only 1 maps"));
+        assert!(check(r#"{ "labels": [{ "path": "ab/cd", "text": "x", "events": 10 }] }"#).unwrap_err().contains("isn't shown"));
+        //Misspelled settings are caught rather than ignored
+        assert!(check(r#"{ "ranges": [{ "events": 11, "sped": 2 }] }"#).unwrap_err().contains("unknown field"));
+    }
+}
diff --git a/tools/tracer/src/html.rs b/tools/tracer/src/html.rs
new file mode 100644
index 00000000..17b1a851
--- /dev/null
+++ b/tools/tracer/src/html.rs
@@ -0,0 +1,114 @@
+//! Renders a [Replay] as a self-contained HTML page
+
+use std::fmt::Write;
+
+use crate::{Annotations, Replay, ReplayValue};
+
+const TEMPLATE: &str = include_str!("player.html");
+
+/// Appends `s` as a JSON string.  `<` is escaped too, so the JSON can't end the enclosing `<script>`
+fn push_json_str(out: &mut String, s: &str) {
+    out.push('"');
+    for c in s.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '<' => out.push_str("\\u003c"),
+            c if (c as u32) < 0x20 => { let _ = write!(out, "\\u{:04x}", c as u32); },
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+}
+
+fn push_hex(out: &mut String, path: &[u8]) {
+    out.push('"');
+    for byte in path {
+        let _ = write!(out, "{byte:02x}");
+    }
+    out.push('"');
+}
+
+fn push_list<T>(out: &mut String, items: impl IntoIterator<Item = T>, mut push_item: impl FnMut(&mut String, T)) {
+    out.push('[');
+    for (idx, item) in items.into_iter().enumerate() {
+        if idx > 0 {
+            out.push(',');
+        }
+        push_item(out, item);
+    }
+    out.push(']');
+}
+
+/// The frames as JSON.  Paths are hex strings.  Each frame has its event's seq as `e`, each node is
+/// `[path, exists, accessible, val, hidden]`, and each zipper is `[id, root, focus, writer]`
+fn frames_json<V: ReplayValue>(replay: &Replay<V>, title: &str, ann: &str) -> String {
+    let mut out = String::from("{\"title\":");
+    push_json_str(&mut out, title);
+    out.push_str(",\"maps\":");
+    push_list(&mut out, &replay.map_labels, |out, label| push_json_str(out, label));
+    out.push_str(",\"frames\":");
+    push_list(&mut out, &replay.frames, |out, frame| {
+        match frame.event {
+            Some(seq) => { let _ = write!(out, "{{\"e\":{seq},\"c\":"); },
+            None => out.push_str("{\"e\":null,\"c\":"),
+        }
+        push_json_str(out, &frame.caption);
+        match frame.actor {
+            Some(id) => { let _ = write!(out, ",\"a\":{id}"); },
+            None => out.push_str(",\"a\":null"),
+        }
+        out.push_str(",\"s\":");
+        push_list(out, &frame.sources, |out, id| { let _ = write!(out, "{id}"); });
+        out.push_str(",\"m\":");
+        push_list(out, &frame.maps, |out, map| {
+            let _ = write!(out, "{{\"i\":{},\"n\":", map.map);
+            push_list(out, &map.nodes, |out, (path, node)| {
+                out.push('[');
+                push_hex(out, path);
+                let _ = write!(out, ",{},{},", node.exists as u8, node.accessible as u8);
+                match &node.val {
+                    Some(val) => push_json_str(out, val),
+                    None => out.push_str("null"),
+                }
+                let _ = write!(out, ",{}]", node.hidden);
+            });
+            out.push_str(",\"z\":");
+            push_list(out, &map.zippers, |out, z| {
+                let _ = write!(out, "[{},", z.id);
+                push_hex(out, &z.root);
+                out.push(',');
+                push_hex(out, &z.focus);
+                let _ = write!(out, ",{}]", z.writer as u8);
+            });
+            out.push('}');
+        });
+        out.push('}');
+    });
+    out.push_str(",\"ann\":");
+    out.push_str(ann);
+    out.push('}');
+    out
+}
+
+/// Renders the replay as a page that plays it back, steered by `ann` if given.  Fails if the annotations
+/// don't fit the replay
+pub fn render_html<V: ReplayValue>(replay: &Replay<V>, title: &str, ann: Option<&Annotations>) -> Result<String, String> {
+    let ann = match ann {
+        //`<` only appears inside strings, where escaping it keeps the JSON from ending the enclosing `<script>`
+        Some(ann) => crate::annotations::resolve(ann, replay)?.to_string().replace('<', "\\u003c"),
+        None => "null".to_string(),
+    };
+    let mut escaped_title = String::new();
+    for c in title.chars() {
+        match c {
+            '<' => escaped_title.push_str("&lt;"),
+            '>' => escaped_title.push_str("&gt;"),
+            '&' => escaped_title.push_str("&amp;"),
+            c => escaped_title.push(c),
+        }
+    }
+    Ok(TEMPLATE
+        .replace("__TITLE__", &escaped_title)
+        .replace("/*__TRACE_DATA__*/null", &frames_json(replay, title, &ann)))
+}
diff --git a/tools/tracer/src/lib.rs b/tools/tracer/src/lib.rs
new file mode 100644
index 00000000..e6ddd303
--- /dev/null
+++ b/tools/tracer/src/lib.rs
@@ -0,0 +1,63 @@
+//! Replays trace files written by pathmap's [TraceZipper](pathmap::utils::debug::TraceZipper), and renders
+//! them as a self-contained, animated HTML page
+
+use std::io;
+use std::path::{Path, PathBuf};
+
+use pathmap::PathMap;
+use pathmap::arena_compact::ArenaCompactTree;
+use pathmap::ring::{DistributiveLattice, Lattice};
+use pathmap::utils::debug::zipper_tracing::{decode_trace, TraceValue};
+
+mod annotations;
+mod html;
+mod replay;
+
+pub use annotations::{Annotations, EventRange, Label, Mark, RangeNote, Zoom};
+pub use html::render_html;
+pub use replay::{replay, quote_path, Frame, MapView, NodeView, Replay, ReplayConfig, ZipperView};
+
+/// A value type that traces can be replayed with
+pub trait ReplayValue: TraceValue + Clone + Send + Sync + Unpin + Lattice + DistributiveLattice + core::fmt::Debug {
+    /// The text to show for a value, or `None` to show nothing
+    fn display(&self) -> Option<String>;
+    /// Converts a value read from an ACT file
+    fn from_act(val: u64) -> Self;
+}
+
+impl ReplayValue for u64 {
+    fn display(&self) -> Option<String> { Some(self.to_string()) }
+    fn from_act(val: u64) -> Self { val }
+}
+
+impl ReplayValue for () {
+    fn display(&self) -> Option<String> { None }
+    fn from_act(_val: u64) -> Self {}
+}
+
+/// Loads an ACT file into a [PathMap]
+pub fn load_act<V: ReplayValue>(path: &Path) -> io::Result<PathMap<V>> {
+    let act = ArenaCompactTree::open_mmap(path)?;
+    Ok(act.iter().map(|(path, val)| (path, V::from_act(val))).collect())
+}
+
+fn render<V: ReplayValue>(trace: &[u8], acts: &[PathBuf], ann: Option<&Annotations>, cfg: &ReplayConfig, title: &str) -> io::Result<(String, Vec<String>)> {
+    let events = decode_trace::<V>(trace)?;
+    let seeds = acts.iter()
+        .map(|path| Ok((format!("{}", path.file_name().unwrap_or(path.as_os_str()).to_string_lossy()), load_act::<V>(path)?)))
+        .collect::<io::Result<Vec<_>>>()?;
+    let replay = replay(&events, seeds, cfg);
+    let html = render_html(&replay, title, ann).map_err(io::Error::other)?;
+    Ok((html, replay.warnings))
+}
+
+/// Replays a trace, seeding maps from `acts`, and returns the HTML page, steered by `ann` if given, and any warnings
+///
+/// Traces with `u64` and `()` values are supported
+pub fn render_trace(trace: &[u8], acts: &[PathBuf], ann: Option<&Annotations>, cfg: &ReplayConfig, title: &str) -> io::Result<(String, Vec<String>)> {
+    match render::<u64>(trace, acts, ann, cfg, title) {
+        //The trace's value type is only known from its header, so a mismatch means it should be tried as ()
+        Err(err) if err.kind() == io::ErrorKind::InvalidData => render::<()>(trace, acts, ann, cfg, title).map_err(|_| err),
+        result => result,
+    }
+}
diff --git a/tools/tracer/src/main.rs b/tools/tracer/src/main.rs
new file mode 100644
index 00000000..cafb2a32
--- /dev/null
+++ b/tools/tracer/src/main.rs
@@ -0,0 +1,67 @@
+use std::path::PathBuf;
+use std::process::ExitCode;
+
+use tracer::{render_trace, Annotations, ReplayConfig};
+
+const USAGE: &str = "\
+Usage: tracer replay <trace-file> [--act <file.act>]... [--annotations <file.json>] [--prefix-len <n>] [-o <out.html>]
+
+Replays a trace written by pathmap's TraceZipper, and writes it as an animated HTML page
+
+  --act <file>        Seeds a map with the contents of an ACT file.  May be given more than once; a zipper
+                      goes on the first map its root_prefix_path is compatible with.  Without any, maps start empty
+  --annotations <file>  Captions, playback speeds, zooming, and chapter marks for the animation.  See the
+                      tracer crate's `annotations` module for the format
+  --prefix-len <n>    Zippers whose root_prefix_paths share this many leading bytes share a map (default 2)
+  -o <file>           Output file (default: the trace file with an .html extension)";
+
+fn run(args: &[String]) -> Result<(), String> {
+    let mut args = args.iter();
+    match args.next().map(String::as_str) {
+        Some("replay") => {},
+        Some("-h") | Some("--help") => { println!("{USAGE}"); return Ok(()) },
+        _ => return Err(USAGE.to_string()),
+    }
+    let mut trace = None;
+    let mut acts = Vec::new();
+    let mut ann = None;
+    let mut out = None;
+    let mut cfg = ReplayConfig::default();
+    while let Some(arg) = args.next() {
+        let mut value = || args.next().ok_or_else(|| format!("{arg} needs a value"));
+        match arg.as_str() {
+            "--act" => acts.push(PathBuf::from(value()?)),
+            "--annotations" => {
+                let path = PathBuf::from(value()?);
+                let text = std::fs::read_to_string(&path).map_err(|err| format!("{}: {err}", path.display()))?;
+                ann = Some(Annotations::from_json(&text).map_err(|err| format!("{}: {err}", path.display()))?);
+            },
+            "--prefix-len" => cfg.prefix_len = value()?.parse().map_err(|_| "--prefix-len needs a number".to_string())?,
+            "-o" => out = Some(PathBuf::from(value()?)),
+            _ if trace.is_none() && !arg.starts_with('-') => trace = Some(PathBuf::from(arg)),
+            _ => return Err(format!("unexpected argument {arg}\n\n{USAGE}")),
+        }
+    }
+    let trace = trace.ok_or_else(|| USAGE.to_string())?;
+    let out = out.unwrap_or_else(|| trace.with_extension("html"));
+    let bytes = std::fs::read(&trace).map_err(|err| format!("{}: {err}", trace.display()))?;
+    let title = trace.file_name().map_or_else(|| "trace".to_string(), |name| name.to_string_lossy().into_owned());
+    let (html, warnings) = render_trace(&bytes, &acts, ann.as_ref(), &cfg, &title).map_err(|err| format!("{}: {err}", trace.display()))?;
+    for warning in warnings {
+        eprintln!("warning: {warning}");
+    }
+    std::fs::write(&out, html).map_err(|err| format!("{}: {err}", out.display()))?;
+    println!("wrote {}", out.display());
+    Ok(())
+}
+
+fn main() -> ExitCode {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    match run(&args) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(err) => {
+            eprintln!("{err}");
+            ExitCode::FAILURE
+        }
+    }
+}
diff --git a/tools/tracer/src/player.html b/tools/tracer/src/player.html
new file mode 100644
index 00000000..0a1916d5
--- /dev/null
+++ b/tools/tracer/src/player.html
@@ -0,0 +1,493 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>__TITLE__</title>
+<style>
+  :root {
+    --bg: #faf9f6; --fg: #1d2127; --muted: #6a717c; --rule: #dedbd3;
+    --edge: #b9bdc5; --node: #ffffff; --node-stroke: #4a5160; --ghost: #a3a8b1;
+    --val-fill: #fbe7b6; --val-text: #8a5a00; --button: #efede7; --button-hover: #e3e0d7;
+    --off-fill: #ecebe7; --off-stroke: #b3b6bc; --off-text: #8d929b; --off-edge: #d5d7db; --pill: #f1efe9;
+    --note-bg: #f3f1ec;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #15171c; --fg: #e4e6ea; --muted: #9aa1ac; --rule: #2c3038;
+      --edge: #4a505b; --node: #20232a; --node-stroke: #c3c8d1; --ghost: #6b717c;
+      --val-fill: #4d3b12; --val-text: #f2c66d; --button: #23262d; --button-hover: #2e323a;
+      --off-fill: #1c1e23; --off-stroke: #4b505a; --off-text: #6f7580; --off-edge: #30343c; --pill: #20232a;
+      --note-bg: #1b1d22;
+    }
+  }
+  html, body { margin: 0; height: 100%; background: var(--bg); color: var(--fg); font: 14px/1.4 system-ui, -apple-system, "Segoe UI", sans-serif; }
+  #app { display: flex; flex-direction: column; height: 100%; }
+  header { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 14px; padding: 10px 16px; border-bottom: 1px solid var(--rule); }
+  header h1 { font-size: 15px; font-weight: 600; margin: 0 8px 0 0; }
+  .controls { display: flex; align-items: center; gap: 4px; }
+  button, select { font: inherit; color: var(--fg); background: var(--button); border: 1px solid var(--rule); border-radius: 6px; padding: 3px 9px; cursor: pointer; }
+  button:hover { background: var(--button-hover); }
+  .scrub-wrap { position: relative; flex: 1; min-width: 160px; display: flex; }
+  #scrub { width: 100%; }
+  #ticks { position: absolute; left: 8px; right: 8px; top: -5px; height: 8px; pointer-events: none; }
+  .tick { position: absolute; width: 3px; height: 8px; border-radius: 2px; background: var(--node-stroke); transform: translateX(-50%); }
+  #counter { font-variant-numeric: tabular-nums; color: var(--muted); min-width: 70px; text-align: right; }
+  #caption { display: flex; align-items: center; gap: 12px; padding: 10px 16px; font: 600 20px/1.35 ui-monospace, SFMono-Regular, Menlo, monospace; border-bottom: 1px solid var(--rule); min-height: 28px; overflow-wrap: anywhere; }
+  #swatch { width: 16px; height: 16px; border-radius: 50%; flex: none; }
+  #stage { flex: 1; min-height: 0; }
+  /* The annotation caption has a band of its own, so it never covers the graph */
+  #note { display: flex; align-items: center; justify-content: center; min-height: 34px; padding: 8px 16px; background: var(--note-bg); border-bottom: 1px solid var(--rule); font: 600 22px/1.35 system-ui, sans-serif; text-align: center; }
+  #note span { opacity: 0; transition: opacity 0.35s; }
+  #note span.on { opacity: 1; }
+  .region { stroke-width: 1.5; stroke-dasharray: 6 4; }
+  .region-tab { font: 700 15px system-ui, sans-serif; dominant-baseline: central; fill: #fff; }
+  #view { width: 100%; height: 100%; display: block; }
+  footer { display: flex; flex-wrap: wrap; gap: 6px 18px; padding: 8px 16px; border-top: 1px solid var(--rule); color: var(--muted); font-size: 12px; }
+  footer svg { vertical-align: middle; margin-right: 4px; }
+  .edge { stroke: var(--edge); stroke-width: 1.5; }
+  .edge.ghost { stroke: var(--ghost); stroke-dasharray: 4 4; }
+  .edge.off { stroke: var(--off-edge); }
+  .node { fill: var(--node); stroke: var(--node-stroke); stroke-width: 1.5; }
+  .node.val { fill: var(--val-fill); }
+  .node.ghost { fill: var(--bg); stroke: var(--ghost); stroke-dasharray: 3 3; }
+  .node.off { fill: var(--off-fill); stroke: var(--off-stroke); stroke-width: 1; }
+  .root { fill: var(--node-stroke); }
+  .label { fill: var(--fg); font: 600 13px ui-monospace, Menlo, monospace; text-anchor: middle; dominant-baseline: central; pointer-events: none; }
+  .label.ghost { fill: var(--ghost); }
+  .label.off { fill: var(--off-text); font-weight: 500; }
+  .label.hex { font-size: 9px; }
+  .value { fill: var(--val-text); font: 11px ui-monospace, Menlo, monospace; text-anchor: middle; }
+  .value.off { fill: var(--off-text); }
+  .fan { stroke: var(--ghost); stroke-width: 1.5; stroke-dasharray: 3 3; }
+  .pill { fill: var(--pill); stroke: var(--ghost); stroke-width: 1.5; stroke-dasharray: 4 3; }
+  .pill-text { fill: var(--muted); font: 700 12px system-ui, sans-serif; text-anchor: middle; dominant-baseline: central; }
+  .panel { fill: var(--muted); font: 600 12px system-ui, sans-serif; }
+  .tag { font: 700 12px system-ui, sans-serif; dominant-baseline: central; }
+</style>
+</head>
+<body>
+<div id="app">
+  <header>
+    <h1 id="title"></h1>
+    <div class="controls">
+      <button id="first" title="First (Home)">⏮</button>
+      <button id="prev" title="Previous (←)">◀</button>
+      <button id="play" title="Play / pause (space)">▶</button>
+      <button id="next" title="Next (→)">▶︎|</button>
+      <button id="last" title="Last (End)">⏭</button>
+    </div>
+    <div class="scrub-wrap"><input id="scrub" type="range" min="0" value="0"><div id="ticks"></div></div>
+    <span id="counter"></span>
+    <select id="chapters" title="Jump to a marked point" hidden></select>
+    <select id="speed" title="Speed">
+      <option value="0.25">¼×</option><option value="0.5">½×</option><option value="1" selected>1×</option><option value="2">2×</option><option value="4">4×</option>
+    </select>
+  </header>
+  <div id="caption"><span id="swatch"></span><span id="caption-text"></span></div>
+  <div id="note" hidden><span></span></div>
+  <div id="stage"><svg id="view" preserveAspectRatio="xMidYMin meet"></svg></div>
+  <footer>
+    <span><svg width="16" height="16"><circle cx="8" cy="8" r="6" class="node"/></svg>path exists</span>
+    <span><svg width="16" height="16"><circle cx="8" cy="8" r="6" class="node val"/></svg>has a value</span>
+    <span><svg width="16" height="16"><circle cx="8" cy="8" r="6" class="node ghost"/></svg>path doesn't exist</span>
+    <span><svg width="16" height="16"><circle cx="8" cy="8" r="6" class="node off"/></svg>no live zipper can reach it</span>
+    <span><svg width="26" height="16"><circle cx="13" cy="8" r="6" fill="none" stroke="#2e86de" stroke-width="2.5"/></svg><svg width="26" height="16"><line x1="2" y1="8" x2="24" y2="8" stroke="#2e86de" stroke-width="6" stroke-linecap="round" opacity="0.35"/></svg>write zipper focus &amp; path</span>
+    <span><svg width="26" height="16"><circle cx="13" cy="8" r="6" fill="none" stroke="#2e86de" stroke-width="2.5" stroke-dasharray="4 3"/></svg><svg width="26" height="16"><line x1="3" y1="8" x2="24" y2="8" stroke="#2e86de" stroke-width="5" stroke-linecap="round" stroke-dasharray="0.1 7" opacity="0.6"/></svg>read zipper focus &amp; path</span>
+    <span><svg width="26" height="16"><line x1="2" y1="8" x2="24" y2="8" stroke="#2e86de" stroke-width="2" stroke-dasharray="3 3"/></svg>above the zipper's root</span>
+    <span><svg width="44" height="16"><rect x="1" y="2" width="42" height="12" rx="6" class="pill"/></svg>children not shown</span>
+  </footer>
+</div>
+<script>
+"use strict";
+const DATA = /*__TRACE_DATA__*/null;
+
+const DX = 40, DY = 60, R = 12, GAP = 80, TOP = 56;
+// The most the drawing is scaled up, so a small trie doesn't fill the window with giant nodes
+const MAX_SCALE = 1.4;
+// Zooming on a subtrie is allowed to scale further, so it can be read, unless its annotation sets a max_scale
+const MAX_ZOOM_SCALE = 4;
+// Hidden children are summarized by a pseudo node, keyed by its parent's path with this suffix
+const MORE = "+";
+const PALETTE = ["#e4572e", "#2e86de", "#17a589", "#9b59b6", "#e1a100", "#d6336c", "#16a3b8", "#7d8a2e"];
+const zcolor = id => PALETTE[id % PALETTE.length];
+// Labeled regions get muted colors, so they don't compete with the zippers
+const REGION_PALETTE = ["#5b6fb5", "#3f8f7d", "#a8577e", "#8a7a3e", "#6a5d9e", "#3d8aa8", "#9a6545", "#5e7f3f"];
+const lerp = (a, b, t) => a + (b - a) * t;
+const ease = t => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+const esc = s => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+
+const svg = document.getElementById("view");
+const scrub = document.getElementById("scrub");
+const playButton = document.getElementById("play");
+const speedSelect = document.getElementById("speed");
+
+function byteLabel(hex) {
+  const b = parseInt(hex.slice(-2), 16);
+  if (b === 0x20) return { text: "␣", hex: false };
+  if (b > 0x20 && b < 0x7f) return { text: String.fromCharCode(b), hex: false };
+  return { text: hex.slice(-2), hex: true };
+}
+
+function pathText(hex) {
+  let s = "";
+  for (let i = 0; i < hex.length; i += 2) {
+    const b = parseInt(hex.slice(i, i + 2), 16);
+    s += (b >= 0x20 && b < 0x7f && b !== 0x22 && b !== 0x5c) ? String.fromCharCode(b) : "\\x" + hex.slice(i, i + 2);
+  }
+  return '"' + s + '"';
+}
+
+const parentPath = path => path.endsWith(MORE) ? path.slice(0, -1) : path.slice(0, -2);
+const parentKey = key => {
+  const colon = key.indexOf(":");
+  const path = key.slice(colon + 1);
+  return path === "" ? null : key.slice(0, colon + 1) + parentPath(path);
+};
+
+// Positions every visible node of a frame.  Maps are laid out side by side, and each map is a tree
+// with the leaves spaced evenly and each parent centered over its children
+const layouts = [];
+function layoutOf(i) {
+  if (!layouts[i]) layouts[i] = layout(DATA.frames[i]);
+  return layouts[i];
+}
+
+function layout(frame) {
+  const nodes = new Map(), panels = new Map(), zippers = [];
+  let xOff = 0, maxY = TOP;
+  for (const mv of frame.m) {
+    const info = new Map(mv.n.map(n => [n[0], n]));
+    const kids = new Map();
+    for (const p of info.keys()) {
+      if (p === "") continue;
+      const parent = p.slice(0, -2);
+      if (!kids.has(parent)) kids.set(parent, []);
+      kids.get(parent).push(p);
+    }
+    for (const list of kids.values()) list.sort();
+    // The pseudo node for hidden children goes after the shown ones
+    for (const [p, n] of info) {
+      if (n[4] > 0) {
+        if (!kids.has(p)) kids.set(p, []);
+        kids.get(p).push(p + MORE);
+      }
+    }
+    const slot = new Map();
+    let leaf = 0;
+    const visit = p => {
+      if (p.endsWith(MORE)) { slot.set(p, leaf + 0.5); leaf += 2; return; }
+      const ks = kids.get(p);
+      if (!ks) { slot.set(p, leaf++); return; }
+      ks.forEach(visit);
+      slot.set(p, (slot.get(ks[0]) + slot.get(ks[ks.length - 1])) / 2);
+    };
+    if (info.has("")) visit("");
+    for (const [p, n] of info) {
+      if (!slot.has(p)) continue;
+      const y = TOP + p.length / 2 * DY;
+      maxY = Math.max(maxY, y);
+      nodes.set(mv.i + ":" + p, { x: xOff + slot.get(p) * DX, y, exists: !!n[1], accessible: !!n[2], val: n[3], path: p, map: mv.i, o: 1 });
+      if (n[4] > 0) {
+        const mp = p + MORE;
+        nodes.set(mv.i + ":" + mp, { x: xOff + slot.get(mp) * DX, y: y + DY, more: n[4], accessible: !!n[2], path: mp, map: mv.i, o: 1 });
+        maxY = Math.max(maxY, y + DY);
+      }
+    }
+    panels.set(mv.i, { x: xOff - R, label: DATA.maps[mv.i] || "map " + mv.i, o: 1 });
+    for (const z of mv.z) zippers.push({ id: z[0], map: mv.i, root: z[1], focus: z[2], writer: !!z[3] });
+    xOff += Math.max(leaf, 1) * DX + GAP;
+  }
+  const width = Math.max(xOff - GAP, DX * 4);
+  return { nodes, panels, zippers, box: [-DX, 0, width + DX * 3, maxY + 80] };
+}
+
+// The state as last drawn.  Transitions start from here, so an interrupted transition continues smoothly
+let cur = { nodes: new Map(), panels: new Map(), rings: new Map(), box: [-DX, 0, DX * 8, 300] };
+let idx = 0, anim = null, playing = false, timer = null;
+
+// The settings each frame gets from the annotations' ranges.  A later range wins for each setting it has
+const ANN = (DATA && DATA.ann) || { start: 0, ranges: [], marks: [] };
+const notes = DATA ? DATA.frames.map(() => ({})) : [];
+for (const r of ANN.ranges) {
+  for (let i = r.from; i <= r.to; i++) {
+    const n = notes[i];
+    if (r.caption != null) n.caption = r.caption;
+    if (r.speed != null) n.speed = r.speed;
+    if (r.hold != null) n.hold = r.hold;
+    if (r.zoom) n.zoom = r.zoom;
+    if (r.collapse) n.collapse = r;
+  }
+}
+
+// The playback speed for a frame: the chosen speed, times the frame's annotated speed
+const speed = i => parseFloat(speedSelect.value) * (notes[i].speed || 1);
+const clampFrame = i => Math.max(0, Math.min(DATA.frames.length - 1, i));
+
+// The frame one step from `i`.  A collapsed range is a single step, from the frame before it to its last frame
+function stepFrom(i, dir) {
+  let j = clampFrame(i + dir);
+  const c = notes[j].collapse;
+  if (c && j !== c.to) j = clampFrame(dir > 0 ? c.to : c.from - 1);
+  return j;
+}
+
+// Grows a view rectangle so it isn't scaled up by more than `cap`
+function fitBox([bx, by, bw, bh], cap, center) {
+  const minW = svg.clientWidth / cap, minH = svg.clientHeight / cap;
+  if (bw < minW) { bx -= (minW - bw) / 2; bw = minW; }
+  if (bh < minH) { if (center) by -= (minH - bh) / 2; bh = minH; }
+  return [bx, by, bw, bh];
+}
+
+// The camera for a frame: the whole layout, or the subtrie its annotations zoom on
+function cameraFor(i, to) {
+  const z = notes[i].zoom;
+  if (z) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const n of to.nodes.values()) {
+      if (n.map !== z.map || !n.path.startsWith(z.path)) continue;
+      minX = Math.min(minX, n.x); maxX = Math.max(maxX, n.x);
+      minY = Math.min(minY, n.y); maxY = Math.max(maxY, n.y);
+    }
+    if (minX !== Infinity) return fitBox([minX - DX * 1.2, minY - DY * 0.8, maxX - minX + DX * 3, maxY - minY + DY * 1.6], z.max_scale || MAX_ZOOM_SCALE, true);
+  }
+  return fitBox(to.box, MAX_SCALE, false);
+}
+
+function goTo(i, instant) {
+  clearTimeout(timer);
+  idx = clampFrame(i);
+  const to = layoutOf(idx);
+  anim = { t0: performance.now(), dur: instant ? 0 : 450 / speed(idx), from: cur, to, box: cameraFor(idx, to) };
+  updateHud();
+  requestAnimationFrame(tick);
+}
+
+function nearestFrom(from, key) {
+  for (let k = key; k !== null; k = parentKey(k)) {
+    const n = from.nodes.get(k);
+    if (n) return n;
+  }
+  return null;
+}
+
+function tick(now) {
+  if (!anim) return;
+  const { from, to } = anim;
+  const t = anim.dur ? Math.min(1, (now - anim.t0) / anim.dur) : 1;
+  const e = ease(t);
+  const nodes = new Map();
+  for (const [k, tn] of to.nodes) {
+    const fn = from.nodes.get(k);
+    if (fn) {
+      nodes.set(k, { ...tn, x: lerp(fn.x, tn.x, e), y: lerp(fn.y, tn.y, e), o: lerp(fn.o, 1, e) });
+    } else {
+      // New nodes grow out of their nearest visible ancestor
+      const start = nearestFrom(from, parentKey(k)) || tn;
+      nodes.set(k, { ...tn, x: lerp(start.x, tn.x, e), y: lerp(start.y, tn.y, e), o: e });
+    }
+  }
+  for (const [k, fn] of from.nodes) {
+    if (!to.nodes.has(k) && fn.o * (1 - e) > 0.02) nodes.set(k, { ...fn, o: fn.o * (1 - e) });
+  }
+  const rings = new Map();
+  for (const z of to.zippers) {
+    const target = nodes.get(z.map + ":" + z.focus);
+    if (!target) continue;
+    const fr = from.rings.get(z.id);
+    rings.set(z.id, fr ? { x: lerp(fr.x, target.x, e), y: lerp(fr.y, target.y, e), o: lerp(fr.o, 1, e) } : { x: target.x, y: target.y, o: e });
+  }
+  for (const [id, fr] of from.rings) {
+    if (!rings.has(id) && fr.o * (1 - e) > 0.02) rings.set(id, { ...fr, o: fr.o * (1 - e) });
+  }
+  const panels = new Map();
+  for (const [i, tp] of to.panels) {
+    const fp = from.panels.get(i);
+    panels.set(i, fp ? { ...tp, x: lerp(fp.x, tp.x, e), o: lerp(fp.o, 1, e) } : { ...tp, o: e });
+  }
+  const box = anim.box.map((v, j) => lerp(from.box[j], v, e));
+  cur = { nodes, panels, rings, box };
+  draw(cur, to);
+  if (t < 1) {
+    requestAnimationFrame(tick);
+  } else {
+    anim = null;
+    if (playing) timer = setTimeout(() => idx < DATA.frames.length - 1 ? goTo(stepFrom(idx, 1)) : setPlaying(false), 350 / speed(idx) + (notes[idx].hold || 0) * 1000);
+  }
+}
+
+function draw(state, target) {
+  const frame = DATA.frames[idx];
+  const out = [];
+  out.push(`<defs><marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="context-stroke"/></marker></defs>`);
+  for (const p of state.panels.values()) {
+    out.push(`<text class="panel" x="${p.x}" y="${TOP - 34}" opacity="${p.o}">${esc(p.label)}</text>`);
+  }
+  // Labeled subtries: a tinted region around everything below the labeled node, with its name on a tab.  Shorter
+  // paths are drawn first, so a region nested in another is drawn over it
+  // Tabs keep at least their normal size on screen when the view is scaled down to fit a large trie
+  const k = Math.min(3, Math.max(1, 1 / Math.min(svg.clientWidth / state.box[2], svg.clientHeight / state.box[3])));
+  const tabs = [];
+  const labels = (ANN.labels || []).map((l, li) => ({ ...l, color: REGION_PALETTE[li % REGION_PALETTE.length] }))
+    .filter(l => l.from <= idx && idx <= l.to).sort((a, b) => a.path.length - b.path.length);
+  for (const l of labels) {
+    const root = state.nodes.get(l.map + ":" + l.path);
+    if (!root) continue;
+    let minX = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const n of state.nodes.values()) {
+      if (n.map !== l.map || !n.path.startsWith(l.path)) continue;
+      minX = Math.min(minX, n.x - (n.more ? 36 : R)); maxX = Math.max(maxX, n.x + (n.more ? 36 : R));
+      maxY = Math.max(maxY, n.y + R + (n.val != null ? 20 : 6));
+    }
+    const tabW = (l.text.length * 8.5 + 20) * k, tabH = 26 * k, pad = 6;
+    // The tab is placed left of the edge that leads into the region where there's room for it
+    const x = minX - pad, y = root.y - R - pad - tabH;
+    const tabX = root.x - R - 6 - tabW >= x ? root.x - R - 6 - tabW : x;
+    //The region's size comes from the subtrie alone; a tab that's wider than the region extends past it
+    const w = maxX + pad - x, h = maxY + pad - y;
+    out.push(`<rect class="region" x="${x}" y="${y}" width="${w}" height="${h}" rx="14" fill="${l.color}" fill-opacity="0.08" stroke="${l.color}" stroke-opacity="0.55" opacity="${root.o}"/>`);
+    //The tabs are drawn over the nodes, so they're never hidden
+    tabs.push(`<g opacity="${root.o}"><rect x="${tabX}" y="${y}" width="${tabW}" height="${tabH}" rx="${tabH / 2}" fill="${l.color}"/><text class="region-tab" x="${tabX + 10 * k}" y="${y + tabH / 2}" style="font-size: ${15 * k}px">${esc(l.text)}</text></g>`);
+  }
+  for (const n of state.nodes.values()) {
+    if (n.path === "") continue;
+    const parent = state.nodes.get(n.map + ":" + parentPath(n.path));
+    if (!parent) continue;
+    const o = Math.min(n.o, parent.o);
+    if (n.more) {
+      // A fan of edges into the pill, so it reads as many children rather than one
+      for (const dx of [-14, 0, 14]) out.push(`<line class="fan" x1="${parent.x}" y1="${parent.y + R}" x2="${n.x + dx}" y2="${n.y - 11}" opacity="${o}"/>`);
+      continue;
+    }
+    const cls = !n.exists ? " ghost" : n.accessible ? "" : " off";
+    out.push(`<line class="edge${cls}" x1="${parent.x}" y1="${parent.y}" x2="${n.x}" y2="${n.y}" opacity="${o}"/>`);
+  }
+  // Each zipper's path from the map root to its focus.  Zippers that share a path are offset so both show
+  target.zippers.forEach((z, zi) => {
+    const shift = (zi - (target.zippers.length - 1) / 2) * 5;
+    const above = [], below = [];
+    for (let k = 0; k <= z.focus.length; k += 2) {
+      const n = state.nodes.get(z.map + ":" + z.focus.slice(0, k));
+      if (!n) continue;
+      const pt = `${n.x + shift},${n.y}`;
+      if (k <= z.root.length) above.push(pt);
+      if (k >= z.root.length) below.push(pt);
+    }
+    const color = zcolor(z.id);
+    if (above.length > 1) out.push(`<polyline points="${above.join(" ")}" fill="none" stroke="${color}" stroke-width="2" stroke-dasharray="3 4" opacity="0.8"/>`);
+    if (below.length > 1) {
+      // Writers get a solid band, readers a dotted one
+      const style = z.writer ? `stroke-width="7" opacity="0.32"` : `stroke-width="6" stroke-dasharray="0.1 9" opacity="0.7"`;
+      out.push(`<polyline points="${below.join(" ")}" fill="none" stroke="${color}" ${style} stroke-linecap="round" stroke-linejoin="round"/>`);
+    }
+  });
+  for (const n of state.nodes.values()) {
+    const tip = n.more ? "" : `<title>${esc(pathText(n.path))}${n.val != null ? " = " + esc(n.val) : ""}${!n.exists ? " (doesn't exist)" : n.accessible ? "" : " (no live zipper can reach it)"}</title>`;
+    if (n.path === "") {
+      out.push(`<g opacity="${n.o}"><circle class="root" cx="${n.x}" cy="${n.y}" r="6"/>${tip}</g>`);
+      continue;
+    }
+    if (n.more) {
+      const text = `+${n.more} more`;
+      const w = text.length * 7 + 16;
+      out.push(`<g opacity="${n.o}"><rect class="pill" x="${n.x - w / 2}" y="${n.y - 11}" width="${w}" height="22" rx="11"/><text class="pill-text" x="${n.x}" y="${n.y}">${text}</text><title>${n.more} more children not shown</title></g>`);
+      continue;
+    }
+    const label = byteLabel(n.path);
+    const state_ = !n.exists ? "ghost" : n.accessible ? "" : "off";
+    const cls = state_ ? "node " + state_ : (n.val != null ? "node val" : "node");
+    let g = `<g opacity="${n.o}"><circle class="${cls}" cx="${n.x}" cy="${n.y}" r="${R}"/>`;
+    g += `<text class="label${state_ ? " " + state_ : ""}${label.hex ? " hex" : ""}" x="${n.x}" y="${n.y}">${esc(label.text)}</text>`;
+    if (n.val != null) g += `<text class="value${state_ === "off" ? " off" : ""}" x="${n.x}" y="${n.y + R + 15}">${esc(n.val)}</text>`;
+    out.push(g + tip + "</g>");
+  }
+  out.push(...tabs);
+  for (const sid of frame.s) {
+    const a = state.rings.get(sid), b = state.rings.get(frame.a);
+    if (!a || !b) continue;
+    const mx = (a.x + b.x) / 2, my = Math.min(a.y, b.y) - 50;
+    out.push(`<path d="M${a.x},${a.y - R - 6} Q${mx},${my} ${b.x},${b.y - R - 6}" fill="none" stroke="${zcolor(sid)}" stroke-width="2" stroke-dasharray="6 4" marker-end="url(#arrow)" opacity="${Math.min(a.o, b.o)}"/>`);
+  }
+  const writers = new Map(target.zippers.map(z => [z.id, z.writer]));
+  for (const [id, r] of state.rings) {
+    const color = zcolor(id);
+    const actor = id === frame.a;
+    const writer = writers.has(id) ? writers.get(id) : r.writer;
+    r.writer = writer;
+    let g = `<g opacity="${r.o}">`;
+    if (actor) g += `<circle cx="${r.x}" cy="${r.y}" r="${R + 9}" fill="none" stroke="${color}" stroke-width="7" opacity="0.22"/>`;
+    g += `<circle cx="${r.x}" cy="${r.y}" r="${R + 5}" fill="none" stroke="${color}" stroke-width="${actor ? 3.5 : 2.5}"${writer ? "" : ` stroke-dasharray="5 3"`}/>`;
+    // Writers get a filled tag, readers an outlined one
+    const text = `z${id} ${writer ? "write" : "read"}`;
+    const w = text.length * 7 + 12, tx = r.x + R + 6, ty = r.y - R - 10;
+    g += writer
+      ? `<rect x="${tx}" y="${ty - 9}" width="${w}" height="18" rx="9" fill="${color}"/><text class="tag" x="${tx + 6}" y="${ty}" fill="#fff">${text}</text>`
+      : `<rect x="${tx}" y="${ty - 9}" width="${w}" height="18" rx="9" fill="var(--bg)" stroke="${color}" stroke-width="1.5"/><text class="tag" x="${tx + 6}" y="${ty}" fill="${color}">${text}</text>`;
+    out.push(g + "</g>");
+  }
+  svg.innerHTML = out.join("");
+  svg.setAttribute("viewBox", state.box.join(" "));
+}
+
+function updateHud() {
+  const frame = DATA.frames[idx];
+  document.getElementById("caption-text").textContent = frame.c;
+  document.getElementById("swatch").style.background = frame.a != null ? zcolor(frame.a) : "transparent";
+  const last = DATA.frames[DATA.frames.length - 1].e;
+  document.getElementById("counter").textContent = frame.e == null ? "start" : `event ${frame.e} / ${last}`;
+  scrub.value = idx;
+  const note = document.querySelector("#note span");
+  if (notes[idx].caption) note.textContent = notes[idx].caption;
+  note.classList.toggle("on", !!notes[idx].caption);
+  if (frame.e != null) history.replaceState(null, "", `#event=${frame.e}`);
+}
+
+function setPlaying(on) {
+  playing = on;
+  playButton.textContent = on ? "⏸" : "▶";
+  clearTimeout(timer);
+  if (on) {
+    if (idx >= DATA.frames.length - 1) goTo(0); else if (!anim) goTo(stepFrom(idx, 1));
+  }
+}
+
+if (!DATA) {
+  document.getElementById("caption-text").textContent = "No trace data.  This page is generated by `tracer replay`.";
+} else {
+  document.getElementById("title").textContent = DATA.title;
+  scrub.max = DATA.frames.length - 1;
+  document.getElementById("first").onclick = () => { setPlaying(false); goTo(0); };
+  document.getElementById("prev").onclick = () => { setPlaying(false); goTo(stepFrom(idx, -1)); };
+  document.getElementById("next").onclick = () => { setPlaying(false); goTo(stepFrom(idx, 1)); };
+  document.getElementById("last").onclick = () => { setPlaying(false); goTo(DATA.frames.length - 1); };
+  playButton.onclick = () => setPlaying(!playing);
+  scrub.oninput = () => { setPlaying(false); goTo(parseInt(scrub.value, 10)); };
+  document.addEventListener("keydown", ev => {
+    if (ev.target.tagName === "SELECT" || ev.target.tagName === "INPUT") return;
+    if (ev.key === "ArrowRight") { setPlaying(false); goTo(stepFrom(idx, 1)); }
+    else if (ev.key === "ArrowLeft") { setPlaying(false); goTo(stepFrom(idx, -1)); }
+    else if (ev.key === " ") { ev.preventDefault(); setPlaying(!playing); }
+    else if (ev.key === "Home") { setPlaying(false); goTo(0); }
+    else if (ev.key === "End") { setPlaying(false); goTo(DATA.frames.length - 1); }
+    else return;
+  });
+  document.getElementById("note").hidden = !ANN.ranges.some(r => r.caption != null);
+  // Chapter marks, in a menu and as ticks on the scrubber
+  if (ANN.marks.length) {
+    const chapters = document.getElementById("chapters");
+    chapters.hidden = false;
+    chapters.innerHTML = `<option value="">Jump to…</option>` + ANN.marks.map(m => `<option value="${m.frame}">${esc(m.label)}</option>`).join("");
+    chapters.onchange = () => { if (chapters.value !== "") { setPlaying(false); goTo(parseInt(chapters.value, 10)); } chapters.value = ""; };
+    document.getElementById("ticks").innerHTML = ANN.marks.map(m =>
+      `<div class="tick" style="left: ${m.frame / Math.max(1, DATA.frames.length - 1) * 100}%" title="${esc(m.label)}"></div>`).join("");
+  }
+  window.addEventListener("resize", () => { if (!anim) goTo(idx, true); });
+  // A link may name the event to open at, as #event=N
+  const linked = /^#event=(\d+)$/.exec(location.hash);
+  const linkedFrame = linked ? DATA.frames.findIndex(f => f.e === parseInt(linked[1], 10)) : -1;
+  goTo(linkedFrame >= 0 ? linkedFrame : ANN.start, true);
+}
+</script>
+</body>
+</html>
diff --git a/tools/tracer/src/replay.rs b/tools/tracer/src/replay.rs
new file mode 100644
index 00000000..3bdff67e
--- /dev/null
+++ b/tools/tracer/src/replay.rs
@@ -0,0 +1,765 @@
+//! Replays a trace against real [PathMap]s, producing a [Frame] after each event
+
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
+
+use pathmap::PathMap;
+use pathmap::utils::ByteMask;
+use pathmap::utils::debug::zipper_tracing::{TraceOp, TraceSrc};
+use pathmap::zipper::*;
+
+use crate::ReplayValue;
+
+/// The most children shown below one node.  The rest are counted in [NodeView::hidden]
+const MAX_CHILDREN: usize = 12;
+/// How many levels below a zipper's focus are shown
+const FOCUS_DEPTH: usize = 3;
+/// Beyond the regions around the zippers, the rest of a map is shown until it has this many nodes
+const MAP_NODE_BUDGET: usize = 400;
+
+/// Settings for a replay
+#[derive(Clone, Debug)]
+pub struct ReplayConfig {
+    /// Zippers whose `root_prefix_path`s share at least this many leading bytes are placed on the same map
+    pub prefix_len: usize,
+}
+
+impl Default for ReplayConfig {
+    fn default() -> Self {
+        Self { prefix_len: 2 }
+    }
+}
+
+/// The result of replaying a trace
+pub struct Replay<V: ReplayValue> {
+    /// The state of each map after the last event
+    pub maps: Vec<PathMap<V>>,
+    /// A description of each map
+    pub map_labels: Vec<String>,
+    /// The state before the first event, followed by the state after each event
+    pub frames: Vec<Frame>,
+    /// Problems encountered during the replay
+    pub warnings: Vec<String>,
+}
+
+/// The visible state after one event
+#[derive(Clone, Debug)]
+pub struct Frame {
+    /// The `seq` of the event, or `None` for the state before the first event
+    pub event: Option<u64>,
+    pub caption: String,
+    /// The zipper that performed the event
+    pub actor: Option<u64>,
+    /// Traced zippers the event read from
+    pub sources: Vec<u64>,
+    /// The maps that are seeded, or that have had a zipper
+    pub maps: Vec<MapView>,
+}
+
+/// The visible part of one map: the regions around its live zippers, and as much of the rest as fits
+#[derive(Clone, Debug)]
+pub struct MapView {
+    pub map: usize,
+    /// Keyed by absolute path.  Every node's parent is present, up to the map root (the empty path)
+    pub nodes: BTreeMap<Vec<u8>, NodeView>,
+    pub zippers: Vec<ZipperView>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct NodeView {
+    /// `false` for the part of a zipper's path that doesn't exist in the trie
+    pub exists: bool,
+    /// The node is at or below the root of a live zipper
+    pub accessible: bool,
+    pub val: Option<String>,
+    /// The number of children the node has in the trie
+    pub child_count: usize,
+    /// The number of the node's children that aren't shown
+    pub hidden: usize,
+}
+
+#[derive(Clone, Debug)]
+pub struct ZipperView {
+    pub id: u64,
+    /// Absolute path of the zipper's root
+    pub root: Vec<u8>,
+    /// Absolute path of the zipper's focus
+    pub focus: Vec<u8>,
+    pub writer: bool,
+}
+
+fn is_write_op<V>(op: &TraceOp<V>) -> bool {
+    use TraceOp::*;
+    matches!(op, ValWritten { .. } | GetValMut | GetValOrSetMut { .. } | GetValOrSetMutWith | SetVal { .. } |
+        SetValAt { .. } | RemoveVal { .. } | ZipperHead | Graft { .. } | GraftSrcAt { .. } | GraftMap { .. } |
+        GraftChildMaps { .. } | GraftMaskedBranches { .. } | JoinInto { .. } | JoinMapInto { .. } | JoinIntoTake { .. } |
+        JoinKPathInto { .. } | MeetKPathInto { .. } | InsertPrefix { .. } | RemovePrefix { .. } | MeetInto { .. } |
+        Meet2 { .. } | SubtractInto { .. } | Restrict { .. } | Restricting { .. } | TakeMap { .. } | RemoveBranches { .. } |
+        RemoveSubtrie { .. } | RemoveUnmaskedBranches { .. } | CreatePath | PrunePath | PruneAscend)
+}
+
+fn traced_sources<V>(op: &TraceOp<V>) -> Vec<u64> {
+    use TraceOp::*;
+    let srcs: Vec<&TraceSrc<V>> = match op {
+        Graft { src } | GraftSrcAt { src, .. } | GraftMaskedBranches { src, .. } | JoinInto { src } |
+        JoinIntoTake { src, .. } | MeetInto { src, .. } | SubtractInto { src, .. } | Restrict { src } |
+        Restricting { src } => vec![src],
+        Meet2 { src_a, src_b } => vec![src_a, src_b],
+        _ => vec![],
+    };
+    srcs.into_iter().filter_map(|src| match src { TraceSrc::Traced(id) => Some(*id), TraceSrc::Unknown(_) => None }).collect()
+}
+
+fn overlaps(a: &[u8], b: &[u8]) -> bool {
+    a.starts_with(b) || b.starts_with(a)
+}
+
+/// A map that zippers may be assigned to
+struct MapSlot {
+    /// For maps not seeded from a file, the leading bytes shared by the zippers on the map.  `None`
+    /// for a map made for a zipper whose `root_prefix_path` is too short to share
+    key: Option<Vec<u8>>,
+    /// For maps seeded from a file, the index of the seed
+    seed: Option<usize>,
+    label: String,
+    /// Live zippers, their `root_prefix_path`s, and whether they're writers
+    live: Vec<(u64, Vec<u8>, bool)>,
+}
+
+/// Decides which map each zipper is on.  Returns the map index of each zipper id, and the labels of maps
+/// added beyond the seeded ones
+fn assign_maps<V: ReplayValue>(events: &[(u64, u64, TraceOp<V>)], seeds: &[(String, PathMap<V>)], writers: &HashSet<usize>, cfg: &ReplayConfig, warnings: &mut Vec<String>) -> (HashMap<u64, usize>, Vec<String>) {
+    let mut slots: Vec<MapSlot> = seeds.iter().enumerate().map(|(idx, (label, _))| MapSlot { key: None, seed: Some(idx), label: label.clone(), live: vec![] }).collect();
+    let mut map_of: HashMap<u64, usize> = HashMap::new();
+    for (idx, (_, id, op)) in events.iter().enumerate() {
+        match op {
+            TraceOp::Created { root_prefix_path: rpp, .. } => {
+                let is_writer = writers.contains(&idx);
+                //A reused id is the same zipper, so it stays on its map
+                if let Some(&m) = map_of.get(id) {
+                    slots[m].live.retain(|(live_id, _, _)| live_id != id);
+                    slots[m].live.push((*id, rpp.clone(), is_writer));
+                    continue
+                }
+                //Putting the zipper on a map where it would overlap a live writer would break exclusivity
+                let fits = |slot: &MapSlot| !slot.live.iter().any(|(_, live_rpp, live_writer)| overlaps(live_rpp, rpp) && (is_writer || *live_writer));
+                let key = (rpp.len() >= cfg.prefix_len).then(|| rpp[..cfg.prefix_len].to_vec());
+                let seeded = slots.iter().position(|slot| {
+                    slot.seed.is_some_and(|seed| {
+                        let seed = &seeds[seed].1;
+                        seed.path_exists_at(rpp) || key.as_ref().is_some_and(|key| seed.path_exists_at(key))
+                    })
+                });
+                let shared = slots.iter().position(|slot| slot.seed.is_none() && key.is_some() && slot.key == key);
+                let m = match seeded.or(shared) {
+                    Some(m) if fits(&slots[m]) => m,
+                    candidate => {
+                        if let Some(m) = candidate {
+                            warnings.push(format!("z{id} would overlap a live writer on {}, so it was given its own map", slots[m].label));
+                        }
+                        let label = match &key {
+                            Some(key) => format!("map {} ({}…)", slots.len(), quote_path(key)),
+                            None => format!("map {} (z{id})", slots.len()),
+                        };
+                        slots.push(MapSlot { key: key.clone(), seed: None, label, live: vec![] });
+                        slots.len() - 1
+                    }
+                };
+                slots[m].live.push((*id, rpp.clone(), is_writer));
+                map_of.insert(*id, m);
+            },
+            TraceOp::Dropped => {
+                if let Some(&m) = map_of.get(id) {
+                    slots[m].live.retain(|(live_id, _, _)| live_id != id);
+                }
+            },
+            _ => {}
+        }
+    }
+    let labels = slots.into_iter().map(|slot| slot.label).collect();
+    (map_of, labels)
+}
+
+/// A replay zipper.  Zippers that perform any write op are replayed as write zippers
+enum Live<'h, V: ReplayValue> {
+    Read(ReadZipperTracked<'h, 'static, V>),
+    Write(WriteZipperTracked<'h, 'static, V>),
+}
+
+struct LiveZipper<'h, V: ReplayValue> {
+    z: Live<'h, V>,
+    map: usize,
+    root: Vec<u8>,
+}
+
+macro_rules! with_z {
+    ($live:expr, $z:ident => $body:expr) => {
+        match $live {
+            Live::Read($z) => $body,
+            Live::Write($z) => $body,
+        }
+    };
+}
+
+/// The source argument of a write op, resolved to something that can be passed to the op
+enum Src<'s, 'h, V: ReplayValue> {
+    Read(&'s ReadZipperTracked<'h, 'static, V>),
+    Write(&'s WriteZipperTracked<'h, 'static, V>),
+    Map(PathMap<V>),
+}
+
+macro_rules! with_src {
+    ($src:expr, $s:ident => $body:expr) => {
+        match $src {
+            Src::Read(z) => { let $s = z; $body },
+            Src::Write(z) => { let $s = z; $body },
+            Src::Map(map) => { let rz = map.read_zipper(); let $s = &rz; $body },
+        }
+    };
+}
+
+fn entries_map<V: ReplayValue>(entries: &[(Vec<u8>, V)]) -> PathMap<V> {
+    entries.iter().cloned().collect()
+}
+
+fn resolve_src<'s, 'h, V: ReplayValue>(src: &TraceSrc<V>, live: &'s HashMap<u64, LiveZipper<'h, V>>) -> Result<Src<'s, 'h, V>, String> {
+    match src {
+        TraceSrc::Unknown(entries) => Ok(Src::Map(entries_map(entries))),
+        TraceSrc::Traced(id) => match live.get(id).map(|lz| &lz.z) {
+            Some(Live::Read(z)) => Ok(Src::Read(z)),
+            Some(Live::Write(z)) => Ok(Src::Write(z)),
+            None => Err(format!("source z{id} isn't live")),
+        }
+    }
+}
+
+/// Gives a write zipper the default [ZipperIteration] methods, which replay needs because the original
+/// write zipper may have had them
+struct IterAdapter<'a, Z>(&'a mut Z);
+
+impl<Z: Zipper> Zipper for IterAdapter<'_, Z> {
+    fn path_exists(&self) -> bool { self.0.path_exists() }
+    fn is_val(&self) -> bool { self.0.is_val() }
+    fn child_count(&self) -> usize { self.0.child_count() }
+    fn child_mask(&self) -> ByteMask { self.0.child_mask() }
+}
+
+impl<Z: ZipperMoving> ZipperMoving for IterAdapter<'_, Z> {
+    fn depth(&self) -> usize { self.0.depth() }
+    fn focus_byte(&self) -> Option<u8> { self.0.focus_byte() }
+    fn val_count(&self) -> usize { self.0.val_count() }
+    fn descend_to<K: AsRef<[u8]>>(&mut self, k: K) { self.0.descend_to(k) }
+    fn ascend(&mut self, steps: usize) -> usize { self.0.ascend(steps) }
+    fn ascend_until(&mut self) -> usize { self.0.ascend_until() }
+    fn ascend_until_branch(&mut self) -> usize { self.0.ascend_until_branch() }
+}
+
+impl<Z: ZipperMoving> ZipperIteration for IterAdapter<'_, Z> {}
+
+/// Applies an op that only moves the zipper.  Returns `false` if `op` isn't such an op
+fn apply_move<V, Z: ZipperMoving + ZipperPath>(z: &mut Z, op: &TraceOp<V>) -> bool {
+    use TraceOp::*;
+    match op {
+        Reset => z.reset(),
+        DescendTo { path } => z.descend_to(path),
+        DescendToCheck { path } => { z.descend_to_check(path); },
+        DescendToExisting { path } => { z.descend_to_existing(path); },
+        DescendToVal { path } => { z.descend_to_val(path); },
+        DescendToByte { byte } => z.descend_to_byte(*byte),
+        DescendToExistingByte { byte } => { z.descend_to_existing_byte(*byte); },
+        DescendIndexedByte { idx } => { z.descend_indexed_byte(*idx); },
+        DescendFirstByte => { z.descend_first_byte(); },
+        DescendLastByte => { z.descend_last_byte(); },
+        DescendUntil => { z.descend_until(); },
+        DescendUntilMaxBytes { max_bytes } => { z.descend_until_max_bytes(*max_bytes); },
+        Ascend { steps } => { z.ascend(*steps); },
+        AscendByte => { z.ascend_byte(); },
+        AscendUntil => { z.ascend_until(); },
+        AscendUntilBranch => { z.ascend_until_branch(); },
+        ToNextSiblingByte => { z.to_next_sibling_byte(); },
+        ToPrevSiblingByte => { z.to_prev_sibling_byte(); },
+        ToNextStep => { z.to_next_step(); },
+        MoveToPath { path } => { z.move_to_path(path); },
+        _ => return false,
+    }
+    true
+}
+
+/// Applies an iteration op.  Returns `false` if `op` isn't one
+fn apply_iteration<V, Z: ZipperIteration>(z: &mut Z, op: &TraceOp<V>) -> bool {
+    use TraceOp::*;
+    match op {
+        ToNextVal | ToNextGetVal => { z.to_next_val(); },
+        DescendLastPath => { z.descend_last_path(); },
+        DescendFirstKPath { k } => { z.descend_first_k_path(*k); },
+        ToNextKPath { k } => { z.to_next_k_path(*k); },
+        _ => return false,
+    }
+    true
+}
+
+/// Applies a write op to `w`.  `live` holds the other live zippers, which may be sources
+fn apply_write<'h, V: ReplayValue>(w: &mut WriteZipperTracked<'h, 'static, V>, op: &TraceOp<V>, live: &mut HashMap<u64, LiveZipper<'h, V>>) -> Result<(), String> {
+    use TraceOp::*;
+    match op {
+        GetValMut | GetValOrSetMutWith | ZipperHead => {},
+        ValWritten { val } => { w.set_val(val.clone()); },
+        GetValOrSetMut { default } => { w.get_val_or_set_mut(default.clone()); },
+        SetVal { val } => { w.set_val(val.clone()); },
+        SetValAt { path, val } => { w.set_val_at(path, val.clone()); },
+        RemoveVal { prune } => { w.remove_val(*prune); },
+        Graft { src } => with_src!(resolve_src(src, live)?, s => w.graft(s)),
+        GraftSrcAt { src, path } => with_src!(resolve_src(src, live)?, s => w.graft_src_at(s, path)),
+        GraftMap { map } => w.graft_map(entries_map(map)),
+        GraftChildMaps { child_mask, maps, remove_unset } => w.graft_child_maps(*child_mask, maps.iter().map(|map| entries_map(map)), *remove_unset),
+        GraftMaskedBranches { src, child_mask, remove_unset } => with_src!(resolve_src(src, live)?, s => w.graft_masked_branches(s, *child_mask, *remove_unset)),
+        JoinInto { src } => { with_src!(resolve_src(src, live)?, s => w.join_into(s)); },
+        JoinMapInto { map } => { w.join_map_into(entries_map(map)); },
+        JoinIntoTake { src, prune } => {
+            //The source must be taken from too, so it can't be shared
+            if let TraceSrc::Traced(src_id) = src {
+                if let Some(mut src_lz) = live.remove(src_id) {
+                    let result = match &mut src_lz.z {
+                        Live::Write(src_w) => { w.join_into_take(src_w, *prune); Ok(()) },
+                        Live::Read(_) => Err(format!("join_into_take source z{src_id} isn't a write zipper")),
+                    };
+                    live.insert(*src_id, src_lz);
+                    return result
+                }
+            }
+            with_src!(resolve_src(src, live)?, s => w.join_into(s));
+        },
+        JoinKPathInto { byte_cnt, prune } => { w.join_k_path_into(*byte_cnt, *prune); },
+        MeetKPathInto { byte_cnt, prune } => { w.meet_k_path_into(*byte_cnt, *prune); },
+        InsertPrefix { prefix } => { w.insert_prefix(prefix); },
+        RemovePrefix { n } => { w.remove_prefix(*n); },
+        MeetInto { src, prune } => { with_src!(resolve_src(src, live)?, s => w.meet_into(s, *prune)); },
+        Meet2 { src_a, src_b } => {
+            let src_b = resolve_src(src_b, live)?;
+            with_src!(resolve_src(src_a, live)?, a => with_src!(src_b, b => { w.meet_2(a, b); }));
+        },
+        SubtractInto { src, prune } => { with_src!(resolve_src(src, live)?, s => w.subtract_into(s, *prune)); },
+        Restrict { src } => { with_src!(resolve_src(src, live)?, s => w.restrict(s)); },
+        Restricting { src } => { with_src!(resolve_src(src, live)?, s => w.restricting(s)); },
+        TakeMap { prune } => { w.take_map(*prune); },
+        RemoveBranches { prune } => { w.remove_branches(*prune); },
+        RemoveSubtrie { prune } => { w.remove_subtrie(*prune); },
+        RemoveUnmaskedBranches { mask, prune } => w.remove_unmasked_branches(*mask, *prune),
+        CreatePath => { w.create_path(); },
+        PrunePath => { w.prune_path(); },
+        PruneAscend => { w.prune_ascend(); },
+        _ => {},
+    }
+    Ok(())
+}
+
+/// Returns the index of the `Created` event of each zipper lifetime that performs a write.  Write and read zippers
+/// are replayed differently, and an id may be reused, so this is decided per lifetime rather than per id
+fn writer_lifetimes<V>(events: &[(u64, u64, TraceOp<V>)]) -> HashSet<usize> {
+    let mut current: HashMap<u64, usize> = HashMap::new();
+    let mut writers = HashSet::new();
+    for (idx, (_, id, op)) in events.iter().enumerate() {
+        if let TraceOp::Created { .. } = op {
+            current.insert(*id, idx);
+        }
+        if is_write_op(op) {
+            writers.extend(current.get(id));
+        }
+        //A join_into_take source has its focus taken, so it's a writer too
+        if let TraceOp::JoinIntoTake { src: TraceSrc::Traced(src_id), .. } = op {
+            writers.extend(current.get(src_id));
+        }
+    }
+    writers
+}
+
+/// Replays `events`, which are `(seq, zipper_id, op)` as returned by [decode_trace](pathmap::utils::debug::zipper_tracing::decode_trace),
+/// and records a frame after each one
+///
+/// `seeds` are the initial contents of maps loaded from files, in priority order.  When a zipper's
+/// `root_prefix_path` is compatible with more than one seed, the first one wins
+pub fn replay<V: ReplayValue>(events: &[(u64, u64, TraceOp<V>)], seeds: Vec<(String, PathMap<V>)>, cfg: &ReplayConfig) -> Replay<V> {
+    let mut warnings = Vec::new();
+    let writers = writer_lifetimes(events);
+    let (map_of, map_labels) = assign_maps(events, &seeds, &writers, cfg, &mut warnings);
+    let map_count = map_labels.len();
+    let mut shown: Vec<bool> = (0..map_count).map(|m| m < seeds.len()).collect();
+    let mut maps: Vec<PathMap<V>> = seeds.into_iter().map(|(_, map)| map).collect();
+    maps.resize_with(map_count, PathMap::new);
+    //The real maps are only reachable through the replay zippers, which can't see outside their regions, so each
+    // map is mirrored here.  Only writers change a map, so refreshing each live writer's region keeps the mirror exact
+    let mut mirrors = maps.clone();
+
+    let mut frames = Vec::with_capacity(events.len() + 1);
+    {
+        let heads: Vec<_> = maps.iter_mut().map(|map| map.zipper_head()).collect();
+        let mut live: HashMap<u64, LiveZipper<'_, V>> = HashMap::new();
+        frames.push(Frame { event: None, caption: "start".to_string(), actor: None, sources: vec![], maps: capture(&mut live, &mut mirrors, &shown) });
+        for (idx, (seq, id, op)) in events.iter().enumerate() {
+            let mut caption = format!("z{id}.{}", call_text(op));
+            let result = step(*id, op, &heads, &map_of, writers.contains(&idx), &mut live);
+            if let Err(err) = result {
+                caption.push_str(&format!("  ⚠ {err}"));
+                warnings.push(format!("event {seq} (z{id}): {err}"));
+            }
+            if let Some(&m) = map_of.get(id) {
+                shown[m] = true;
+            }
+            frames.push(Frame { event: Some(*seq), caption, actor: Some(*id), sources: traced_sources(op), maps: capture(&mut live, &mut mirrors, &shown) });
+        }
+        //The zippers borrow the heads, so they must go first
+        drop(live);
+    }
+    Replay { maps, map_labels, frames, warnings }
+}
+
+/// Applies one event.  `writer` says whether a zipper being created will write during its life
+fn step<'h, V: ReplayValue>(id: u64, op: &TraceOp<V>, heads: &'h [ZipperHead<'_, '_, V>], map_of: &HashMap<u64, usize>, writer: bool, live: &mut HashMap<u64, LiveZipper<'h, V>>) -> Result<(), String> {
+    match op {
+        TraceOp::Created { root_prefix_path, path, .. } => {
+            live.remove(&id);
+            let map = map_of[&id];
+            //SAFETY: The traced program obeyed PathMap's exclusivity rules, and map assignment never puts
+            // a zipper where it would overlap a live writer, so these zippers can't conflict
+            let mut z = if writer {
+                Live::Write(unsafe { heads[map].write_zipper_at_exclusive_path_unchecked(root_prefix_path) })
+            } else {
+                Live::Read(unsafe { heads[map].read_zipper_at_path_unchecked(root_prefix_path) })
+            };
+            with_z!(&mut z, z => z.descend_to(path));
+            live.insert(id, LiveZipper { z, map, root: root_prefix_path.clone() });
+        },
+        TraceOp::Dropped => { live.remove(&id); },
+        _ => {
+            let Some(mut lz) = live.remove(&id) else {
+                return Err("zipper isn't live".to_string())
+            };
+            let result = match &mut lz.z {
+                Live::Read(r) => {
+                    if !apply_move(r, op) && !apply_iteration(r, op) && is_write_op(op) {
+                        Err("write op on a read zipper".to_string())
+                    } else {
+                        Ok(())
+                    }
+                },
+                Live::Write(w) => {
+                    if apply_move(w, op) || apply_iteration(&mut IterAdapter(w), op) {
+                        Ok(())
+                    } else {
+                        apply_write(w, op, live)
+                    }
+                }
+            };
+            live.insert(id, lz);
+            result?;
+        }
+    }
+    Ok(())
+}
+
+/// Builds the visible part of every shown map
+fn capture<V: ReplayValue>(live: &mut HashMap<u64, LiveZipper<'_, V>>, mirrors: &mut [PathMap<V>], shown: &[bool]) -> Vec<MapView> {
+    let mut views: Vec<MapView> = (0..mirrors.len()).map(|map| MapView { map, nodes: BTreeMap::new(), zippers: vec![] }).collect();
+    let mut ids: Vec<u64> = live.keys().copied().collect();
+    ids.sort();
+    for id in ids {
+        let lz = live.get_mut(&id).unwrap();
+        let (root_exists, rel, snapshot) = with_z!(&mut lz.z, z => snapshot(z));
+        let writer = matches!(lz.z, Live::Write(_));
+        if writer {
+            mirrors[lz.map].write_zipper_at_path(&lz.root).graft_map(snapshot.clone());
+        }
+        let view = &mut views[lz.map];
+        add_zipper_region(&mut view.nodes, &lz.root, root_exists, &rel, &snapshot);
+        let mut focus = lz.root.clone();
+        focus.extend_from_slice(&rel);
+        view.zippers.push(ZipperView { id, root: lz.root.clone(), focus, writer });
+    }
+    views.retain(|view| shown[view.map]);
+    for view in &mut views {
+        add_context(&mut view.nodes, &mirrors[view.map]);
+        let mut shown_children: HashMap<Vec<u8>, usize> = HashMap::new();
+        for path in view.nodes.keys().filter(|path| !path.is_empty()) {
+            *shown_children.entry(path[..path.len() - 1].to_vec()).or_default() += 1;
+        }
+        for (path, node) in view.nodes.iter_mut() {
+            node.hidden = node.child_count.saturating_sub(shown_children.get(path).copied().unwrap_or(0));
+            node.accessible = view.zippers.iter().any(|z| path.starts_with(&z.root));
+        }
+    }
+    views
+}
+
+/// Adds the rest of the map, nearest the nodes already shown first, until the map has [MAP_NODE_BUDGET] nodes
+fn add_context<V: ReplayValue>(nodes: &mut BTreeMap<Vec<u8>, NodeView>, mirror: &PathMap<V>) {
+    nodes.entry(vec![]).or_default().exists = true;
+    let mut frontier: Vec<Vec<u8>> = nodes.iter().filter(|(_, node)| node.exists).map(|(path, _)| path.clone()).collect();
+    frontier.sort_by_key(|path| path.len());
+    let mut queue: VecDeque<Vec<u8>> = frontier.into();
+    while let Some(path) = queue.pop_front() {
+        let rz = mirror.read_zipper_at_path(&path);
+        if !rz.path_exists() {
+            continue
+        }
+        let node = nodes.get_mut(&path).unwrap();
+        node.child_count = node.child_count.max(rz.child_count());
+        if node.val.is_none() {
+            node.val = rz.val().and_then(ReplayValue::display);
+        }
+        for byte in rz.child_mask().iter().take(MAX_CHILDREN) {
+            let mut child = path.clone();
+            child.push(byte);
+            if nodes.contains_key(&child) {
+                continue
+            }
+            if nodes.len() >= MAP_NODE_BUDGET {
+                return
+            }
+            let child_rz = mirror.read_zipper_at_path(&child);
+            nodes.insert(child.clone(), NodeView { exists: true, val: child_rz.val().and_then(ReplayValue::display), child_count: child_rz.child_count(), ..Default::default() });
+            queue.push_back(child);
+        }
+    }
+}
+
+/// Captures the trie below a zipper's root, without disturbing the zipper.  Returns whether the root
+/// exists, the focus relative to the root, and the trie
+fn snapshot<V: ReplayValue, Z: ZipperMoving + ZipperPath + ZipperInfallibleSubtries<V>>(z: &mut Z) -> (bool, Vec<u8>, PathMap<V>) {
+    let rel = z.path().to_vec();
+    z.reset();
+    let root_exists = z.path_exists();
+    let snapshot = z.make_map();
+    z.descend_to(&rel);
+    (root_exists, rel, snapshot)
+}
+
+fn add_node(nodes: &mut BTreeMap<Vec<u8>, NodeView>, path: &[u8], exists: bool, val: Option<String>, child_count: usize) {
+    let node = nodes.entry(path.to_vec()).or_default();
+    node.exists |= exists;
+    node.child_count = node.child_count.max(child_count);
+    if node.val.is_none() {
+        node.val = val;
+    }
+}
+
+/// Adds the nodes on the zipper's path, their children, and the subtrie below the focus
+fn add_zipper_region<V: ReplayValue>(nodes: &mut BTreeMap<Vec<u8>, NodeView>, root: &[u8], root_exists: bool, rel: &[u8], snapshot: &PathMap<V>) {
+    for len in 0..root.len() {
+        add_node(nodes, &root[..len], root_exists, None, 0);
+    }
+    let mut rz = snapshot.read_zipper();
+    let mut path = root.to_vec();
+    let mut existing = 0;
+    while root_exists && rz.path_exists() {
+        let at_focus = existing == rel.len();
+        add_node(nodes, &path, true, rz.val().and_then(ReplayValue::display), rz.child_count());
+        add_children(nodes, &mut rz, &mut path, if at_focus { FOCUS_DEPTH } else { 1 });
+        if at_focus {
+            return
+        }
+        rz.descend_to_byte(rel[existing]);
+        path.push(rel[existing]);
+        existing += 1;
+    }
+    //The rest of the path doesn't exist in the trie
+    add_node(nodes, &path, false, None, 0);
+    for &byte in &rel[existing..] {
+        path.push(byte);
+        add_node(nodes, &path, false, None, 0);
+    }
+}
+
+fn add_children<V: ReplayValue, Z: ZipperMoving + ZipperValues<V>>(nodes: &mut BTreeMap<Vec<u8>, NodeView>, rz: &mut Z, path: &mut Vec<u8>, depth: usize) {
+    let mask = rz.child_mask();
+    for (idx, byte) in mask.iter().enumerate() {
+        if idx == MAX_CHILDREN {
+            break
+        }
+        rz.descend_to_byte(byte);
+        path.push(byte);
+        add_node(nodes, path, true, rz.val().and_then(ReplayValue::display), rz.child_count());
+        if depth > 1 {
+            add_children(nodes, rz, path, depth - 1);
+        }
+        path.pop();
+        rz.ascend_byte();
+    }
+}
+
+/// Renders a path as a quoted string, escaping bytes that aren't printable ascii
+pub fn quote_path(path: &[u8]) -> String {
+    let mut out = String::from("\"");
+    for &byte in path {
+        match byte {
+            b'"' => out.push_str("\\\""),
+            b'\\' => out.push_str("\\\\"),
+            0x20..=0x7e => out.push(byte as char),
+            _ => out.push_str(&format!("\\x{byte:02x}")),
+        }
+    }
+    out.push('"');
+    out
+}
+
+fn quote_byte(byte: u8) -> String {
+    let quoted = quote_path(&[byte]);
+    format!("'{}'", &quoted[1..quoted.len() - 1])
+}
+
+fn val_text<V: ReplayValue>(val: &V) -> String {
+    val.display().unwrap_or_else(|| format!("{val:?}"))
+}
+
+fn mask_text(mask: &ByteMask) -> String {
+    let bytes: Vec<String> = mask.iter().map(quote_byte).collect();
+    format!("{{{}}}", bytes.join(", "))
+}
+
+fn src_text<V>(src: &TraceSrc<V>) -> String {
+    match src {
+        TraceSrc::Traced(id) => format!("z{id}"),
+        TraceSrc::Unknown(entries) => format!("<untraced: {} values>", entries.len()),
+    }
+}
+
+fn map_text<V>(entries: &[(Vec<u8>, V)]) -> String {
+    format!("<map: {} values>", entries.len())
+}
+
+/// Renders an op as the method call it records
+fn call_text<V: ReplayValue>(op: &TraceOp<V>) -> String {
+    use TraceOp::*;
+    match op {
+        Created { type_name, root_prefix_path, path } => {
+            let short_name = type_name.split('<').next().unwrap_or(type_name).rsplit("::").next().unwrap_or(type_name);
+            let mut text = format!("created({short_name}, root: {}", quote_path(root_prefix_path));
+            if !path.is_empty() {
+                text.push_str(&format!(", focus: {}", quote_path(path)));
+            }
+            text.push(')');
+            text
+        },
+        Dropped => "drop()".to_string(),
+        ValWritten { val } => format!("<value written through &mut: {}>", val_text(val)),
+        PathExists => "path_exists()".to_string(),
+        IsVal => "is_val()".to_string(),
+        ChildCount => "child_count()".to_string(),
+        ChildMask => "child_mask()".to_string(),
+        Val => "val()".to_string(),
+        ValAt { path } => format!("val_at({})", quote_path(path)),
+        NativeSubtries => "native_subtries()".to_string(),
+        TryMakeMap => "try_make_map()".to_string(),
+        TrieRef => "trie_ref()".to_string(),
+        Depth => "depth()".to_string(),
+        AtRoot => "at_root()".to_string(),
+        FocusByte => "focus_byte()".to_string(),
+        Reset => "reset()".to_string(),
+        ValCount => "val_count()".to_string(),
+        DescendTo { path } => format!("descend_to({})", quote_path(path)),
+        DescendToCheck { path } => format!("descend_to_check({})", quote_path(path)),
+        DescendToExisting { path } => format!("descend_to_existing({})", quote_path(path)),
+        DescendToVal { path } => format!("descend_to_val({})", quote_path(path)),
+        DescendToByte { byte } => format!("descend_to_byte({})", quote_byte(*byte)),
+        DescendToExistingByte { byte } => format!("descend_to_existing_byte({})", quote_byte(*byte)),
+        DescendIndexedByte { idx } => format!("descend_indexed_byte({idx})"),
+        DescendFirstByte => "descend_first_byte()".to_string(),
+        DescendLastByte => "descend_last_byte()".to_string(),
+        DescendUntil => "descend_until()".to_string(),
+        DescendUntilMaxBytes { max_bytes } => format!("descend_until_max_bytes({max_bytes})"),
+        Ascend { steps } => format!("ascend({steps})"),
+        AscendByte => "ascend_byte()".to_string(),
+        AscendUntil => "ascend_until()".to_string(),
+        AscendUntilBranch => "ascend_until_branch()".to_string(),
+        ToNextSiblingByte => "to_next_sibling_byte()".to_string(),
+        ToPrevSiblingByte => "to_prev_sibling_byte()".to_string(),
+        ToNextStep => "to_next_step()".to_string(),
+        ToNextVal => "to_next_val()".to_string(),
+        DescendLastPath => "descend_last_path()".to_string(),
+        DescendFirstKPath { k } => format!("descend_first_k_path({k})"),
+        ToNextKPath { k } => format!("to_next_k_path({k})"),
+        Path => "path()".to_string(),
+        MoveToPath { path } => format!("move_to_path({})", quote_path(path)),
+        OriginPath => "origin_path()".to_string(),
+        RootPrefixPath => "root_prefix_path()".to_string(),
+        GetVal => "get_val()".to_string(),
+        GetValAt { path } => format!("get_val_at({})", quote_path(path)),
+        ToNextGetVal => "to_next_get_val()".to_string(),
+        MakeMap => "make_map()".to_string(),
+        GetTrieRef => "get_trie_ref()".to_string(),
+        FocusFactor => "focus_factor()".to_string(),
+        FactorCount => "factor_count()".to_string(),
+        PathIndices => "path_indices()".to_string(),
+        GetValMut => "get_val_mut()".to_string(),
+        GetValOrSetMut { default } => format!("get_val_or_set_mut({})", val_text(default)),
+        GetValOrSetMutWith => "get_val_or_set_mut_with(<closure>)".to_string(),
+        SetVal { val } => format!("set_val({})", val_text(val)),
+        SetValAt { path, val } => format!("set_val_at({}, {})", quote_path(path), val_text(val)),
+        RemoveVal { prune } => format!("remove_val({prune})"),
+        ZipperHead => "zipper_head()".to_string(),
+        Graft { src } => format!("graft({})", src_text(src)),
+        GraftSrcAt { src, path } => format!("graft_src_at({}, {})", src_text(src), quote_path(path)),
+        GraftMap { map } => format!("graft_map({})", map_text(map)),
+        GraftChildMaps { child_mask, maps, remove_unset } => format!("graft_child_maps({}, <{} maps>, {remove_unset})", mask_text(child_mask), maps.len()),
+        GraftMaskedBranches { src, child_mask, remove_unset } => format!("graft_masked_branches({}, {}, {remove_unset})", src_text(src), mask_text(child_mask)),
+        JoinInto { src } => format!("join_into({})", src_text(src)),
+        JoinMapInto { map } => format!("join_map_into({})", map_text(map)),
+        JoinIntoTake { src, prune } => format!("join_into_take({}, {prune})", src_text(src)),
+        JoinKPathInto { byte_cnt, prune } => format!("join_k_path_into({byte_cnt}, {prune})"),
+        MeetKPathInto { byte_cnt, prune } => format!("meet_k_path_into({byte_cnt}, {prune})"),
+        InsertPrefix { prefix } => format!("insert_prefix({})", quote_path(prefix)),
+        RemovePrefix { n } => format!("remove_prefix({n})"),
+        MeetInto { src, prune } => format!("meet_into({}, {prune})", src_text(src)),
+        Meet2 { src_a, src_b } => format!("meet_2({}, {})", src_text(src_a), src_text(src_b)),
+        SubtractInto { src, prune } => format!("subtract_into({}, {prune})", src_text(src)),
+        Restrict { src } => format!("restrict({})", src_text(src)),
+        Restricting { src } => format!("restricting({})", src_text(src)),
+        TakeMap { prune } => format!("take_map({prune})"),
+        RemoveBranches { prune } => format!("remove_branches({prune})"),
+        RemoveSubtrie { prune } => format!("remove_subtrie({prune})"),
+        RemoveUnmaskedBranches { mask, prune } => format!("remove_unmasked_branches({}, {prune})", mask_text(mask)),
+        CreatePath => "create_path()".to_string(),
+        PrunePath => "prune_path()".to_string(),
+        PruneAscend => "prune_ascend()".to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn created(id: u64, rpp: &[u8]) -> (u64, TraceOp<u64>) {
+        (id, TraceOp::Created { type_name: "Z".to_string(), root_prefix_path: rpp.to_vec(), path: vec![] })
+    }
+
+    #[test]
+    fn map_assignment() {
+        let events = vec![
+            created(1, b"ab/x"),
+            created(2, b"ab/y"),
+            //Shares "ab" but overlaps writer 1, so it can't be on 1's map
+            created(3, b"ab/x/deep"),
+            created(4, b"zz"),
+            created(5, b"a"),
+            created(6, b""),
+            (1, TraceOp::SetVal { val: 1 }),
+        ];
+        let events: Vec<_> = events.into_iter().enumerate().map(|(seq, (id, op))| (seq as u64, id, op)).collect();
+        //Zipper 1's lifetime begins at event 0
+        let writers = HashSet::from([0]);
+        let mut warnings = vec![];
+        let (map_of, labels) = assign_maps(&events, &[], &writers, &ReplayConfig::default(), &mut warnings);
+        assert_eq!(map_of[&1], map_of[&2]);
+        assert_ne!(map_of[&3], map_of[&1]);
+        assert_eq!(warnings.len(), 1);
+        let distinct: HashSet<usize> = [1, 3, 4, 5, 6].iter().map(|id| map_of[id]).collect();
+        assert_eq!(distinct.len(), 5);
+        assert_eq!(labels.len(), 5);
+    }
+
+    #[test]
+    fn call_text_matches_methods() {
+        assert_eq!(call_text(&TraceOp::<u64>::DescendTo { path: b"hi\n".to_vec() }), "descend_to(\"hi\\x0a\")");
+        assert_eq!(call_text(&TraceOp::<u64>::DescendToByte { byte: b'h' }), "descend_to_byte('h')");
+        assert_eq!(call_text(&TraceOp::<u64>::SetValAt { path: b"x".to_vec(), val: 3 }), "set_val_at(\"x\", 3)");
+        assert_eq!(call_text(&TraceOp::<u64>::Meet2 { src_a: TraceSrc::Traced(3), src_b: TraceSrc::Unknown(vec![]) }), "meet_2(z3, <untraced: 0 values>)");
+    }
+}
diff --git a/tools/tracer/tests/aunt_kg.ann.json b/tools/tracer/tests/aunt_kg.ann.json
new file mode 100644
index 00000000..fa39a90d
--- /dev/null
+++ b/tools/tracer/tests/aunt_kg.ann.json
@@ -0,0 +1,47 @@
+{
+  "comment": "Annotations for the aunt_kg test's animation.  Event numbers are the trace's seq numbers",
+  "ranges": [
+    { "events": [0, 88], "speed": 4, "caption": "Invert the \"parent\" paths to create the \"child\" subtrie" },
+    { "events": [89, 95], "caption": "person = female ∪ male" },
+    { "events": [96, 101], "caption": "Every person's parents: graft the child subtrie, then restrict it to people" },
+    { "events": [102, 168], "speed": 3, "caption": "mother(p) = parents(p) ∩ female, as one meet_2 per person" },
+    { "events": [169, 275], "speed": 3, "caption": "sister(p) = (children of p's parents ∩ female) − p" },
+    { "events": [276, 375], "speed": 3, "caption": "aunt(p) = (children of p's grandparents − p's parents) ∩ female" },
+
+    { "comment": "Slow down for jon, who has two parents, and zoom in on jon's aunts as they're computed",
+      "events": [339, 343], "speed": 1, "caption": "aunt(jon)" },
+    { "events": [344, 350], "speed": 0.5, "hold": 1.5, "zoom": { "path": "out/aunt/jon/", "max_scale": 1.25 } },
+    { "events": 344, "caption": "aunt(jon): start from jon's parents, bob and eve" },
+    { "events": 345, "caption": "aunt(jon): fill in the parents of each of jon's parents" },
+    { "events": 346, "caption": "aunt(jon): drop the parent symbol, leaving jon's grandparents, ann and gus" },
+    { "events": 347, "caption": "aunt(jon): fill in each grandparent's children" },
+    { "events": 348, "caption": "aunt(jon): drop the grandparent symbol, leaving the grandparents' children" },
+    { "events": 349, "caption": "aunt(jon): subtract jon's parents" },
+    { "events": 350, "caption": "aunt(jon): keep the women — jon's aunts are cat, dee and ivy" },
+
+    { "comment": "Event 375 is the last before the aunt writer is dropped, after which the result is greyed out",
+      "events": [375, 381], "zoom": { "path": "out/aunt/" }, "caption": "The result: every person's aunts" },
+    { "events": 375, "hold": 4 }
+  ],
+  "labels": [
+    { "path": "kg/parent/", "text": "parent index" },
+    { "path": "kg/child/", "text": "child index" },
+    { "path": "kg/female/", "text": "female" },
+    { "path": "kg/male/", "text": "male" },
+    { "path": "kg/person/", "text": "person" },
+    { "path": "out/parents/", "text": "parents" },
+    { "path": "out/mother/", "text": "mother" },
+    { "path": "out/sister/", "text": "sister" },
+    { "path": "out/aunt/", "text": "aunt" }
+  ],
+  "marks": [
+    { "event": 0, "label": "child index" },
+    { "event": 89, "label": "person index" },
+    { "event": 96, "label": "parents" },
+    { "event": 102, "label": "mothers" },
+    { "event": 169, "label": "sisters" },
+    { "event": 276, "label": "aunts" },
+    { "event": 339, "label": "aunt(jon)" },
+    { "event": 375, "label": "result" }
+  ]
+}
diff --git a/tools/tracer/tests/visualize.rs b/tools/tracer/tests/visualize.rs
new file mode 100644
index 00000000..2d5ad7a1
--- /dev/null
+++ b/tools/tracer/tests/visualize.rs
@@ -0,0 +1,331 @@
+//! Traces some small programs, replays them, and checks the replay matches what really happened.  Each
+//! test writes its animation to the test's temporary directory.  Run with `--nocapture` to see the paths
+
+use std::io::{self, Write};
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+
+use pathmap::PathMap;
+use pathmap::arena_compact::ArenaCompactTree;
+use pathmap::utils::debug::TraceZipper;
+use pathmap::utils::debug::zipper_tracing::{self, decode_trace};
+use pathmap::zipper::*;
+use tracer::{render_html, replay, Annotations, Replay, ReplayConfig};
+
+/// The trace is global, so tests that use it must not overlap
+static TRACE_LOCK: Mutex<()> = Mutex::new(());
+
+#[derive(Clone, Default)]
+struct SharedBuf(Arc<Mutex<Vec<u8>>>);
+
+impl Write for SharedBuf {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.lock().unwrap().extend_from_slice(buf); Ok(buf.len()) }
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+/// Runs `f` with a trace open, and returns the trace
+fn traced(f: impl FnOnce()) -> Vec<u8> {
+    let _lock = TRACE_LOCK.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+    let buf = SharedBuf::default();
+    zipper_tracing::open::<u64>(buf.clone()).unwrap();
+    f();
+    zipper_tracing::close().unwrap();
+    let bytes = buf.0.lock().unwrap().clone();
+    bytes
+}
+
+fn out_dir() -> PathBuf {
+    PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("tracer")
+}
+
+/// Replays the trace, and writes it as `name.trace` and its animation as `name.html`, with the annotations
+/// in `tests/name.ann.json` if there are any
+fn replay_and_render(name: &str, trace: &[u8], seeds: Vec<(String, PathMap<u64>)>) -> Replay<u64> {
+    let events = decode_trace::<u64>(trace).unwrap();
+    let replay = replay(&events, seeds, &ReplayConfig::default());
+    assert!(replay.warnings.is_empty(), "{:?}", replay.warnings);
+    std::fs::create_dir_all(out_dir()).unwrap();
+    std::fs::write(out_dir().join(format!("{name}.trace")), trace).unwrap();
+    let path = out_dir().join(format!("{name}.html"));
+    let ann_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join(format!("{name}.ann.json"));
+    let ann = ann_path.exists().then(|| Annotations::from_json(&std::fs::read_to_string(&ann_path).unwrap()).unwrap());
+    std::fs::write(&path, render_html(&replay, name, ann.as_ref()).unwrap()).unwrap();
+    println!("{name}: {}", path.display());
+    replay
+}
+
+fn entries(map: &PathMap<u64>) -> Vec<(Vec<u8>, u64)> {
+    map.iter().map(|(path, val)| (path, *val)).collect()
+}
+
+#[test]
+fn one_zipper_assembles_paths() {
+    let mut map = PathMap::<u64>::new();
+    let trace = traced(|| {
+        let mut wz = TraceZipper::new(1, map.write_zipper());
+        //The zipper's path runs past the trie until a value is set at the end of it
+        for &byte in b"hello" {
+            wz.descend_to_byte(byte);
+        }
+        wz.set_val(1);
+        wz.ascend(2);
+        wz.descend_to_byte(b'p');
+        wz.set_val(2);
+        wz.ascend(1);
+        wz.descend_to(b"icopter");
+        wz.set_val(3);
+        wz.reset();
+        wz.descend_to(b"hi");
+        wz.set_val(4);
+        wz.ascend(1);
+        wz.descend_to(b"el");
+        //Removes "help", "hello", and "helicopter"
+        wz.remove_branches(true);
+        wz.reset();
+    });
+    let replay = replay_and_render("one_zipper", &trace, vec![]);
+    assert_eq!(replay.maps.len(), 1);
+    assert_eq!(entries(&replay.maps[0]), entries(&map));
+    assert_eq!(entries(&map), vec![(b"hi".to_vec(), 4)]);
+
+    //Partway through descending "hello", "hel" exists only as the zipper's path
+    let frame = &replay.frames[4];
+    let nodes = &frame.maps[0].nodes;
+    assert!(!nodes[&b"hel"[..]].exists);
+    assert_eq!(frame.maps[0].zippers[0].focus, b"hel");
+    //Once the value is set, the whole path exists
+    let frame = &replay.frames[7];
+    assert!(frame.maps[0].nodes[&b"hello"[..]].exists);
+    assert_eq!(frame.maps[0].nodes[&b"hello"[..]].val.as_deref(), Some("1"));
+}
+
+#[test]
+fn two_zipper_dance() {
+    let mut map = PathMap::<u64>::new();
+    let trace = traced(|| {
+        let zh = map.zipper_head();
+        let mut a = TraceZipper::new(1, zh.write_zipper_at_exclusive_path(b"ab/x/").unwrap());
+        let mut b = TraceZipper::new(2, zh.write_zipper_at_exclusive_path(b"ab/y/").unwrap());
+        //The two writers take turns building words in their own regions
+        for (val, (a_word, b_word)) in [("cat", "dog"), ("car", "dot"), ("cart", "do")].into_iter().enumerate() {
+            a.descend_to(a_word);
+            a.set_val(val as u64);
+            a.reset();
+            b.descend_to(b_word);
+            b.set_val(10 + val as u64);
+            b.reset();
+        }
+        drop(b);
+        //A reader walks the values the second writer left behind
+        let mut r = TraceZipper::new(3, zh.read_zipper_at_path(b"ab/y/").unwrap());
+        while r.to_next_val() {}
+        r.reset();
+        r.descend_to(b"do");
+        //The first writer grafts a copy of what the reader sees
+        a.descend_to(b"copy/");
+        a.graft(&r);
+        drop(r);
+        drop(a);
+    });
+    let replay = replay_and_render("two_zipper_dance", &trace, vec![]);
+    //Both writers' roots start with "ab", so they share a map
+    assert_eq!(replay.maps.len(), 1);
+    assert_eq!(entries(&replay.maps[0]), entries(&map));
+    assert_eq!(map.get(b"ab/x/copy/g"), Some(&10));
+    let graft = replay.frames.iter().find(|frame| frame.caption.contains(".graft(")).unwrap();
+    assert_eq!(graft.sources, vec![3]);
+    //After z2 is dropped, what it wrote is still shown, though no zipper can reach it
+    let dropped = replay.frames.iter().find(|frame| frame.caption == "z2.drop()").unwrap();
+    let dog = &dropped.maps[0].nodes[&b"ab/y/dog"[..]];
+    assert!(dog.exists && !dog.accessible);
+    assert_eq!(dog.val.as_deref(), Some("10"));
+    assert!(dropped.maps[0].nodes[&b"ab/x/"[..]].accessible);
+}
+
+#[test]
+fn act_seeded_replay() {
+    let mut map: PathMap<u64> = [("apple", 1), ("apricot", 2), ("banana", 3), ("band", 4)].into_iter().collect();
+    std::fs::create_dir_all(out_dir()).unwrap();
+    let act_path = out_dir().join("seed.act");
+    ArenaCompactTree::dump_from_zipper(map.read_zipper(), |val: &u64| *val, &act_path).unwrap();
+    let trace = traced(|| {
+        let mut rz = TraceZipper::new(1, map.read_zipper());
+        while rz.to_next_val() {}
+        drop(rz);
+        let mut wz = TraceZipper::new(2, map.write_zipper());
+        wz.descend_to(b"ban");
+        wz.remove_branches(true);
+        wz.reset();
+        wz.descend_to(b"ap");
+        wz.descend_until();
+    });
+    let seed = tracer::load_act::<u64>(&act_path).unwrap();
+    let replay = replay_and_render("act_seeded", &trace, vec![("seed.act".to_string(), seed)]);
+    //Both zippers are at the root, which every seed contains, so both are on the seeded map
+    assert_eq!(replay.maps.len(), 1);
+    assert_eq!(entries(&replay.maps[0]), entries(&map));
+    //The reader sees the seeded contents
+    assert!(replay.frames[2].maps[0].nodes[&b"ap"[..]].exists);
+}
+
+#[test]
+fn wide_trie() {
+    let mut map = PathMap::<u64>::new();
+    let trace = traced(|| {
+        //More children per node than are shown
+        let mut wz = TraceZipper::new(1, map.write_zipper());
+        for (idx, first) in (b'a'..=b'z').enumerate() {
+            for second in b"xyz" {
+                wz.set_val_at([first, *second], idx as u64);
+            }
+        }
+        drop(wz);
+        //Zippers at the root are on separate maps unless they reuse an id, so the reader reuses the writer's id
+        let mut rz = TraceZipper::new(1, map.read_zipper());
+        for _ in 0..4 {
+            rz.to_next_val();
+        }
+        rz.reset();
+        rz.descend_to(b"q");
+    });
+    let replay = replay_and_render("wide_trie", &trace, vec![]);
+    assert_eq!(replay.maps.len(), 1);
+    assert_eq!(entries(&replay.maps[0]), entries(&map));
+    //The root has 26 children, but only 12 are shown.  The reader at "q" adds one more
+    let last = replay.frames.iter().rev().find(|frame| frame.caption == "z1.descend_to(\"q\")").unwrap();
+    assert_eq!(last.maps[0].nodes[&b""[..]].hidden, 26 - 13);
+    assert!(!last.maps[0].zippers[0].writer);
+}
+
+/// A small version of the aunt query from MORK's aunt-kg benchmark.  Names are 3 bytes plus a separator,
+/// so dropping the leading symbol of every path below a zipper is `join_k_path_into(4)`
+#[test]
+fn aunt_kg() {
+    const PARENTS: [(&str, &str); 12] = [
+        ("ann", "bob"), ("ann", "cat"), ("ann", "dee"), ("gus", "eve"), ("gus", "hal"), ("gus", "ivy"),
+        ("bob", "jon"), ("bob", "kim"), ("eve", "jon"), ("eve", "kim"), ("dee", "lou"), ("hal", "max"),
+    ];
+    //lou's gender isn't recorded, so lou isn't a person
+    const FEMALE: [&str; 6] = ["ann", "cat", "dee", "eve", "ivy", "kim"];
+    const MALE: [&str; 5] = ["bob", "gus", "hal", "jon", "max"];
+    const SYMBOL_LEN: usize = 4;
+
+    let mut family = PathMap::<u64>::new();
+    for (parent, child) in PARENTS {
+        family.insert(format!("kg/parent/{parent}/{child}"), 1);
+    }
+    for person in FEMALE {
+        family.insert(format!("kg/female/{person}"), 1);
+    }
+    for person in MALE {
+        family.insert(format!("kg/male/{person}"), 1);
+    }
+    std::fs::create_dir_all(out_dir()).unwrap();
+    let act_path = out_dir().join("family.act");
+    ArenaCompactTree::dump_from_zipper(family.read_zipper(), |val: &u64| *val, &act_path).unwrap();
+
+    let mut output = PathMap::<u64>::new();
+    let trace = traced(|| {
+        let family_head = family.zipper_head();
+        let output_head = output.zipper_head();
+
+        //family |= (child $y $x) for each (parent $x $y)
+        let mut parent = TraceZipper::new(1, family_head.read_zipper_at_path(b"kg/parent/").unwrap());
+        let mut child_index = TraceZipper::new(2, family_head.write_zipper_at_exclusive_path(b"kg/child/").unwrap());
+        while parent.to_next_val() {
+            let fact = parent.path().to_vec();
+            let (p, c) = fact.split_at(SYMBOL_LEN);
+            child_index.descend_to(c);
+            child_index.descend_to(b"/");
+            child_index.descend_to(&p[..SYMBOL_LEN - 1]);
+            child_index.set_val(1);
+            child_index.reset();
+        }
+        drop(child_index);
+        parent.reset();
+
+        //person = female ∪ male
+        let female = TraceZipper::new(3, family_head.read_zipper_at_path(b"kg/female/").unwrap());
+        let male = TraceZipper::new(4, family_head.read_zipper_at_path(b"kg/male/").unwrap());
+        let mut person_index = TraceZipper::new(5, family_head.write_zipper_at_exclusive_path(b"kg/person/").unwrap());
+        person_index.graft(&female);
+        let _ = person_index.join_into(&male);
+        drop(person_index);
+        drop(male);
+
+        //Every person's parents
+        let child = TraceZipper::new(6, family_head.read_zipper_at_path(b"kg/child/").unwrap());
+        let mut person = TraceZipper::new(7, family_head.read_zipper_at_path(b"kg/person/").unwrap());
+        let mut parents_out = TraceZipper::new(8, output_head.write_zipper_at_exclusive_path(b"out/parents/").unwrap());
+        parents_out.graft(&child);
+        let _ = parents_out.restrict(&person);
+        drop(parents_out);
+
+        //my_parents is positioned at the parents of each person in turn.  People without recorded parents are skipped
+        let mut my_parents = TraceZipper::new(9, family_head.read_zipper_at_path(b"kg/child/").unwrap());
+        let next_person = |person: &mut TraceZipper<_>, my_parents: &mut TraceZipper<_>| -> Option<Vec<u8>> {
+            while person.to_next_val() {
+                let mut dir = person.path().to_vec();
+                dir.push(b'/');
+                my_parents.move_to_path(&dir);
+                if my_parents.path_exists() {
+                    return Some(dir)
+                }
+            }
+            None
+        };
+
+        //mother(p) = parents(p) ∩ female
+        let mut mother_out = TraceZipper::new(10, output_head.write_zipper_at_exclusive_path(b"out/mother/").unwrap());
+        while let Some(dir) = next_person(&mut person, &mut my_parents) {
+            mother_out.move_to_path(&dir);
+            let _ = mother_out.meet_2(&my_parents, &female);
+        }
+        drop(mother_out);
+        person.reset();
+
+        //sister(p) = (children of p's parents ∩ female) - p
+        let mut sister_out = TraceZipper::new(11, output_head.write_zipper_at_exclusive_path(b"out/sister/").unwrap());
+        while let Some(dir) = next_person(&mut person, &mut my_parents) {
+            sister_out.move_to_path(&dir);
+            sister_out.graft(&my_parents);
+            sister_out.restricting(&parent);
+            sister_out.join_k_path_into(SYMBOL_LEN, true);
+            let _ = sister_out.meet_into(&female, true);
+            if sister_out.descend_to_check(&dir[..SYMBOL_LEN - 1]) {
+                sister_out.remove_val(true);
+            }
+        }
+        drop(sister_out);
+        person.reset();
+
+        //aunt(p) = (children of p's grandparents - p's parents) ∩ female
+        let mut aunt_out = TraceZipper::new(12, output_head.write_zipper_at_exclusive_path(b"out/aunt/").unwrap());
+        while let Some(dir) = next_person(&mut person, &mut my_parents) {
+            aunt_out.move_to_path(&dir);
+            aunt_out.graft(&my_parents);
+            aunt_out.restricting(&child);
+            aunt_out.join_k_path_into(SYMBOL_LEN, true);
+            if !aunt_out.restricting(&parent) {
+                continue
+            }
+            aunt_out.join_k_path_into(SYMBOL_LEN, true);
+            let _ = aunt_out.subtract_into(&my_parents, true);
+            let _ = aunt_out.meet_into(&female, true);
+        }
+    });
+    let seed = tracer::load_act::<u64>(&act_path).unwrap();
+    let replay = replay_and_render("aunt_kg", &trace, vec![("family.act".to_string(), seed)]);
+    //The family map is seeded, and the output map shares no prefix with it
+    assert_eq!(replay.maps.len(), 2);
+    assert_eq!(entries(&replay.maps[0]), entries(&family));
+    assert_eq!(entries(&replay.maps[1]), entries(&output));
+    let relation = |name: &str| -> Vec<String> {
+        let prefix = format!("out/{name}/");
+        output.iter().filter_map(|(path, _)| path.strip_prefix(prefix.as_bytes()).map(|rest| String::from_utf8(rest.to_vec()).unwrap())).collect()
+    };
+    assert_eq!(relation("parents"), ["bob/ann", "cat/ann", "dee/ann", "eve/gus", "hal/gus", "ivy/gus", "jon/bob", "jon/eve", "kim/bob", "kim/eve", "max/hal"]);
+    assert_eq!(relation("mother"), ["bob/ann", "cat/ann", "dee/ann", "jon/eve", "kim/eve"]);
+    assert_eq!(relation("sister"), ["bob/cat", "bob/dee", "cat/dee", "dee/cat", "eve/ivy", "hal/eve", "hal/ivy", "ivy/eve", "jon/kim"]);
+    assert_eq!(relation("aunt"), ["jon/cat", "jon/dee", "jon/ivy", "kim/cat", "kim/dee", "kim/ivy", "max/eve", "max/ivy"]);
+}