Merge pull request #1521 from ludovic111/fix/launcher-doc-crlf

🤖 Agent: merged after verify and CI parity passed, built merged with current main (launcher-ship-1). #1521: generated docs keep LF line endings on Windows, so the launcher builds there again (dry run 40035909909 green on all three OSes). #1522: Prepare no longer requires Netty's optional native transport jar, which Prism never downloads (fixes #1487; test plus a real Prism-layout prepare).
Launcher: the command reference is the same on Windows
2026-11-07 17:21:49 -10:00 · 2026-10-24 02:16:48 +02:00 · 2026-10-24 00:48:08 +02:00 · 2026-10-24 00:32:56 +02:00 · 2026-10-24 00:08:06 +02:00 · 2026-10-23 23:07:17 +02:00
560 changed files with 4891 additions and 5158 deletions
@@ -0,0 +1,5 @@
+# Generated files that tests compare byte for byte with what they generate: LF on every OS, also
+# where Git for Windows' core.autocrlf would check them out with CRLF.
+docs/launcher-commands.md text eol=lf
+docs/horizon-ctl-commands.md text eol=lf
+website/src/tokens.css text eol=lf
@@ -1,104 +0,0 @@
-//! Full production fact loading, including file reads, interning and temporary destruction.
-//! cargo run --profile fast -p horizon-client --example block_facts_bench -- ROOT [SAMPLES]
-//! Use SAMPLES=1 with an OS peak-RSS wrapper; `digest` checks all facts
-//! and the shape sharing partition (including sharing between outlines and edges).
-use horizon_client::blocks::BlockFacts;
-use horizon_world::{DATA_VERSION, nbt::Tag, registry::BlockRegistry};
-use serde_json::Value;
-use std::{
-    collections::{HashMap, hash_map::DefaultHasher},
-    fs,
-    hash::{Hash, Hasher},
-    hint::black_box,
-    path::Path,
-    time::Instant,
-};
-type Result<T> = horizon_client::Result<T>;
-
-fn tag(value: &Value) -> Result<Tag> {
-    Ok(match value {
-        Value::String(s) => Tag::String(s.as_str().into()),
-        Value::Number(n) => Tag::Int(i32::try_from(n.as_i64().ok_or("registry number")?)?),
-        Value::Array(a) => Tag::List(a.iter().map(tag).collect::<Result<_>>()?),
-        Value::Object(o) => Tag::Compound(
-            o.iter()
-                .map(|(k, v)| Ok((k.as_str().into(), tag(v)?)))
-                .collect::<Result<_>>()?,
-        ),
-        _ => return Err("registry value".into()),
-    })
-}
-fn registry(root: &Path) -> Result<BlockRegistry> {
-    let facts: Value = serde_json::from_slice(&fs::read(root.join("facts.json"))?)?;
-    Ok(BlockRegistry::from_nbt(&Tag::compound([
-        ("DataVersion", Tag::Int(DATA_VERSION)),
-        (
-            "states",
-            Tag::List(
-                facts["states"]
-                    .as_array()
-                    .ok_or("registry states")?
-                    .iter()
-                    .map(|s| tag(&s[4]))
-                    .collect::<Result<_>>()?,
-            ),
-        ),
-        ("defaults", tag(&facts["defaults"])?),
-    ]))?)
-}
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    let root = Path::new(
-        args.first()
-            .ok_or("usage: block_facts_bench ROOT [SAMPLES|digest]")?,
-    );
-    let setup = Instant::now();
-    let registry = registry(root)?;
-    println!(
-        "registry_setup_ms={:.3}",
-        setup.elapsed().as_secs_f64() * 1000.0
-    );
-    if args.get(1).is_some_and(|s| s == "digest") {
-        let facts = BlockFacts::load(root, &registry)?;
-        let mut hash = DefaultHasher::new();
-        let mut shapes = HashMap::new();
-        facts.air.hash(&mut hash);
-        for state in &facts.states {
-            format!("{state:?}").hash(&mut hash);
-            for shape in [&state.outline, &state.outline_edges] {
-                let next = shapes.len();
-                shapes
-                    .entry((shape.as_ptr(), shape.len()))
-                    .or_insert(next)
-                    .hash(&mut hash);
-            }
-        }
-        println!(
-            "states={} shared_shapes={} digest={:016x}",
-            facts.states.len(),
-            shapes.len(),
-            hash.finish()
-        );
-        return Ok(());
-    }
-    let samples: usize = args.get(1).map(|s| s.parse()).transpose()?.unwrap_or(9);
-    assert!(samples > 0);
-    // First load is reported separately; OS file caches are not forcibly evicted.
-    let load = || -> Result<f64> {
-        let start = Instant::now();
-        let facts = black_box(BlockFacts::load(black_box(root), black_box(&registry))?);
-        let ms = start.elapsed().as_secs_f64() * 1000.0;
-        drop(facts);
-        Ok(ms)
-    };
-    println!("first_load_ms={:.3}", load()?);
-    if samples > 1 {
-        load()?;
-        load()?;
-        let mut times = (0..samples).map(|_| load()).collect::<Result<Vec<_>>>()?;
-        println!("samples_ms={times:.3?}");
-        times.sort_by(f64::total_cmp);
-        println!("median_ms={:.3}", times[times.len() / 2]);
-    }
-    Ok(())
-}
@@ -1,216 +0,0 @@
-//! Resident chunk storage benchmark: generates a block of vanilla terrain, then
-//! reports the resident block/biome memory, the cost of lookups, meshing and
-//! lighting on it.
-//!
-//! chunk_bench <client resource dir> [--seed S] [--size N]
-#![forbid(unsafe_code)]
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    chunk::{Chunk, MIN_Y, SECTIONS},
-    light::{LightTables, apply_lighting, light_chunk},
-    mesher::{MeshTables, Mesher},
-    models,
-    streaming::{ChunkGenerator, Proto},
-    vanillagen::VanillaTerrain,
-};
-use horizon_core::biome::BiomeZoom;
-use std::{path::PathBuf, sync::Arc, time::Instant};
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let root = PathBuf::from(args.first().ok_or("usage: chunk_bench RESOURCES")?);
-    let flag = |name: &str, default: i64| -> i64 {
-        args.iter()
-            .position(|a| a == name)
-            .and_then(|i| args.get(i + 1))
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(default)
-    };
-    let (seed, size) = (flag("--seed", 12345), flag("--size", 8) as i32);
-    let assets = Assets::load(&root)?;
-    let render = assets.reload(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Biomes::load(&root)?;
-    let tables = MeshTables::new(
-        &assets,
-        &render,
-        &facts,
-        models::load_visibility(&root, assets.registry)?,
-    )?;
-    let light = LightTables::load(&root, assets.registry, &facts)?;
-    let terrain = VanillaTerrain::new(&root.join("worldgen"), assets.registry, &biomes, seed)?;
-    let mut worker = terrain.worker();
-
-    // Protos for size+4 columns, decorated for the inner size+2, finished as size+2.
-    let started = Instant::now();
-    let outer = size + 4;
-    let mut protos: Vec<Option<Proto>> = (0..outer * outer)
-        .map(|i| Some(terrain.proto(&mut worker, i % outer, i / outer)))
-        .collect();
-    eprintln!("proto: {:.2}s", started.elapsed().as_secs_f64());
-    let started = Instant::now();
-    let inner = size + 2;
-    for z in 1..=inner {
-        for x in 1..=inner {
-            let mut region: [Proto; 9] = std::array::from_fn(|k| {
-                let (dx, dz) = (k as i32 % 3 - 1, k as i32 / 3 - 1);
-                protos[((z + dz) * outer + x + dx) as usize]
-                    .take()
-                    .expect("proto")
-            });
-            terrain.decorate(&mut worker, &mut region);
-            for (k, p) in region.into_iter().enumerate() {
-                let (dx, dz) = (k as i32 % 3 - 1, k as i32 / 3 - 1);
-                protos[((z + dz) * outer + x + dx) as usize] = Some(p);
-            }
-        }
-    }
-    eprintln!("decorate: {:.2}s", started.elapsed().as_secs_f64());
-    let started = Instant::now();
-    let mut chunks: Vec<Chunk> = Vec::new();
-    for z in 1..=inner {
-        for x in 1..=inner {
-            let proto = protos[(z * outer + x) as usize].take().expect("proto");
-            let mut chunk = terrain.finish(proto);
-            chunk.x = x;
-            chunk.z = z;
-            chunks.push(chunk);
-        }
-    }
-    let finish = started.elapsed().as_secs_f64();
-    println!(
-        "finish (proto -> resident chunk): {:.1} ms per chunk",
-        finish * 1e3 / chunks.len() as f64
-    );
-
-    let chunks: Vec<Arc<Chunk>> = chunks.into_iter().map(Arc::new).collect();
-    let at = |x: i32, z: i32| chunks[((z - 1) * inner + x - 1) as usize].clone();
-
-    // Light all inner-inner columns.
-    let started = Instant::now();
-    let mut lit = Vec::new();
-    for z in 2..inner {
-        for x in 2..inner {
-            let region: [[Option<Arc<Chunk>>; 3]; 3] = std::array::from_fn(|dz| {
-                std::array::from_fn(|dx| Some(at(x + dx as i32 - 1, z + dz as i32 - 1)))
-            });
-            let borrowed = horizon_client::mesher::borrow(&region);
-            lit.push(((x, z), light_chunk(&borrowed, &light, true)));
-        }
-    }
-    println!(
-        "light: {:.2} ms per column",
-        started.elapsed().as_secs_f64() * 1e3 / lit.len() as f64
-    );
-    let mut chunks: Vec<Chunk> = chunks.iter().map(|c| (**c).clone()).collect();
-    for ((x, z), sections) in lit {
-        apply_lighting(&mut chunks[((z - 1) * inner + x - 1) as usize], sections);
-    }
-    let chunks: Vec<Arc<Chunk>> = chunks.into_iter().map(Arc::new).collect();
-    let at = |x: i32, z: i32| chunks[((z - 1) * inner + x - 1) as usize].clone();
-
-    // Memory.
-    let (mut bytes, mut sections, mut uniform) = (0usize, 0usize, 0usize);
-    for chunk in &chunks {
-        bytes += chunk.heap_bytes();
-        for s in &chunk.sections {
-            sections += 1;
-            uniform += usize::from(s.is_uniform(s.get(0)));
-        }
-    }
-    println!(
-        "resident: {} chunks, {} sections ({} uniform), {:.1} KiB per chunk ({:.2} MiB total)",
-        chunks.len(),
-        sections,
-        uniform,
-        bytes as f64 / 1024.0 / chunks.len() as f64,
-        bytes as f64 / 1048576.0
-    );
-
-    // Meshing.
-    let mut mesher = Mesher {
-        nether_shading: false,
-        assets: &assets,
-        render: &render,
-        tables: &tables,
-        biomes: &biomes,
-        visibility: tables.visibility.clone(),
-        zoom: BiomeZoom::new(7),
-        blend_radius: 2,
-        smooth_lighting: true,
-        cutout_leaves: true,
-        cull_leaves: false,
-    };
-    let mut best = f64::MAX;
-    let mut quads = 0usize;
-    for _ in 0..3 {
-        let started = Instant::now();
-        let mut jobs = 0;
-        quads = 0;
-        for z in 2..inner {
-            for x in 2..inner {
-                let region: [[Option<Arc<Chunk>>; 3]; 3] = std::array::from_fn(|dz| {
-                    std::array::from_fn(|dx| Some(at(x + dx as i32 - 1, z + dz as i32 - 1)))
-                });
-                let borrowed = horizon_client::mesher::borrow(&region);
-                for sy in 0..SECTIONS as i32 {
-                    let mesh = mesher.mesh(&borrowed, sy);
-                    quads += (mesh.solid.len() + mesh.translucent.len()) / 4;
-                    jobs += 1;
-                }
-            }
-        }
-        best = best.min(started.elapsed().as_secs_f64() / f64::from(jobs));
-    }
-    println!(
-        "mesh: {:.1} us per section ({} quads total)",
-        best * 1e6,
-        quads
-    );
-
-    // Random lookups, as collision and entity queries do.
-    let mut state = 0x9E37_79B9_7F4A_7C15u64;
-    let started = Instant::now();
-    let mut sum = 0u64;
-    let lookups = 20_000_000u64;
-    for _ in 0..lookups {
-        state ^= state << 13;
-        state ^= state >> 7;
-        state ^= state << 17;
-        let cx = 2 + (state % u64::from((inner - 2) as u32)) as i32;
-        let cz = 2 + ((state >> 8) % u64::from((inner - 2) as u32)) as i32;
-        let chunk = &chunks[((cz - 1) * inner + cx - 1) as usize];
-        let (x, y, z) = (
-            (state >> 16) as i32 & 15,
-            MIN_Y + ((state >> 24) % 384) as i32,
-            (state >> 40) as i32 & 15,
-        );
-        sum += u64::from(chunk.get(x, y, z));
-    }
-    println!(
-        "random get: {:.2} ns per lookup (checksum {sum})",
-        started.elapsed().as_secs_f64() * 1e9 / lookups as f64
-    );
-    // Coherent scan, as a column or area query does.
-    let started = Instant::now();
-    let mut sum = 0u64;
-    for _ in 0..4 {
-        for chunk in &chunks {
-            for y in MIN_Y..MIN_Y + 384 {
-                for z in 0..16 {
-                    for x in 0..16 {
-                        sum += u64::from(chunk.get(x, y, z));
-                    }
-                }
-            }
-        }
-    }
-    println!(
-        "scan get: {:.2} ns per lookup (checksum {sum})",
-        started.elapsed().as_secs_f64() * 1e9 / (4.0 * chunks.len() as f64 * 98304.0)
-    );
-    Ok(())
-}
@@ -1,140 +0,0 @@
-//! Isolated production mob-model builder benchmark; no assets, Game, GPU or full-frame work.
-//! CARGO_TARGET_DIR=/home/bob/Documents/horizon/target CARGO_INCREMENTAL=0 \
-//! cargo run --profile fast -p horizon-client --example entity_geometry_bench
-use horizon_client::{
-    mesher::Vertex,
-    mobs::{Part, Polygon, anim::Poses, render},
-};
-use std::{hint::black_box, time::Instant};
-
-fn cube(name: String, position: f32) -> Part {
-    let polygons = (0..6)
-        .map(|face| {
-            let axis = face / 2;
-            let side = (face % 2) as f32;
-            let mut normal = [0.0; 3];
-            normal[axis] = side * 2.0 - 1.0;
-            Polygon {
-                normal,
-                vertices: [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]].map(|uv| {
-                    let mut vertex = [0.0; 5];
-                    vertex[axis] = side * 8.0;
-                    vertex[(axis + 1) % 3] = uv[0] * 8.0;
-                    vertex[(axis + 2) % 3] = uv[1] * 8.0;
-                    vertex[3] = uv[0];
-                    vertex[4] = uv[1];
-                    vertex
-                }),
-            }
-        })
-        .collect();
-    Part {
-        name,
-        pose: [position, 0.0, 0.0, 0.1, 0.2, 0.0, 1.0, 1.0, 1.0],
-        polygons,
-        children: Vec::new(),
-    }
-}
-
-fn build(model: &Part, poses: &Poses, count: usize, out: &mut Vec<Vertex>) {
-    for i in 0..count {
-        render::draw(
-            black_box(model),
-            glam::Mat4::from_translation(glam::Vec3::new((i % 32) as f32, 0.0, (i / 32) as f32)),
-            black_box(poses),
-            [0.125, 0.25, 0.5, 0.75],
-            0xffc0_d0e0,
-            0xf0f0,
-            0,
-            out,
-        );
-    }
-    black_box(out.as_slice());
-}
-
-fn measure(model: &Part, poses: &Poses, count: usize, iterations: usize, reuse: bool) -> f64 {
-    let mut retained = Vec::new();
-    build(model, poses, count, &mut retained); // Untimed warmup.
-    let start = Instant::now();
-    for _ in 0..iterations {
-        let mut out = if reuse {
-            std::mem::take(&mut retained)
-        } else {
-            Vec::new()
-        };
-        out.clear();
-        build(model, poses, count, &mut out);
-        if reuse {
-            retained = out;
-        }
-    }
-    start.elapsed().as_secs_f64() * 1e6 / iterations as f64
-}
-
-fn main() {
-    let mut model = cube("body".into(), 0.0);
-    model.children = (1..6).map(|i| cube(format!("part{i}"), i as f32)).collect();
-    let poses = Poses::new(&model);
-    for count in [32, 256, 1024, 4096, 8192] {
-        let mut expected = Vec::new();
-        build(&model, &poses, count, &mut expected);
-        let mut retained = Vec::new();
-        build(&model, &poses, count, &mut retained);
-        let (pointer, capacity) = (retained.as_ptr(), retained.capacity());
-        // Populated -> empty/reset -> smaller -> populated must never leave stale vertices.
-        for n in [0, count / 2, count, count] {
-            retained.clear();
-            build(&model, &poses, n, &mut retained);
-            let mut fresh = Vec::new();
-            build(&model, &poses, n, &mut fresh);
-            assert_eq!(
-                bytemuck::cast_slice::<Vertex, u8>(&retained),
-                bytemuck::cast_slice::<Vertex, u8>(&fresh)
-            );
-            assert_eq!(
-                (retained.as_ptr(), retained.capacity()),
-                (pointer, capacity)
-            );
-        }
-        assert_eq!(
-            bytemuck::cast_slice::<Vertex, u8>(&retained),
-            bytemuck::cast_slice::<Vertex, u8>(&expected)
-        );
-        let iterations = (100_000 / count).clamp(40, 1000);
-        let mut fresh = Vec::new();
-        let mut reused = Vec::new();
-        let mut paired_speedups = Vec::new();
-        // Alternate order, reporting medians over eleven warmed batches.
-        for batch in 0..11 {
-            let mut pair = [0.0; 2];
-            for reuse in if batch % 2 == 0 {
-                [false, true]
-            } else {
-                [true, false]
-            } {
-                let time = measure(&model, &poses, count, iterations, reuse);
-                pair[usize::from(reuse)] = time;
-                if reuse {
-                    reused.push(time);
-                } else {
-                    fresh.push(time);
-                }
-            }
-            paired_speedups.push(pair[0] / pair[1]);
-        }
-        paired_speedups.sort_by(f64::total_cmp);
-        fresh.sort_by(f64::total_cmp);
-        reused.sort_by(f64::total_cmp);
-        println!(
-            "entities={count} vertices={} capacity={capacity} retained_bytes={} fresh_us={:.3} reused_us={:.3} speedup={:.3}x paired_speedup_median={:.3}x paired_speedup_range={:.3}..{:.3}x iterations={iterations} batches=11 byte_equivalence=pass pointer_capacity_reuse=pass",
-            retained.len(),
-            capacity * size_of::<Vertex>(),
-            fresh[5],
-            reused[5],
-            fresh[5] / reused[5],
-            paired_speedups[5],
-            paired_speedups[0],
-            paired_speedups[10]
-        );
-    }
-}
@@ -1,205 +0,0 @@
-//! Compare the exact read/deserialize sequences used by the model loaders.
-//! Run with `cargo run -p horizon-client --profile fast --example json_readers_bench`.
-//! Optional arguments: resource directory, repetitions (default 9).
-use serde_json::{Map, Value, json};
-use std::{
-    collections::BTreeMap,
-    fmt::Debug,
-    fs::{self, File},
-    hint::black_box,
-    io::BufReader,
-    path::{Path, PathBuf},
-    time::Instant,
-};
-
-type Result<T> = horizon_client::Result<T>;
-
-#[derive(Clone, Copy)]
-enum Reader {
-    File,
-    Buffered,
-    Slice,
-}
-const READERS: [Reader; 3] = [Reader::File, Reader::Buffered, Reader::Slice];
-
-// These match the map types and reader expressions at all three production sites.
-macro_rules! reader {
-    ($name:ident, $map:ty) => {
-        fn $name(path: &Path, reader: Reader) -> Result<$map> {
-            Ok(match reader {
-                Reader::File => serde_json::from_reader(File::open(path)?)?,
-                Reader::Buffered => serde_json::from_reader(BufReader::new(File::open(path)?))?,
-                Reader::Slice => serde_json::from_slice(&fs::read(path)?)?,
-            })
-        }
-    };
-}
-reader!(prepare_facts, Map<String, Value>);
-reader!(catalog_facts, BTreeMap<String, Value>);
-
-struct Fixture(PathBuf);
-impl Fixture {
-    fn new() -> Result<Self> {
-        let root =
-            std::env::temp_dir().join(format!("horizon-json-readers-{}", std::process::id()));
-        fs::create_dir(&root)?;
-        Ok(Self(root))
-    }
-}
-impl Drop for Fixture {
-    fn drop(&mut self) {
-        let _ = fs::remove_dir_all(&self.0);
-    }
-}
-
-fn fixtures(root: &Path) -> Result<()> {
-    let states: Vec<_> = (0..56)
-        .map(|i| {
-            json!({"facing": (["north", "east", "south", "west"][i % 4]),
-                "powered": if i / 4 % 2 == 0 { "false" } else { "true" },
-                "age": (i / 8).to_string()})
-        })
-        .collect();
-    let mut models = Map::new();
-    let mut render = Map::new();
-    for i in 0..1024 {
-        let name = format!("minecraft:fixture_block_{i:04}");
-        models.insert(
-            name.clone(),
-            json!({
-                "schema": {"facing": {"named": ["north", "east", "south", "west"]},
-                    "powered": {"named": ["false", "true"]}, "age": {"integer": [0, 6]}},
-                "states": states
-            }),
-        );
-        render.insert(
-            name,
-            json!({"rule": "never", "can_occlude": true, "bars_tag": false}),
-        );
-    }
-    fs::write(root.join("model-states.json"), serde_json::to_vec(&models)?)?;
-    fs::write(
-        root.join("render-definitions.json"),
-        serde_json::to_vec(&render)?,
-    )?;
-    Ok(())
-}
-
-fn benchmark<T: PartialEq + Debug>(
-    label: &str,
-    path: &Path,
-    repetitions: usize,
-    read: impl Fn(&Path, Reader) -> Result<T>,
-) -> Result<()> {
-    let expected = read(path, Reader::File)?;
-    for reader in READERS {
-        assert_eq!(expected, read(path, reader)?);
-        for _ in 0..2 {
-            black_box(read(black_box(path), reader)?);
-        }
-    }
-    drop(expected);
-    let mut samples: [Vec<f64>; 3] = std::array::from_fn(|_| Vec::new());
-    for repetition in 0..repetitions {
-        // Rotate reader order to distribute drift across implementations.
-        for offset in 0..3 {
-            let index = (repetition + offset) % 3;
-            let start = Instant::now();
-            let value = black_box(read(black_box(path), READERS[index])?);
-            samples[index].push(start.elapsed().as_secs_f64() * 1000.0);
-            drop(value); // Match the loaders: retain the parsed tree after loading.
-        }
-    }
-    let median: Vec<_> = samples
-        .iter_mut()
-        .map(|s| {
-            s.sort_by(f64::total_cmp);
-            s[s.len() / 2]
-        })
-        .collect();
-    println!(
-        "{label}: {} bytes, {repetitions} samples/reader, median ms: File={:.3}, BufReader={:.3}, read+slice={:.3}; slice speedup={:.2}x",
-        fs::metadata(path)?.len(),
-        median[0],
-        median[1],
-        median[2],
-        median[0] / median[2]
-    );
-    Ok(())
-}
-
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    let fixture = if args.is_empty() {
-        Some(Fixture::new()?)
-    } else {
-        None
-    };
-    let root = fixture
-        .as_ref()
-        .map(|f| f.0.clone())
-        .unwrap_or_else(|| PathBuf::from(&args[0]));
-    if fixture.is_some() {
-        fixtures(&root)?;
-        println!(
-            "Generated representative fixtures: 1024 blocks, 57344 model states; warm filesystem cache."
-        );
-    }
-    let repetitions = args.get(1).map(|s| s.parse()).transpose()?.unwrap_or(9);
-    assert!(repetitions > 0, "repetitions must be positive");
-    benchmark(
-        "prepare model states",
-        &root.join("model-states.json"),
-        repetitions,
-        prepare_facts,
-    )?;
-    benchmark(
-        "catalog model states",
-        &root.join("model-states.json"),
-        repetitions,
-        catalog_facts,
-    )?;
-    benchmark(
-        "render definitions",
-        &root.join("render-definitions.json"),
-        repetitions,
-        catalog_facts,
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn reader_equivalence_and_errors() -> Result<()> {
-        let fixture = Fixture::new()?;
-        let path = fixture.0.join("test.json");
-        fs::write(&path, br#"{"minecraft:stone":{"schema":{},"states":[{}]},"unicode":"\u2603","duplicate":1,"duplicate":2}"#)?;
-        let expected = prepare_facts(&path, Reader::File)?;
-        for reader in READERS {
-            assert_eq!(expected, prepare_facts(&path, reader)?);
-            assert_eq!(
-                expected.iter().collect::<BTreeMap<_, _>>(),
-                catalog_facts(&path, reader)?.iter().collect()
-            );
-        }
-        for invalid in [b"{\"a\": ".as_slice(), b"{} trailing", b"{\"a\":\"\xff\"}"] {
-            fs::write(&path, invalid)?;
-            for reader in READERS {
-                let error = prepare_facts(&path, reader).unwrap_err();
-                assert!(error.downcast_ref::<serde_json::Error>().is_some());
-                assert!(catalog_facts(&path, reader).is_err());
-            }
-        }
-        fs::remove_file(&path)?;
-        for reader in READERS {
-            let error = prepare_facts(&path, reader).unwrap_err();
-            assert_eq!(
-                error.downcast_ref::<std::io::Error>().unwrap().kind(),
-                std::io::ErrorKind::NotFound
-            );
-        }
-        Ok(())
-    }
-}
@@ -1,143 +0,0 @@
-//! Serve a small flat world on the LAN server without the game, for joining
-//! with a real client while developing the protocol:
-//! `cargo run --release --example lan_flat -- RESOURCES PORT`.
-use horizon_client::{
-    assets::Assets,
-    blocks::BlockFacts,
-    chunk::{Chunk, MIN_Y},
-    lan::{
-        Lan,
-        chunks::ChunkEncoder,
-        data::SyncData,
-        hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
-    },
-    world::World,
-};
-use horizon_protocol::packets::play::Serverbound as S;
-use std::{path::PathBuf, sync::Arc, time::Duration};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args = std::env::args().skip(1);
-    let root = PathBuf::from(args.next().ok_or("RESOURCES PORT")?);
-    let port: u16 = args.next().ok_or("port")?.parse()?;
-    let assets = Assets::load(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let state = |name: &str| assets.registry.default_state(name).map_or(0, |s| s.0);
-    let sync = Arc::new(SyncData::load(&root)?);
-    let biomes: Vec<String> = sync
-        .dynamic
-        .registries
-        .get("minecraft:worldgen/biome")
-        .map(|v| v.iter().map(|(n, _)| n.clone()).collect())
-        .unwrap_or_default();
-    let encoder = ChunkEncoder::new(
-        facts
-            .states
-            .iter()
-            .map(|s| (s.name.clone(), s.fluid_level > 0 || s.waterlogged)),
-        &sync.builtin,
-        &biomes,
-        &biomes,
-    );
-    let (stone, dirt, grass) = (
-        state("minecraft:stone"),
-        state("minecraft:dirt"),
-        state("minecraft:grass_block"),
-    );
-    let mut world = World::new(facts.air, 0);
-    for cz in -8..=8 {
-        for cx in -8..=8 {
-            let mut chunk = Chunk::empty(cx, cz);
-            for z in 0..16 {
-                for x in 0..16 {
-                    for y in MIN_Y..60 {
-                        let v = if y == 59 {
-                            grass
-                        } else if y > 55 {
-                            dirt
-                        } else {
-                            stone
-                        };
-                        chunk.set(x, y, z, v);
-                    }
-                }
-            }
-            chunk.lit = true;
-            world.chunks.insert((cx, cz), Arc::new(chunk));
-        }
-    }
-    let lan = Lan::start(sync.clone(), port, "Flat - Example".into(), 8)?;
-    println!("listening on {}", lan.port);
-    let mut hub = Hub::new(
-        lan,
-        sync,
-        encoder,
-        HubConfig {
-            default_game_mode: 1,
-            guest_commands: true,
-            force_game_mode: false,
-            hardcore: false,
-            view_distance: 8,
-            simulation_distance: 8,
-            dimension: "minecraft:overworld".into(),
-            seed: 0,
-            max_players: 8,
-            dedicated: false,
-            integrated: false,
-        },
-    );
-    let mut next_entity = 100u32;
-    let host = HostState {
-        uuid: 42,
-        name: "Host".into(),
-        entity_id: 1,
-        position: [0.5, 60.0, 0.5],
-        yaw: 0.0,
-        pitch: 0.0,
-        head_yaw: 0.0,
-        on_ground: true,
-        game_mode: 1,
-        sneaking: false,
-        sprinting: false,
-        equipment: Default::default(),
-        health: 20.0,
-        attributes: Vec::new(),
-        bed: None,
-        living_flags: 0,
-    };
-    loop {
-        world.game_time += 1;
-        world.day_time += 1;
-        let mut ctx = TickCtx {
-            world: &mut world,
-            host: Some(&host),
-            entities: &[],
-            next_entity: &mut next_entity,
-            spawn: [8.5, 60.0, 8.5],
-            difficulty: 2,
-            difficulty_locked: false,
-            clock_rate: 1.0,
-            tick_rate: 20.0,
-            tick_frozen: false,
-            tick_steps: (0, 0),
-            collision: None,
-        };
-        for event in hub.tick(&mut ctx) {
-            match event {
-                HostEvent::Joined(conn) => hub.place_new_player(conn, &mut ctx),
-                HostEvent::Packet(_, packet) => {
-                    if std::env::var_os("HORIZON_NET_DEBUG").is_some()
-                        && !matches!(*packet, S::ClientTickEnd(_))
-                    {
-                        eprintln!("[lan] {packet:?}");
-                    }
-                }
-                HostEvent::Chat { line, .. } | HostEvent::Warn(line) | HostEvent::Error(line) => {
-                    println!("{line}")
-                }
-                HostEvent::Left(_) => {}
-            }
-        }
-        std::thread::sleep(Duration::from_millis(50));
-    }
-}
@@ -1,153 +0,0 @@
-//! Read-only saved chunk benchmark. All timings exclude resource/corpus setup.
-//!
-//! load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]
-//! Add --profile-worker when a sampling collector cannot sample the main thread.
-//! Reports warm filesystem SaveDir::load (read, inflate, NBT, decode and light),
-//! plus isolated inflate/NBT and native decode. No files in the save are changed.
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    save::{SaveDir, SaveTables, decode_with},
-};
-use horizon_world::{nbt::Limits, region::RegionFile};
-use sha2::{Digest, Sha256};
-use std::{hint::black_box, path::PathBuf, sync::Arc, time::Instant};
-
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn main() -> Result<()> {
-    if std::env::args().any(|a| a == "--profile-worker") {
-        std::thread::spawn(|| run().map_err(|e| e.to_string()))
-            .join()
-            .expect("benchmark worker")
-            .map_err(Into::into)
-    } else {
-        run()
-    }
-}
-
-fn run() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let usage = "load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]";
-    let root = PathBuf::from(args.first().ok_or(usage)?);
-    let dimension = PathBuf::from(args.get(1).ok_or(usage)?);
-    let flag = |name: &str, default: usize| -> Result<usize> {
-        Ok(match args.iter().position(|a| a == name) {
-            Some(i) => args.get(i + 1).ok_or(usage)?.parse()?,
-            None => default,
-        })
-    };
-    let rounds = flag("--rounds", 5)?;
-    let limit = flag("--limit", 256)?;
-    if rounds == 0 || limit == 0 {
-        return Err("rounds and limit must be positive".into());
-    }
-    let assets = Assets::load(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Biomes::load(&root)?;
-    let tables = Arc::new(SaveTables::new(&assets).with_block_entities(&facts));
-    let source = SaveDir::new(dimension.clone());
-    let _ = source.tables.set(tables.clone());
-    let mut paths: Vec<_> = std::fs::read_dir(dimension.join("region"))?
-        .map(|e| e.map(|e| e.path()))
-        .collect::<std::io::Result<_>>()?;
-    paths.retain(|p| p.extension().is_some_and(|e| e == "mca"));
-    paths.sort();
-    let mut corpus = Vec::new();
-    'regions: for path in paths {
-        let mut region = RegionFile::open(path)?;
-        let mut positions: Vec<_> = region.chunks().map(|(pos, _)| pos).collect();
-        positions.sort_by_key(|p| (p.x, p.z));
-        for pos in positions {
-            let record = region.read(pos)?.ok_or("missing record")?;
-            let tag = record.nbt(Limits::default())?;
-            if decode_with(&tag, assets.registry, &biomes, Some(&tables)).is_none() {
-                continue;
-            }
-            corpus.push((pos, record, tag));
-            if corpus.len() == limit {
-                break 'regions;
-            }
-        }
-    }
-    if corpus.is_empty() {
-        return Err("no full chunks in corpus".into());
-    }
-    let mut records_hash = Sha256::new();
-    for (pos, record, _) in &corpus {
-        records_hash.update(pos.x.to_le_bytes());
-        records_hash.update(pos.z.to_le_bytes());
-        records_hash.update((record.compressed.len() as u64).to_le_bytes());
-        records_hash.update(&record.compressed);
-    }
-    println!(
-        "{}",
-        serde_json::json!({"corpus": dimension, "chunks": corpus.len(), "rounds": rounds,
-            "compressed_records_sha256": format!("{:x}", records_hash.finalize()),
-            "compressed_bytes": corpus.iter().map(|(_, r, _)| r.compressed.len()).sum::<usize>()})
-    );
-    // Prime SaveDir's region handles and the filesystem cache before measurement.
-    for (pos, _, _) in &corpus {
-        black_box(
-            source
-                .load(pos.x, pos.z, assets.registry, &biomes)
-                .ok_or("load failed")?,
-        );
-    }
-    for round in 0..rounds {
-        let started = Instant::now();
-        for (pos, _, _) in &corpus {
-            black_box(
-                source
-                    .load(pos.x, pos.z, assets.registry, &biomes)
-                    .ok_or("load failed")?,
-            );
-        }
-        let load_s = started.elapsed().as_secs_f64();
-        let started = Instant::now();
-        for (_, record, _) in &corpus {
-            black_box(record.nbt(Limits::default())?);
-        }
-        let nbt_s = started.elapsed().as_secs_f64();
-        let started = Instant::now();
-        for (_, _, tag) in &corpus {
-            black_box(
-                decode_with(tag, assets.registry, &biomes, Some(&tables)).ok_or("decode failed")?,
-            );
-        }
-        let decode_s = started.elapsed().as_secs_f64();
-        println!(
-            "{}",
-            serde_json::json!({"round": round, "load_s": load_s,
-            "inflate_nbt_s": nbt_s, "decode_s": decode_s})
-        );
-    }
-    if args.iter().any(|a| a == "--checksum") {
-        let mut hash = Sha256::new();
-        let mut light_loaded = 0;
-        for (pos, _, _) in &corpus {
-            let chunk = source
-                .load(pos.x, pos.z, assets.registry, &biomes)
-                .ok_or("load failed")?;
-            hash.update(pos.x.to_le_bytes());
-            hash.update(pos.z.to_le_bytes());
-            light_loaded += usize::from(chunk.light_loaded);
-            for section in &chunk.sections {
-                for i in 0..4096 {
-                    hash.update(section.get(i).to_le_bytes());
-                    hash.update([section.light(i)]);
-                }
-                for i in 0..64 {
-                    hash.update(section.biomes.get(i).to_le_bytes());
-                }
-            }
-        }
-        println!(
-            "{}",
-            serde_json::json!({"blocks_biomes_light_sha256": format!("{:x}", hash.finalize()),
-            "light_loaded": light_loaded})
-        );
-    }
-    Ok(())
-}
@@ -1,8 +1,7 @@
 //! Replays `tools/test_ambient_sound_parity.py` scripts through Horizon's
 //! ambient sound handlers over its `SoundEngine`:
 //! `ambient_fixture ROOT INPUT OUTPUT`.
-#[path = "audio_common/mod.rs"]
-mod common;
+use crate::audio_common as common;
 use common::{Fake, d, f, flush};
 use horizon_client::ambience::{Ambience, AmbientContext, AmbientSounds, Mood, bubble_column_in};
 use horizon_client::sound_engine::{Bound, SoundEngine, TickContext, Ticking};
@@ -47,8 +46,8 @@ fn sounds(a: &[&str]) -> AmbientSounds {
    }
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1])));
    engine.listening = true;
    let mut backend = Fake::default();
@@ -50,8 +50,8 @@ fn particle(k: ArrowParticle) -> &'static str {
        ArrowParticle::Splash => "splash",
    }
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err("usage: arrow_probe RESOURCES FIXTURE_DIRECTORY --describe|REFERENCE".into());
    }
@@ -18,8 +18,8 @@ fn music(m: Option<&Music>) -> String {
    })
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let root = std::path::Path::new(&args[1]);
    let tables = MusicTables::load(root);
    let ambient = AmbientTables::load(root);
@@ -24,8 +24,8 @@ fn db(v: &Value) -> f64 {
    f64::from_bits(u64::from_str_radix(v.as_str().unwrap(), 16).unwrap())
 }

-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let [root, input, output, scene_json] = &args[..] else {
        return Err("usage: auto_jump_probe RESOURCES INPUT OUTPUT SCENE_JSON".into());
    };
@@ -118,8 +118,8 @@ fn status(s: ShulkerStatus) -> &'static str {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: block_entity_anim_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -110,8 +110,8 @@ fn intern(s: &str) -> &'static str {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, textures, output] = args.as_slice() else {
        return Err("usage: block_entity_render_fixture RESOURCES INPUTS TEXTURES OUTPUT".into());
    };
@@ -26,8 +26,8 @@ fn entity(name: &str) -> BlockEntity {
        .unwrap_or_else(|| panic!("no block entity for {name}"))
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let input = std::fs::read_to_string(&args[1]).expect("input");
    let mut out = String::new();
    let mut entities = BlockEntities::default();
@@ -8,8 +8,8 @@ use std::{
    io::{BufRead, BufReader, BufWriter, Write},
    path::Path,
 };
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let root = Path::new(&args[1]);
    let assets = Assets::load(root)?;
    let render = assets.reload(root)?;
@@ -51,8 +51,8 @@ impl Around for Column {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: block_transform_fixture RESOURCES INPUT OUTPUT")?,
@@ -16,8 +16,8 @@ use std::{
 };
 /// The stage sprite origin the cracks carry (the oracle compares the geometry and UVs only).
 const STAGE: [f32; 2] = [0.25, 0.5];
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let root = Path::new(&args[1]);
    let assets = Assets::load(root)?;
    let render = assets.reload(root)?;
@@ -323,8 +323,8 @@ fn avatar(c: &Value, out: &mut impl Write) -> Result<()> {
    Ok(())
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -70,8 +70,8 @@ fn describe(state: &BlockState) -> String {
    format!("{}|{}", state.name, props.join(","))
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: cauldron_fixture RESOURCES INPUT OUTPUT")?,
@@ -5,6 +5,7 @@
 //! the oracle's JSON form.
 //!
 //! usage: chat_screen_fixture RESOURCES REGISTRIES CASES OUTPUT
+use crate::pack_screen_fixture;
 use horizon_client::{
    chat::{ChatAction, ChatScreen, Commands},
    command::vanilla,
@@ -15,14 +16,11 @@ use horizon_client::{
 use serde_json::{Value, json};
 use std::{fmt::Write as _, fs, path::PathBuf};
 use winit::keyboard::KeyCode as K;
-#[path = "pack_screen_fixture.rs"]
-#[allow(dead_code)]
-mod pack_screen_fixture;
 #[path = "chat_screen_fixture/registries.rs"]
 mod registries;

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, registries, inputs, output] = args.as_slice() else {
        return Err("usage: chat_screen_fixture RESOURCES REGISTRIES CASES OUTPUT".into());
    };
@@ -1,8 +1,8 @@
 //! CloudRenderer face selection and mesh traversal, without a GPU.
 use horizon_client::clouds;
 use std::{fmt::Write, fs};
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let mut output = String::new();
    for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() {
        let values: Vec<i32> = line
@@ -132,8 +132,8 @@ fn tree(d: &Dispatcher, node: usize) -> Value {
    v
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    if args.get(1).map(String::as_str) == Some("tree") {
        let d = &vanilla::registered(false);
        let mut v = tree(d, 0);
@@ -24,8 +24,8 @@ fn input_name(input: Input) -> &'static str {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -11,8 +11,8 @@ use horizon_client::{
 use serde_json::{Value, json};
 use std::{fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: creative_search_fixture RESOURCES CREATIVE_JSON VANILLA_JSON OUTPUT";
    let names = Names::load(Path::new(args.get(1).ok_or(usage)?));
    let creative = Creative::from_json(&serde_json::from_slice(&fs::read(
@@ -0,0 +1,49 @@
+//! How the probe binary runs a probe. main.rs lists the probes and nothing else (tools/parity.py leaves it out of
+//! the harnesses' dependencies); code every probe relies on goes here.
+use std::process::ExitCode;
+
+/// `probes! { a, b, }` declares the binary's `main`, which runs the probe module named by its first argument.
+macro_rules! probes {
+    ($($name:ident,)*) => {
+        fn run(name: &str) -> Option<std::process::ExitCode> {
+            use std::process::Termination;
+            Some(match name {
+                $(stringify!($name) => $name::main().report(),)*
+                _ => return None,
+            })
+        }
+
+        fn main() -> std::process::ExitCode {
+            dispatch::main(&[$(stringify!($name)),*], run)
+        }
+    };
+}
+
+/// The probe's command line as its own example saw it: the program, then the arguments after the probe's name.
+pub fn args() -> std::vec::IntoIter<String> {
+    let mut args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        args.remove(1);
+    }
+    args.into_iter()
+}
+
+/// args(), as OsStrings.
+pub fn args_os() -> std::vec::IntoIter<std::ffi::OsString> {
+    let mut args: Vec<_> = std::env::args_os().collect();
+    if args.len() > 1 {
+        args.remove(1);
+    }
+    args.into_iter()
+}
+
+pub fn main(names: &[&str], run: fn(&str) -> Option<ExitCode>) -> ExitCode {
+    let name = std::env::args().nth(1).unwrap_or_default();
+    run(&name).unwrap_or_else(|| {
+        eprintln!(
+            "usage: probe <name> [arguments...]\nprobes: {}",
+            names.join(" ")
+        );
+        ExitCode::from(2)
+    })
+}
@@ -14,8 +14,8 @@ fn d(v: f64) -> String {
    format!("{:016x}", v.to_bits())
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in BufReader::new(File::open(&args[1])?).lines().enumerate() {
        let c: Value = serde_json::from_str(&line?)?;
@@ -10,8 +10,8 @@ use horizon_client::{
 };
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: enchanting_fixture RESOURCES INPUT OUTPUT")?,
@@ -3,7 +3,7 @@
 //! posed model with `mobs::render::draw` under the case's living-entity root
 //! transform and writes each drawn part's packed vertex normals.
 //!
-//! cargo run --profile fast -p horizon-client --example entity_anim_fixture -- \
+//! cargo run --profile fast -p horizon-client --example probe -- entity_anim_fixture \
 //!     RESOURCES VANILLA.jsonl OUT.jsonl
 use horizon_client::mesher::Vertex;
 use horizon_client::mobs::{
@@ -288,8 +288,8 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let root = PathBuf::from(&args[0]);
    let types = MobTypes::load(&root)?;
    let animations = MobData::load_animations(&root);
@@ -61,8 +61,8 @@ fn species(id: &str) -> Species {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -53,8 +53,8 @@ fn line(s: &LootStack) -> String {
    out
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: entity_death_loot_fixture RESOURCES INPUT OUTPUT")?,
@@ -13,8 +13,8 @@ fn d(v: f64) -> String {
    format!("{:016x}", v.to_bits())
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in BufReader::new(File::open(&args[1])?).lines().enumerate() {
        let c: Value = serde_json::from_str(&line?)?;
@@ -9,8 +9,8 @@ use horizon_client::{
 };
 use std::{collections::HashMap, fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: environment_fixture RESOURCES INPUT OUTPUT")?,
@@ -388,8 +388,8 @@ fn describe(m: &Mob, all: &[Mob], regs: &SpawnRegistries) -> String {
    t.join(" ")
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: finalize_spawn_fixture RESOURCES INPUT OUTPUT HALLOWEEN")?,
@@ -11,8 +11,8 @@ use std::{
    io::{BufRead, BufReader, BufWriter, Write},
 };

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for line in input.lines() {
@@ -4,8 +4,8 @@
 use horizon_client::{enchant::Enchantments, item_data::parse_stack, item_tooltip::firework_lines};
 use std::{error::Error, fmt::Write, path::PathBuf};

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let input = std::fs::read_to_string(&args[1])?;
    let root = input
        .lines()
@@ -458,8 +458,8 @@ impl HandWorld for ResetWorld<'_, '_> {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -50,8 +50,8 @@ impl LimiterClock for Script {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -291,8 +291,8 @@ fn key(c: &Value, out: &mut impl Write) -> Result<()> {
    Ok(())
 }

-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut out = BufWriter::new(File::create(&args[1])?);
    for line in BufReader::new(File::open(&args[0])?).lines() {
        let c: Value = serde_json::from_str(&line?)?;
@@ -13,8 +13,8 @@ use horizon_client::{
 use serde_json::Value;
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: ghost_recipe_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -2,7 +2,7 @@
 use horizon_client::command::args::GameMode;
 use horizon_client::items::{ItemStack, take_held_drop};

-fn main() {
+pub fn main() {
    for mode in [
        GameMode::Survival,
        GameMode::Creative,
@@ -10,8 +10,8 @@ use serde_json::Value;
 use std::path::Path;
 use std::{fmt::Write as _, fs};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: hotbar_fixture RESOURCES CASES OUTPUT";
    let items = Items::catalog(Path::new(args.first().and(args.get(1)).ok_or(usage)?))?;
    let known = |id: &str| items.get(id).is_some();
@@ -20,8 +20,8 @@ type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 #[path = "hud_fixture/kinds.rs"]
 mod kinds;

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: hud_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -11,8 +11,8 @@ fn number(v: &Value) -> f32 {
 fn bits(v: f32) -> u32 {
    if v.is_nan() { 0x7fc00000 } else { v.to_bits() }
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut out = BufWriter::new(File::create(&args[1])?);
    for line in BufReader::new(File::open(&args[0])?).lines() {
        let f: Value = serde_json::from_str(&line?)?;
@@ -82,8 +82,8 @@ impl TargetUseWorld for World {
    }
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let input = std::io::BufReader::new(std::fs::File::open(&args[1])?);
    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[2])?);
    for (i, line) in input.lines().enumerate() {
@@ -14,8 +14,8 @@ fn unhex(s: &str) -> Vec<u8> {
        .collect()
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let cases = std::fs::read_to_string(&args[1]).unwrap();
    let mut out = String::new();
    let mut games: Vec<LanGame> = Vec::new();
@@ -2,7 +2,7 @@
 //! server with Horizon's light engine and compare every SkyLight/BlockLight
 //! value with the arrays vanilla stored.
 //!
-//! cargo run --profile fast -p horizon-client --example light_parity -- \
+//! cargo run --profile fast -p horizon-client --example probe -- light_parity \
 //!     RESOURCES DIMENSION_DIR [--nether] [--chunks X0 Z0 X1 Z1]
 use horizon_client::{
    assets::Assets,
@@ -21,8 +21,8 @@ use std::{collections::HashMap, path::PathBuf};

 type Arrays = HashMap<i32, (Option<Vec<u8>>, Option<Vec<u8>>)>;

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let root = PathBuf::from(
        args.first()
            .ok_or("usage: light_parity RESOURCES DIMENSION_DIR")?,
@@ -0,0 +1,178 @@
+//! Every horizon-client parity probe in one binary: `probe <name> [arguments]` runs `<name>.rs` as its own
+//! example did (tools/test_*_parity.py, tools/oracle_harness.py, tools/audio_harness.py). Linking ~80 examples,
+//! each with the whole client in it, was most of the parity job's probe build; one binary builds it once.
+//!
+//! This file only lists the probes, so that adding one reruns no harness: tools/parity.py leaves it out of
+//! their dependencies. How a probe runs is in dispatch.rs.
+#[macro_use]
+mod dispatch;
+
+use dispatch::{args, args_os};
+
+mod ambient_fixture;
+mod arrow_probe;
+mod audio_attributes_fixture;
+/// Sound-engine fakes the audio probes share.
+mod audio_common;
+mod auto_jump_probe;
+mod block_entity_anim_fixture;
+mod block_entity_render_fixture;
+mod block_entity_tickers_fixture;
+mod block_particles_fixture;
+mod block_transform_fixture;
+mod breaking_fixture;
+mod camera_probe;
+mod cauldron_fixture;
+mod chat_screen_fixture;
+mod cloud_fixture;
+mod command_parse_fixture;
+mod container_screen_probe;
+mod creative_search_fixture;
+mod emitter_particles_probe;
+mod enchanting_fixture;
+mod entity_anim_fixture;
+mod entity_components_probe;
+mod entity_death_loot_fixture;
+mod entity_particles_probe;
+mod environment_fixture;
+mod finalize_spawn_fixture;
+mod fire_starter_sound_probe;
+mod firework_tooltip_fixture;
+mod first_person_probe;
+mod frame_limiter_probe;
+mod game_loop_probe;
+mod ghost_recipe_fixture;
+mod held_drop_fixture;
+mod hotbar_fixture;
+mod hud_fixture;
+mod input_probe;
+mod interaction_input_fixture;
+mod lan_probe;
+mod light_parity;
+mod marker_particles_probe;
+mod menu_fixture;
+mod mipmap_probe;
+mod mob_ai_probe;
+mod mob_attributes_fixture;
+mod music_fixture;
+mod natural_spawn_fixture;
+mod options_probe;
+mod pack_resources_fixture;
+mod pack_screen_fixture;
+mod pack_selection_fixture;
+mod particle_providers_probe;
+mod pick_block_data_fixture;
+mod place_recipe_fixture;
+mod player_sync_fixture;
+mod raid_fixture;
+mod random_tick_sections_probe;
+mod recipe_book_fixture;
+mod recipe_book_render_fixture;
+mod recipe_book_view_fixture;
+mod recipe_fixture;
+mod scene_collision_probe;
+mod scene_motion_probe;
+mod scoreboard_fixture;
+mod screen_layout_fixture;
+mod section_mesh_fixture;
+mod server_files_probe;
+mod situational_music_fixture;
+mod skin_image_fixture;
+mod sound_engine_fixture;
+mod sound_event_fixture;
+mod spawn_rules_fixture;
+mod sprint_probe;
+mod subtitle_fixture;
+mod tab_list_fixture;
+mod team_rules_fixture;
+mod toggle_keys_probe;
+mod tooltip_display_fixture;
+mod trading_fixture;
+mod translucency_fixture;
+mod weather_fixture;
+mod world_border_render_fixture;
+mod world_options_fixture;
+
+probes! {
+    ambient_fixture,
+    arrow_probe,
+    audio_attributes_fixture,
+    auto_jump_probe,
+    block_entity_anim_fixture,
+    block_entity_render_fixture,
+    block_entity_tickers_fixture,
+    block_particles_fixture,
+    block_transform_fixture,
+    breaking_fixture,
+    camera_probe,
+    cauldron_fixture,
+    chat_screen_fixture,
+    cloud_fixture,
+    command_parse_fixture,
+    container_screen_probe,
+    creative_search_fixture,
+    emitter_particles_probe,
+    enchanting_fixture,
+    entity_anim_fixture,
+    entity_components_probe,
+    entity_death_loot_fixture,
+    entity_particles_probe,
+    environment_fixture,
+    finalize_spawn_fixture,
+    fire_starter_sound_probe,
+    firework_tooltip_fixture,
+    first_person_probe,
+    frame_limiter_probe,
+    game_loop_probe,
+    ghost_recipe_fixture,
+    held_drop_fixture,
+    hotbar_fixture,
+    hud_fixture,
+    input_probe,
+    interaction_input_fixture,
+    lan_probe,
+    light_parity,
+    marker_particles_probe,
+    menu_fixture,
+    mipmap_probe,
+    mob_ai_probe,
+    mob_attributes_fixture,
+    music_fixture,
+    natural_spawn_fixture,
+    options_probe,
+    pack_resources_fixture,
+    pack_screen_fixture,
+    pack_selection_fixture,
+    particle_providers_probe,
+    pick_block_data_fixture,
+    place_recipe_fixture,
+    player_sync_fixture,
+    raid_fixture,
+    random_tick_sections_probe,
+    recipe_book_fixture,
+    recipe_book_render_fixture,
+    recipe_book_view_fixture,
+    recipe_fixture,
+    scene_collision_probe,
+    scene_motion_probe,
+    scoreboard_fixture,
+    screen_layout_fixture,
+    section_mesh_fixture,
+    server_files_probe,
+    situational_music_fixture,
+    skin_image_fixture,
+    sound_engine_fixture,
+    sound_event_fixture,
+    spawn_rules_fixture,
+    sprint_probe,
+    subtitle_fixture,
+    tab_list_fixture,
+    team_rules_fixture,
+    toggle_keys_probe,
+    tooltip_display_fixture,
+    trading_fixture,
+    translucency_fixture,
+    weather_fixture,
+    world_border_render_fixture,
+    world_options_fixture,
+}
@@ -22,8 +22,8 @@ use std::{
    sync::Arc,
 };

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(".local/horizon-client/26.3");
    let assets = Assets::load(root)?;
    let facts = BlockFacts::load(root, assets.registry)?;
@@ -58,11 +58,12 @@ fn state(menu: &Menu) -> String {
        .map(|(slot, stack)| format!("{slot}:{}", canon_stack(stack.as_ref())))
        .collect();
    let line = format!(
-        "{} | {} |{data} | {} | {}",
+        "{} | {} |{data} | {} | {} | {}",
        slots.join(" "),
        canon_stack(menu.carried.as_ref()),
        menu.drops.join(";"),
-        equipped.join(";")
+        equipped.join(";"),
+        menu.player_sounds.join(";")
    );
    if menu.kind() != Kind::Lectern {
        return line;
@@ -74,8 +75,8 @@ fn state(menu: &Menu) -> String {
    format!("{line} | inv{items}")
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: menu_fixture RESOURCES INPUT OUTPUT")?,
@@ -171,6 +172,7 @@ fn main() -> horizon_client::Result<()> {
        });
        menu.drops.clear();
        menu.equipped.clear();
+        menu.player_sounds.clear();
        out += &format!("init {}\n", state(&menu));
        for op in case["ops"].as_array().ok_or("ops")? {
            let slot = op[0].as_i64().unwrap_or(0) as i32;
@@ -4,8 +4,8 @@
 //! rows like VanillaMipmapOracle.
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let input = fs::read_to_string(&args[0])?;
    let mut lines = input.lines();
    let root = Path::new(lines.next().ok_or("no resources root")?);
@@ -759,8 +759,8 @@ fn villager(m: &Mob) -> String {
    s
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err("usage: mob_ai_probe RESOURCES SCENARIOS OUTPUT".into());
    }
@@ -6,8 +6,8 @@ use horizon_client::mobs::{Mob, MobTypes};
 use horizon_core::geometry::Vec3;
 use std::{fmt::Write as _, fs, path::Path, sync::Arc};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: mob_attributes_fixture RESOURCES OUTPUT")?,
@@ -1,7 +1,6 @@
 //! Replays `tools/test_music_parity.py` scripts through Horizon's
 //! `MusicManager` over its `SoundEngine`: `music_fixture ROOT INPUT OUTPUT`.
-#[path = "audio_common/mod.rs"]
-mod common;
+use crate::audio_common as common;
 use common::{Fake, describe, f, flush};
 use horizon_client::music::{Music, MusicFrequency, MusicManager};
 use horizon_client::sound_engine::{Bound, MUSIC, SoundEngine, TickContext};
@@ -21,8 +20,8 @@ fn music(spec: &str) -> Option<Music> {
    ))
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1])));
    engine.listening = true;
    let mut backend = Fake::default();
@@ -508,8 +508,8 @@ fn yaw_text(entity: &str, v: f32) -> String {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: natural_spawn_fixture RESOURCES INPUT OUTPUT")?,
@@ -7,8 +7,8 @@ use horizon_client::{
 };
 use std::{fs, io::Write};

-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut names: Vec<_> = fs::read_dir(&args[0])?
        .map(|e| e.map(|e| e.path()))
        .collect::<std::io::Result<_>>()?;
@@ -30,8 +30,8 @@ fn types(root: &std::path::Path, file: PathBuf, key: &str) -> String {
        })
        .collect()
 }
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let input = fs::read_to_string(&args[1])?;
    let mut lines = input.lines();
    let root: Vec<&str> = lines.next().ok_or("empty input")?.split(' ').collect();
@@ -66,8 +66,8 @@ pub fn encode(draws: &[Draw]) -> Value {
    )
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: pack_screen_fixture RESOURCES CASES OUTPUT".into());
    };
@@ -35,8 +35,8 @@ fn lists(m: &SelectionModel) -> Value {
    json!({"unselected": side(false), "selected": side(true)})
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [inputs, output] = args.as_slice() else {
        return Err("usage: pack_selection_fixture INPUTS OUTPUT".into());
    };
@@ -140,8 +140,8 @@ fn world(assets: &Assets, facts: &BlockFacts, floor: bool, water: bool) -> Resul
    Ok(world)
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = &Path::new(".local/horizon-client").join(horizon_core::VANILLA_VERSION);
    let assets = Assets::load(root)?;
    let facts = BlockFacts::load(root, assets.registry)?;
@@ -78,8 +78,8 @@ fn case(line: &str) -> Option<String> {
    Some(out)
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = fs::read_to_string(
        args.get(1)
            .ok_or("usage: pick_block_data_fixture INPUT OUTPUT")?,
@@ -28,8 +28,8 @@ fn state(menu: &Menu) -> String {
    )
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: place_recipe_fixture RESOURCES CASES ORDERS OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -8,8 +8,8 @@ fn number(value: &Value) -> f64 {
    f64::from_bits(u64::from_str_radix(value.as_str().unwrap(), 16).unwrap())
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let input = std::io::BufReader::new(std::fs::File::open(&args[1])?);
    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[2])?);
    for line in input.lines() {
@@ -459,8 +459,8 @@ fn run_codec(c: &BTreeMap<&str, &str>) -> Result<String, String> {
    Ok(log.join(" ; "))
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: raid_fixture RESOURCES INPUT OUTPUT")?,
@@ -51,8 +51,8 @@ impl LevelAccess for Air {
    fn emit(&mut self, _: LevelEvent) {}
 }

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let input = std::fs::read_to_string(&args[1])?;
    let root = input
        .lines()
@@ -57,8 +57,8 @@ fn compound(tag: &Tag) -> String {
    out
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: recipe_book_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -30,8 +30,8 @@ fn round(v: f32) -> f32 {
    (v * 1e4).round() / 1e4
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: recipe_book_render_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -15,8 +15,8 @@ use horizon_client::{
 use serde_json::Value;
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: recipe_book_view_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -12,8 +12,8 @@ use horizon_client::{
 };
 use std::{fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: recipe_fixture RESOURCES INPUT OUTPUT")?,
@@ -28,8 +28,8 @@ fn vector(value: &Value) -> Result<Vec3> {
    };
    Ok(Vec3::new(number(0)?, number(1)?, number(2)?))
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err("usage: scene_collision_probe RESOURCES FIXTURE_DIRECTORY RADIUS".into());
    }
@@ -78,6 +78,7 @@ fn main() -> Result<()> {
        let mut selected = collisions::EntityCollisions {
            blocks: scene,
            entities: &entities,
+            border: None,
        };
        let movement = world_movement::resolve_world_movement(
            &mut selected,
@@ -233,8 +233,8 @@ fn snapshot(out: &mut impl Write, player: &PlayerMotion) -> Result<()> {
    writeln!(out, "events {}", events.join(" | "))?;
    Ok(())
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err(
            "usage: scene_motion_probe RESOURCES FIXTURE_DIRECTORY --describe|REFERENCE".into(),
@@ -370,8 +370,8 @@ fn score_json(sc: &sb::Score) -> Value {
    })
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let registries: Value =
        serde_json::from_str(&fs::read_to_string(&args[1]).expect("registries")).expect("json");
    let list = |k: &str| -> Vec<String> {
@@ -60,8 +60,8 @@ fn draw_json(d: &ScreenDraw) -> Value {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: screen_layout_fixture RESOURCES INPUT OUTPUT";
    let banners = Banners::load(Path::new(args.get(1).ok_or(usage)?));
    let input = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -170,8 +170,8 @@ fn scene(
    }
    Ok(json!({"name": row["name"], "quads": quads}))
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err(
            "usage: section_mesh_fixture RESOURCES (INPUT.jsonl | facts) OUTPUT.jsonl".into(),
@@ -11,8 +11,8 @@ use horizon_client::server::{
 use horizon_protocol::crypto::uuid_string;
 use std::{fmt::Write as _, path::Path};

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args = std::env::args().skip(1);
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = crate::args().skip(1);
    let root = std::path::PathBuf::from(args.next().ok_or("CASES OUTPUT")?);
    let output = args.next().ok_or("OUTPUT")?;
    let mut cases: Vec<_> = std::fs::read_dir(&root)?
@@ -5,8 +5,8 @@ use horizon_client::music::{BackgroundMusic, Music, MusicTables, Situation};
 use horizon_client::sound_events::normalize;
 use std::io::Write;

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let tables = MusicTables::load(std::path::Path::new(&args[1]));
    let input = std::fs::read_to_string(&args[2]).expect("input");
    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output"));
@@ -9,8 +9,8 @@ use std::{
 };
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [inputs, output] = args.as_slice() else {
        return Err("usage: skin_image_fixture INPUTS OUTPUT".into());
    };
@@ -1,8 +1,7 @@
 //! Replays `tools/test_sound_engine_parity.py` scripts through Horizon's
 //! `SoundEngine` with a backend recording what an OpenAL source would hold:
 //! `sound_engine_fixture ROOT INPUT OUTPUT`.
-#[path = "audio_common/mod.rs"]
-mod common;
+use crate::audio_common as common;
 use common::{Fake, d, describe, f, flush, result_name};
 use horizon_client::sound_engine::{
    Attenuation, Backend, CartSound, InstanceId, SoundEngine, SoundInstance, TickContext,
@@ -12,8 +11,8 @@ use horizon_core::random::LegacyRandom;
 use std::collections::BTreeMap;
 use std::io::Write;

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1])));
    engine.listening = true;
    let mut backend = Fake::default();
@@ -9,8 +9,8 @@ fn bits(v: f32) -> String {
    format!("{:08x}", v.to_bits())
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let registry = SoundRegistry::load(std::path::Path::new(&args[1]));
    let mut engine = SoundEngine::new(registry);
    let input = std::fs::read_to_string(&args[2]).expect("input");
@@ -136,8 +136,8 @@ fn reason(name: &str) -> Reason {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: spawn_rules_fixture RESOURCES INPUT OUTPUT")?,
@@ -20,8 +20,8 @@ fn keys(mask: u64) -> Keys {
        analog: None,
    }
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut out = BufWriter::new(File::create(&args[1])?);
    for line in BufReader::new(File::open(&args[0])?).lines() {
        let f: Value = serde_json::from_str(&line?)?;
@@ -21,8 +21,8 @@ fn pose(m: [f32; 6]) -> Value {
    json!(m)
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: subtitle_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -53,8 +53,8 @@ fn runs(t: &Text) -> Value {
    out.into_iter().map(|(r, k)| json!([r, k])).collect()
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: tab_list_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -8,8 +8,8 @@ use horizon_client::scoreboard::{self as sb, CollisionRule, NameView, Scoreboard
 use serde_json::{Value, json};
 use std::{fs, io::Write};

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut out = std::io::BufWriter::new(fs::File::create(&args[2]).expect("output"));
    for line in fs::read_to_string(&args[1]).expect("inputs").lines() {
        let c: Value = serde_json::from_str(line).expect("case");
@@ -11,8 +11,8 @@ use std::{
    io::{BufRead, BufReader, BufWriter, Write},
 };

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -3,8 +3,8 @@ use horizon_client::{item_tooltip::TooltipDisplay, items::ItemStack};
 use horizon_world::nbt::Tag;
 use std::{error::Error, fmt::Write};

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let mut output = String::new();
    for line in std::fs::read_to_string(&args[1])?.lines() {
        let fields: Vec<&str> = line.split('\t').collect();
@@ -231,8 +231,8 @@ fn prepare(m: &mut Merchant, gossips: &mut Gossips, kv: &HashMap<String, String>
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: trading_fixture RESOURCES INPUT VANILLA_OUTPUT OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let input = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -14,8 +14,8 @@ struct Case {
    cameras: Vec<[f64; 3]>,
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let [input, output] = args.as_slice() else {
        return Err("usage: translucency_fixture INPUT OUTPUT".into());
    };
@@ -8,8 +8,8 @@ fn bits(value: f32) -> String {
        format!("{:x}", value.to_bits())
    }
 }
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let mut output = String::new();
    let mut parameters = weather::ParameterCache::default();
    for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() {
@@ -24,8 +24,8 @@ fn doubles(v: &[f64]) -> Value {
    v.iter().map(|f| f.to_bits() as i64).collect()
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let [inputs, output] = args.as_slice() else {
        return Err("usage: world_border_render_fixture INPUTS OUTPUT".into());
    };
@@ -2,8 +2,8 @@
 use horizon_protocol::{buf::Reader, packets::play::*};
 use std::{error::Error, fmt::Write};

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let mut output = String::new();
    for line in std::fs::read_to_string(&args[1])?.lines() {
        let fields: Vec<&str> = line.split('\t').collect();
@@ -1,128 +0,0 @@
-//! The region writer on real chunks, without a window: how long a world's
-//! chunks take to be encoded, compressed and written by `SaveDir`, against
-//! the same encoding and compression done one chunk after another (what the
-//! writer thread did alone before it had helpers).
-//!
-//! save_bench RESOURCES DIMENSION_DIR [--rounds N]
-//!
-//! DIMENSION_DIR is a saved dimension folder (`saves/W/dimensions/minecraft/
-//! overworld`); its chunks are read once, then each round saves them all into
-//! a scratch folder with `save_later` + `flush`, and times the one-thread
-//! baseline. The written chunks are checked byte for byte against the
-//! baseline's compressed records.
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    save::{SaveDir, SaveTables, encode_with},
-};
-use horizon_core::position::ChunkPos;
-use horizon_world::{
-    compression::Compression,
-    nbt::Limits,
-    region::{ChunkRecord, RegionFile},
-};
-use std::{path::PathBuf, sync::Arc, time::Instant};
-
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let usage = "usage: save_bench RESOURCES DIMENSION_DIR [--rounds N]";
-    let root = PathBuf::from(args.first().ok_or(usage)?);
-    let dimension = PathBuf::from(args.get(1).ok_or(usage)?);
-    let rounds: usize = args
-        .iter()
-        .position(|a| a == "--rounds")
-        .and_then(|i| args.get(i + 1))
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(5);
-
-    let assets = Assets::load(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Arc::new(Biomes::load(&root)?);
-    let tables = Arc::new(SaveTables::new(&assets).with_block_entities(&facts));
-    let registry = assets.registry;
-
-    let source = SaveDir::new(dimension.clone());
-    let _ = source.tables.set(tables.clone());
-    let mut chunks = Vec::new();
-    for entry in std::fs::read_dir(dimension.join("region"))? {
-        let path = entry?.path();
-        if path.extension().is_none_or(|e| e != "mca") {
-            continue;
-        }
-        let region = RegionFile::open(&path)?;
-        for (pos, _) in region.chunks() {
-            if let Some(chunk) = source.load(pos.x, pos.z, registry, &biomes) {
-                chunks.push(Arc::new(chunk));
-            }
-        }
-    }
-    chunks.sort_by_key(|c| (c.x, c.z));
-    println!("{} chunks from {}", chunks.len(), dimension.display());
-
-    let scratch = std::env::temp_dir().join(format!("save_bench_{}", std::process::id()));
-    // Encoding and compressing on one thread (what the writer did alone),
-    // then SaveDir's writer with its helpers.
-    let mut times = [Vec::new(), Vec::new(), Vec::new()];
-    let mut written = Vec::new();
-    for round in 0..rounds {
-        let started = Instant::now();
-        let tags: Vec<_> = chunks
-            .iter()
-            .map(|c| encode_with(c, registry, &biomes, Some(&tables), true))
-            .collect();
-        times[0].push(started.elapsed().as_secs_f64());
-        let started = Instant::now();
-        let baseline: Vec<ChunkRecord> = tags
-            .iter()
-            .map(|tag| ChunkRecord::from_nbt(tag, Compression::Zlib, 0, Limits::default()))
-            .collect::<std::io::Result<_>>()?;
-        times[1].push(started.elapsed().as_secs_f64());
-        drop(tags);
-
-        let _ = std::fs::remove_dir_all(&scratch);
-        let save = SaveDir::new(scratch.clone());
-        let _ = save.tables.set(tables.clone());
-        let started = Instant::now();
-        save.save_later(&chunks, registry, &biomes)?;
-        save.flush().unwrap();
-        times[2].push(started.elapsed().as_secs_f64());
-        drop(save);
-
-        if round == 0 {
-            for (chunk, want) in chunks.iter().zip(&baseline) {
-                let path = scratch.join(format!("region/r.{}.{}.mca", chunk.x >> 5, chunk.z >> 5));
-                let got = RegionFile::open(&path)?
-                    .read(ChunkPos::new(chunk.x, chunk.z))?
-                    .ok_or("a saved chunk is missing")?;
-                if got.compressed != want.compressed {
-                    return Err(format!("chunk {} {} differs", chunk.x, chunk.z).into());
-                }
-            }
-            written = baseline.iter().map(|r| r.compressed.len()).collect();
-        }
-    }
-    let _ = std::fs::remove_dir_all(&scratch);
-    println!(
-        "{} KiB compressed, identical to the one-thread records",
-        written.iter().sum::<usize>() / 1024
-    );
-    let per_chunk = 1000.0 / chunks.len() as f64;
-    let names = [
-        "one thread: encode",
-        "one thread: compress",
-        "SaveDir (encode, compress, write)",
-    ];
-    for (name, t) in names.iter().zip(&mut times) {
-        t.sort_by(f64::total_cmp);
-        println!(
-            "{name}: best {:.0} ms, median {:.0} ms of {rounds} ({:.3} ms per chunk at best)",
-            t[0] * 1000.0,
-            t[t.len() / 2] * 1000.0,
-            t[0] * per_chunk
-        );
-    }
-    Ok(())
-}
@@ -1,265 +0,0 @@
-//! Differential save test: load every full chunk of a world written by the
-//! vanilla 26.3 server, light it, encode it again with Horizon's chunk writer
-//! and compare the result with the original NBT: block states, biomes,
-//! heightmaps, light layers (by value), block entities and scheduled ticks.
-//!
-//! cargo run --profile fast -p horizon-client --example save_parity -- \
-//!     RESOURCES DIMENSION_DIR [--nether]
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    chunk::{Chunk, MIN_Y, SECTIONS},
-    light::{LightTables, apply_lighting, light_chunk},
-    save::{self, SaveTables},
-};
-use horizon_core::position::ChunkPos;
-use horizon_world::{
-    chunk::BlockState,
-    nbt::{Limits, NamedTag, Tag},
-    region::RegionFile,
-};
-use std::{
-    collections::{BTreeMap, HashMap},
-    path::PathBuf,
-};
-
-/// Block state names per section index, decoded independently of Horizon.
-fn block_names(tag: &Tag) -> BTreeMap<i64, Vec<String>> {
-    let mut out = BTreeMap::new();
-    let Some(Tag::List(sections)) = tag.get("sections") else {
-        return out;
-    };
-    for s in sections {
-        let Some(Tag::Byte(y)) = s.get("Y") else {
-            continue;
-        };
-        let Some(states) = s.get("block_states") else {
-            continue;
-        };
-        let Some(Tag::List(palette)) = states.get("palette") else {
-            continue;
-        };
-        let names: Vec<String> = palette
-            .iter()
-            .map(|p| {
-                let st = BlockState::from_nbt(p).expect("palette entry");
-                format!("{}{:?}", st.name, st.properties)
-            })
-            .collect();
-        let bits = (usize::BITS - (names.len().max(1) - 1).leading_zeros()).max(4);
-        let per = 64 / bits as usize;
-        let data = match states.get("data") {
-            Some(Tag::LongArray(d)) => d.clone(),
-            _ => Vec::new(),
-        };
-        let blocks = (0..4096)
-            .map(|i| {
-                if names.len() == 1 {
-                    return names[0].clone();
-                }
-                let v = (data[i / per] as u64 >> ((i % per) as u32 * bits)) & ((1 << bits) - 1);
-                names[v as usize].clone()
-            })
-            .collect();
-        out.insert(i64::from(*y), blocks);
-    }
-    out
-}
-fn light(tag: &Tag, key: &str) -> HashMap<i64, Vec<u8>> {
-    let mut out = HashMap::new();
-    if let Some(Tag::List(sections)) = tag.get("sections") {
-        for s in sections {
-            if let (Some(Tag::Byte(y)), Some(Tag::ByteArray(a))) = (s.get("Y"), s.get(key)) {
-                out.insert(i64::from(*y), a.clone());
-            }
-        }
-    }
-    out
-}
-/// Light value with vanilla's reading of missing layers.
-fn value(
-    layers: &HashMap<i64, Vec<u8>>,
-    sy: i64,
-    i: usize,
-    sky: bool,
-    empty: bool,
-    top: i64,
-) -> u8 {
-    let nibble = |a: &Vec<u8>, i: usize| (a[i >> 1] >> ((i & 1) * 4)) & 15;
-    if let Some(a) = layers.get(&sy) {
-        return nibble(a, i);
-    }
-    if !sky || !empty {
-        return 0;
-    }
-    ((sy + 1)..=top)
-        .find_map(|y| layers.get(&y))
-        .map_or(15, |a| nibble(a, i & 255))
-}
-fn count(tag: &Tag, key: &str) -> usize {
-    match tag.get(key) {
-        Some(Tag::List(l)) => l.len(),
-        _ => 0,
-    }
-}
-
-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let root = PathBuf::from(
-        args.first()
-            .ok_or("usage: save_parity RESOURCES DIMENSION_DIR")?,
-    );
-    let dim = PathBuf::from(args.get(1).ok_or("missing dimension directory")?);
-    let sky_light = !args.iter().any(|a| a == "--nether");
-    let assets = Assets::load(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Biomes::load(&root)?;
-    let lights = LightTables::load(&root, assets.registry, &facts)?;
-    let tables = SaveTables::new(&assets).with_block_entities(&facts);
-    let mut originals: HashMap<(i32, i32), NamedTag> = HashMap::new();
-    let mut chunks: HashMap<(i32, i32), Chunk> = HashMap::new();
-    for entry in std::fs::read_dir(dim.join("region"))? {
-        let mut region = RegionFile::open(entry?.path())?;
-        let positions: Vec<ChunkPos> = region.chunks().map(|(p, _)| p).collect();
-        for p in positions {
-            let Some(record) = region.read(p)? else {
-                continue;
-            };
-            let tag = record.nbt(Limits::default())?;
-            if tag.tag.get("isLightOn") != Some(&Tag::Byte(1)) {
-                continue;
-            }
-            if let Some(c) = save::decode_with(&tag, assets.registry, &biomes, Some(&tables)) {
-                chunks.insert((c.x, c.z), c);
-                originals.insert((p.x, p.z), tag);
-            }
-        }
-    }
-    let mut keys: Vec<_> = chunks
-        .keys()
-        .copied()
-        .filter(|&(x, z)| {
-            (-1..=1).all(|dz| (-1..=1).all(|dx| chunks.contains_key(&(x + dx, z + dz))))
-        })
-        .collect();
-    keys.sort_unstable();
-    let (
-        mut blocks_bad,
-        mut biomes_bad,
-        mut heightmaps_bad,
-        mut light_bad,
-        mut light_total,
-        mut other_bad,
-    ) = (0, 0, 0, 0u64, 0u64, 0);
-    for &(x, z) in &keys {
-        let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
-            std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
-        });
-        let mut chunk = chunks[&(x, z)].clone();
-        apply_lighting(&mut chunk, light_chunk(&region, &lights, sky_light));
-        chunk.lit = true;
-        let ours = save::encode_with(&chunk, assets.registry, &biomes, Some(&tables), sky_light);
-        let theirs = &originals[&(x, z)];
-        let (a, b) = (&ours.tag, &theirs.tag);
-        // Block states: compare every non-empty vanilla section.
-        let (na, nb) = (block_names(a), block_names(b));
-        for (y, vb) in &nb {
-            match na.get(y) {
-                Some(va) if va == vb => {}
-                Some(va) => {
-                    let n = va.iter().zip(vb).filter(|(p, q)| p != q).count();
-                    if blocks_bad < 5 {
-                        let i = va.iter().zip(vb).position(|(p, q)| p != q).unwrap_or(0);
-                        eprintln!(
-                            "chunk {x} {z} section {y}: {n} blocks differ, e.g. {} vs {}",
-                            va[i], vb[i]
-                        );
-                    }
-                    blocks_bad += 1;
-                }
-                None if vb.iter().all(|s| s.starts_with("minecraft:air")) => {}
-                None => blocks_bad += 1,
-            }
-        }
-        let biome_of = |t: &Tag| -> Vec<Tag> {
-            match t.get("sections") {
-                Some(Tag::List(l)) => l.iter().filter_map(|s| s.get("biomes").cloned()).collect(),
-                _ => Vec::new(),
-            }
-        };
-        if biome_of(a) != biome_of(b) {
-            biomes_bad += 1;
-        }
-        for kind in [
-            "WORLD_SURFACE",
-            "OCEAN_FLOOR",
-            "MOTION_BLOCKING",
-            "MOTION_BLOCKING_NO_LEAVES",
-        ] {
-            let get = |t: &Tag| t.get("Heightmaps").and_then(|h| h.get(kind)).cloned();
-            if get(a) != get(b) {
-                if heightmaps_bad < 5 {
-                    eprintln!("chunk {x} {z}: heightmap {kind} differs");
-                }
-                heightmaps_bad += 1;
-            }
-        }
-        for (key, sky) in [("SkyLight", true), ("BlockLight", false)] {
-            if sky && !sky_light {
-                continue;
-            }
-            let (la, lb) = (light(a, key), light(b, key));
-            let top = i64::from((MIN_Y >> 4) + SECTIONS as i32);
-            for si in 0..SECTIONS {
-                let sy = i64::from((MIN_Y >> 4) + si as i32);
-                let empty = chunk.sections[si].is_uniform(tables_air(&assets));
-                for i in 0..4096 {
-                    light_total += 1;
-                    if value(&la, sy, i, sky, empty, top) != value(&lb, sy, i, sky, empty, top) {
-                        light_bad += 1;
-                    }
-                }
-            }
-        }
-        for key in ["block_entities", "block_ticks", "fluid_ticks"] {
-            if count(a, key) != count(b, key) {
-                if other_bad < 5 {
-                    eprintln!(
-                        "chunk {x} {z}: {key} {} vs {}",
-                        count(a, key),
-                        count(b, key)
-                    );
-                }
-                other_bad += 1;
-            }
-        }
-        for key in [
-            "structures",
-            "PostProcessing",
-            "InhabitedTime",
-            "Status",
-            "DataVersion",
-            "yPos",
-        ] {
-            if a.get(key) != b.get(key) {
-                if other_bad < 5 {
-                    eprintln!("chunk {x} {z}: {key} differs");
-                }
-                other_bad += 1;
-            }
-        }
-    }
-    println!(
-        "{} chunks: {blocks_bad} sections with different blocks, {biomes_bad} chunks with different biomes, \
-         {heightmaps_bad} different heightmaps, {light_bad} of {light_total} light values differ, {other_bad} other differences",
-        keys.len()
-    );
-    Ok(())
-}
-fn tables_air(assets: &Assets) -> u32 {
-    assets
-        .registry
-        .default_state("minecraft:air")
-        .map_or(0, |s| s.0)
-}
@@ -1,284 +0,0 @@
-//! The chunk pipeline (generation, decoration, lighting, meshing) on its worker
-//! pool, without a window: how fast a render distance fills with N workers, and
-//! what the render thread pays for it in `Streaming::update`.
-//!
-//! streaming_bench RESOURCES [--threads N] [--radius R] [--seed S] [--fly CHUNKS_PER_S] [--seconds T] [--hz F]
-//!     [--dimension overworld|the_nether|the_end] [--center-x X] [--center-z Z]
-//!
-//! First the area around (0, 0) fills; then, with `--fly`, the centre moves along +x
-//! at that speed for T seconds while frames run at F per second. Each phase reports
-//! its wall time, chunks generated and sections meshed, and the time `update`
-//! took on the calling thread (the render thread in the game): total, median,
-//! p99 and slowest. Compile with HORIZON_BENCH_COUNT_ALLOCATIONS=1 to count the
-//! allocations made on the calling thread during updates and by everything.
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    light::LightTables,
-    mesher::MeshTables,
-    models,
-    streaming::{Streaming, WorkerContext},
-    vanillagen::VanillaTerrain,
-    world::World,
-};
-use std::{
-    alloc::{GlobalAlloc, Layout, System},
-    cell::Cell,
-    path::PathBuf,
-    sync::{
-        Arc,
-        atomic::{AtomicU64, Ordering::Relaxed},
-    },
-    time::{Duration, Instant},
-};
-
-const TRACK: bool = option_env!("HORIZON_BENCH_COUNT_ALLOCATIONS").is_some();
-static ALLOCATIONS: AtomicU64 = AtomicU64::new(0);
-static BYTES: AtomicU64 = AtomicU64::new(0);
-thread_local! {
-    static LOCAL: Cell<(u64, u64)> = const { Cell::new((0, 0)) };
-}
-fn count(size: usize) {
-    if TRACK {
-        ALLOCATIONS.fetch_add(1, Relaxed);
-        BYTES.fetch_add(size as u64, Relaxed);
-        let _ = LOCAL.try_with(|c| {
-            let (n, b) = c.get();
-            c.set((n + 1, b + size as u64));
-        });
-    }
-}
-struct CountingAllocator;
-// Delegates every operation and layout unchanged to System.
-unsafe impl GlobalAlloc for CountingAllocator {
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        count(layout.size());
-        unsafe { System.alloc(layout) }
-    }
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        count(layout.size());
-        unsafe { System.alloc_zeroed(layout) }
-    }
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        unsafe { System.dealloc(ptr, layout) };
-    }
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, size: usize) -> *mut u8 {
-        count(size);
-        unsafe { System.realloc(ptr, layout, size) }
-    }
-}
-#[global_allocator]
-static ALLOCATOR: CountingAllocator = CountingAllocator;
-
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn cpu_seconds() -> f64 {
-    std::fs::read_to_string("/proc/self/stat")
-        .ok()
-        .and_then(|stat| {
-            let fields = stat
-                .rsplit_once(')')?
-                .1
-                .split_whitespace()
-                .collect::<Vec<_>>();
-            Some((fields[11].parse::<f64>().ok()? + fields[12].parse::<f64>().ok()?) / 100.0)
-        })
-        .unwrap_or(0.0)
-}
-
-#[derive(Default)]
-struct Phase {
-    updates: Vec<f64>,
-    local: (u64, u64),
-    uploads: usize,
-    stage_samples: [u64; 7],
-    cpu_start: f64,
-}
-impl Phase {
-    fn update(&mut self, streaming: &mut Streaming, world: &mut World) {
-        if self.updates.is_empty() {
-            self.cpu_start = cpu_seconds();
-        }
-        let before = LOCAL.with(Cell::get);
-        let started = Instant::now();
-        let (uploads, _) = streaming.update(world);
-        self.updates.push(started.elapsed().as_secs_f64() * 1e3);
-        let after = LOCAL.with(Cell::get);
-        self.local.0 += after.0 - before.0;
-        self.local.1 += after.1 - before.1;
-        self.uploads += uploads.len();
-        drop(uploads);
-        for (sum, (_, count)) in self.stage_samples.iter_mut().zip(streaming.stages()) {
-            *sum += count as u64;
-        }
-    }
-    fn report(&self, name: &str, wall: Duration, streaming: &Streaming, generated: u64) {
-        let mut sorted = self.updates.clone();
-        sorted.sort_by(f64::total_cmp);
-        let at = |p: f64| sorted[((sorted.len() as f64 * p) as usize).min(sorted.len() - 1)];
-        let total: f64 = sorted.iter().sum();
-        println!(
-            "{name}: {:.2} s, {} chunks generated, {} sections meshed; update {:.1} ms total over {} calls, p50 {:.3} p99 {:.3} max {:.2} ms",
-            wall.as_secs_f64(),
-            streaming.generated_total - generated,
-            self.uploads,
-            total,
-            sorted.len(),
-            at(0.5),
-            at(0.99),
-            sorted.last().copied().unwrap_or(0.0),
-        );
-        println!(
-            "BENCH {}",
-            serde_json::json!({
-                "phase": name, "wall_s": wall.as_secs_f64(),
-                "cpu_s": cpu_seconds() - self.cpu_start,
-                "chunks": streaming.generated_total - generated, "sections": self.uploads,
-                "updates": self.updates.len(), "update_ms": total,
-                "mean_stages": self.stage_samples.map(|n| n as f64 / self.updates.len() as f64),
-            })
-        );
-        if TRACK {
-            println!(
-                "  update allocations: {} ({:.1} MiB)",
-                self.local.0,
-                self.local.1 as f64 / 1048576.0
-            );
-        }
-    }
-}
-
-/// Nothing queued or in flight. Sections at the edge of the area stay dirty
-/// (their outer neighbours are never lit), so they don't count.
-fn settled(streaming: &Streaming) -> bool {
-    streaming
-        .stages()
-        .iter()
-        .all(|&(name, n)| name == "protos" || n == 0)
-}
-
-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let root = PathBuf::from(args.first().ok_or("usage: streaming_bench RESOURCES")?);
-    let flag = |name: &str, default: f64| -> f64 {
-        args.iter()
-            .position(|a| a == name)
-            .and_then(|i| args.get(i + 1))
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(default)
-    };
-    let auto = std::thread::available_parallelism().map_or(2, |n| n.get() - 1);
-    let threads = flag("--threads", auto as f64) as usize;
-    let radius = flag("--radius", 8.0) as i32;
-    let seed = flag("--seed", 1234.0) as i64;
-    let fly = flag("--fly", 0.0);
-    let seconds = flag("--seconds", 10.0);
-    let hz = flag("--hz", 240.0);
-    let dimension = args
-        .iter()
-        .position(|a| a == "--dimension")
-        .and_then(|i| args.get(i + 1))
-        .map(|d| {
-            if d.contains(':') {
-                d.clone()
-            } else {
-                format!("minecraft:{d}")
-            }
-        })
-        .unwrap_or_else(|| "minecraft:overworld".into());
-    let center = (
-        flag("--center-x", 0.0) as i32,
-        flag("--center-z", 0.0) as i32,
-    );
-
-    let assets = Arc::new(Assets::load(&root)?);
-    let render = Arc::new(assets.reload(&root)?);
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Arc::new(Biomes::load(&root)?);
-    let tables = Arc::new(MeshTables::new(
-        &assets,
-        &render,
-        &facts,
-        models::load_visibility(&root, assets.registry)?,
-    )?);
-    let light = Arc::new(LightTables::load(&root, assets.registry, &facts)?);
-    let terrain = Arc::new(VanillaTerrain::for_dimension(
-        &root.join("worldgen"),
-        assets.registry,
-        &biomes,
-        seed,
-        &dimension,
-    )?);
-    let context = Arc::new(WorkerContext {
-        assets,
-        render: render.clone(),
-        tables,
-        biomes,
-        light,
-    });
-    let mut world = World::new(facts.air, seed);
-    let mut streaming = Streaming::new(terrain, context, threads);
-    streaming.radius = radius;
-    streaming.center = center;
-    streaming.nether_shading = dimension == "minecraft:the_nether";
-    streaming.sky_light = dimension != "minecraft:the_nether";
-    println!(
-        "{threads} workers, radius {radius}, seed {seed}, dimension {dimension}, center {center:?}"
-    );
-    let (allocations, bytes) = (ALLOCATIONS.load(Relaxed), BYTES.load(Relaxed));
-
-    // Fill: update as often as the game would uncapped, until settled.
-    let mut phase = Phase::default();
-    let started = Instant::now();
-    let mut quiet = 0;
-    while quiet < 20 {
-        let uploads = phase.uploads;
-        phase.update(&mut streaming, &mut world);
-        quiet = if settled(&streaming) && phase.uploads == uploads {
-            quiet + 1
-        } else {
-            0
-        };
-        std::thread::sleep(Duration::from_micros(500));
-    }
-    phase.report("fill", started.elapsed(), &streaming, 0);
-
-    if fly > 0.0 {
-        let mut phase = Phase::default();
-        let generated = streaming.generated_total;
-        let frame = Duration::from_secs_f64(1.0 / hz);
-        let started = Instant::now();
-        let mut behind = Vec::new();
-        while started.elapsed().as_secs_f64() < seconds {
-            let next = Instant::now() + frame;
-            let x = center.0 + (started.elapsed().as_secs_f64() * fly) as i32;
-            streaming.center = (x, center.1);
-            phase.update(&mut streaming, &mut world);
-            // Columns within 2 chunks of the player still missing their meshes.
-            let near = (-2..=2)
-                .flat_map(|dz| (-2..=2).map(move |dx| (x + dx, center.1 + dz)))
-                .filter(|&(cx, cz)| !streaming.is_lit(cx, cz))
-                .count();
-            behind.push(near);
-            if let Some(wait) = next.checked_duration_since(Instant::now()) {
-                std::thread::sleep(wait);
-            }
-        }
-        phase.report("fly", started.elapsed(), &streaming, generated);
-        let unlit = behind.iter().filter(|&&n| n > 0).count();
-        println!(
-            "  frames with an unlit column within 2 chunks of the player: {unlit} of {} ({:.1}%)",
-            behind.len(),
-            unlit as f64 * 100.0 / behind.len().max(1) as f64
-        );
-    }
-    if TRACK {
-        println!(
-            "all threads: {} allocations ({:.1} MiB)",
-            ALLOCATIONS.load(Relaxed) - allocations,
-            (BYTES.load(Relaxed) - bytes) as f64 / 1048576.0
-        );
-    }
-    Ok(())
-}
@@ -1,143 +0,0 @@
-//! Resident-key synchronization used by Game (registration callback work excluded).
-//! Run: CARGO_INCREMENTAL=0 cargo run -p horizon-client --profile fast --example tick_chunk_membership_bench
-use horizon_client::{
-    chunk::Chunk, chunk_map::ChunkMap, tick_chunk_membership::TickChunkMembership,
-};
-use std::{collections::HashSet, hint::black_box, sync::Arc, time::Instant};
-
-type Key = (i32, i32);
-#[derive(Default)]
-struct Old {
-    keys: HashSet<Key>,
-}
-impl Old {
-    fn sync(&mut self, map: &ChunkMap) -> (usize, usize) {
-        let loaded: HashSet<_> = map.keys().copied().collect();
-        let mut counts = (0, 0);
-        for key in loaded.difference(&self.keys.clone()) {
-            black_box(key);
-            counts.0 += 1;
-        }
-        for key in self.keys.difference(&loaded) {
-            black_box(key);
-            counts.1 += 1;
-        }
-        self.keys = loaded;
-        counts
-    }
-}
-fn new_sync(cache: &mut TickChunkMembership, map: &ChunkMap) -> (usize, usize) {
-    if !cache.synchronize(map) {
-        return (0, 0);
-    }
-    let added = cache.take_added();
-    for key in &added {
-        black_box(key);
-    }
-    for key in cache.removed() {
-        black_box(key);
-    }
-    let counts = (added.len(), cache.removed().len());
-    cache.recycle_added(added);
-    counts
-}
-fn map(offset: i32) -> ChunkMap {
-    let mut map = ChunkMap::default();
-    // Share a payload: the synchronization path reads only keys, not block data.
-    let chunk = Arc::new(Chunk::empty(0, 0));
-    for x in -16..=16 {
-        for z in -16..=16 {
-            map.insert((x + offset, z), chunk.clone());
-        }
-    }
-    map
-}
-fn run(new: bool, scenario: usize, iterations: usize) -> (f64, (usize, usize)) {
-    let mut a = map(0);
-    let b = map(33);
-    let chunk = Arc::new(Chunk::empty(0, 0));
-    let mut old = Old::default();
-    let mut cache = TickChunkMembership::default();
-    for _ in 0..64 {
-        if new {
-            black_box(new_sync(&mut cache, &a));
-        } else {
-            black_box(old.sync(&a));
-        }
-    }
-    let mut total = (0, 0);
-    let start = Instant::now();
-    for i in 0..iterations {
-        let resident = match scenario {
-            0 => &a,
-            1 => {
-                let (previous, next) = if i % 2 == 0 {
-                    ((-16, -16), (-17, -16))
-                } else {
-                    ((-17, -16), (-16, -16))
-                };
-                a.remove(&previous);
-                a.insert(next, chunk.clone());
-                &a
-            }
-            2 => {
-                if i % 2 == 0 {
-                    &b
-                } else {
-                    &a
-                }
-            }
-            _ => unreachable!(),
-        };
-        let counts = if new {
-            new_sync(black_box(&mut cache), black_box(resident))
-        } else {
-            old.sync(black_box(resident))
-        };
-        total.0 += counts.0;
-        total.1 += counts.1;
-    }
-    (
-        start.elapsed().as_secs_f64() * 1e9 / iterations as f64,
-        black_box(total),
-    )
-}
-fn main() {
-    println!("1089 keys, 64 warmup calls, 9 samples; ns/sync, median");
-    for (scenario, name, iterations) in [
-        (0, "stable", 10_000),
-        (1, "one-key same-count replacement", 2_000),
-        (2, "whole-map replacement", 1_000),
-    ] {
-        let mut before = Vec::new();
-        let mut after = Vec::new();
-        for sample in 0..9 {
-            let (old, new) = if sample % 2 == 0 {
-                (
-                    run(false, scenario, iterations),
-                    run(true, scenario, iterations),
-                )
-            } else {
-                let new = run(true, scenario, iterations);
-                (run(false, scenario, iterations), new)
-            };
-            assert_eq!(old.1, new.1);
-            let expected = match scenario {
-                0 => (0, 0),
-                1 => (iterations, iterations),
-                _ => (1089 * iterations, 1089 * iterations),
-            };
-            assert_eq!(new.1, expected);
-            before.push(old.0);
-            after.push(new.0);
-        }
-        before.sort_by(f64::total_cmp);
-        after.sort_by(f64::total_cmp);
-        println!(
-            "{name}: {:.1} -> {:.1} ns, {:.2}x; {iterations} iterations/sample",
-            before[4],
-            after[4],
-            before[4] / after[4]
-        );
-    }
-}
@@ -708,6 +708,13 @@ impl Audio {
        let seed = self.random.next_long();
        self.play_seeded(event, at, volume, pitch, seed);
    }
+    /// `play` for this client only: a sound a packet's handler plays
+    /// (`playLocalSound`), which the guests play from that packet themselves.
+    pub fn play_unshared(&mut self, event: &str, at: Option<[f64; 3]>, volume: f32, pitch: f32) {
+        let capture = self.capture.take();
+        self.play(event, at, volume, pitch);
+        self.capture = capture;
+    }
    /// `LivingEntity.handleDamageEvent`'s pitch, `(r - r) * 0.2 + 1`, drawn on the
    /// client (the entity's own random there, never the server's world random).
    pub fn hurt_pitch(&mut self) -> f32 {
@@ -0,0 +1,192 @@
+//! `BundleContents.Mutable`: what a bundle takes in and gives back, by
+//! weight. The menus (`menu`, `lan::menu`) run `BundleItem`'s click
+//! overrides on it.
+use crate::items::{ItemStack, Items};
+use horizon_world::nbt::Tag;
+
+/// A bundle weight: vanilla's `Fraction`, exact and kept reduced.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct Weight {
+    n: i128,
+    d: i128,
+}
+
+fn gcd(a: i128, b: i128) -> i128 {
+    let (mut a, mut b) = (a.abs(), b.abs());
+    while b != 0 {
+        (a, b) = (b, a % b);
+    }
+    a.max(1)
+}
+
+impl Weight {
+    const ZERO: Self = Self { n: 0, d: 1 };
+    const ONE: Self = Self { n: 1, d: 1 };
+
+    fn new(n: i128, d: i128) -> Self {
+        let g = gcd(n, d);
+        Self { n: n / g, d: d / g }
+    }
+
+    fn add(self, o: Self) -> Self {
+        Self::new(self.n * o.d + o.n * self.d, self.d * o.d)
+    }
+
+    fn sub(self, o: Self) -> Self {
+        self.add(Self { n: -o.n, d: o.d })
+    }
+
+    fn times(self, count: u32) -> Self {
+        Self::new(self.n * i128::from(count), self.d)
+    }
+
+    /// `this.divideBy(item).intValue()` (truncated), at least 0.
+    fn how_many(self, item: Self) -> u32 {
+        let q = (self.n * item.d) / (self.d * item.n);
+        u32::try_from(q.max(0)).unwrap_or(u32::MAX)
+    }
+}
+
+/// The sounds of `BundleItem` (`Entity.playSound` at the player): insert
+/// and remove one at volume 0.8 and pitch `0.8 + random * 0.4`, a failed
+/// insert at 1, 1.
+pub const INSERT: &str = "minecraft:item.bundle.insert";
+pub const INSERT_FAIL: &str = "minecraft:item.bundle.insert_fail";
+pub const REMOVE_ONE: &str = "minecraft:item.bundle.remove_one";
+
+fn max_stack(items: &Items, stack: &ItemStack) -> u32 {
+    items.get(&stack.item).map_or(64, |i| i.max_stack).max(1)
+}
+
+/// The stack's `bundle_contents`, when it has the component.
+fn contents_of<'a>(items: &Items, stack: &'a ItemStack) -> Option<&'a [ItemStack]> {
+    let inside = stack.data().map_or(&[][..], |d| &d.bundle_contents[..]);
+    let bundle = items.get(&stack.item).is_some_and(|i| i.bundle);
+    (bundle || !inside.is_empty()).then_some(inside)
+}
+
+/// `BundleContents.getWeight`: a nested bundle weighs its contents plus
+/// 1/16, a beehive with bees 1, the rest 1 / max stack size.
+fn item_weight(items: &Items, stack: &ItemStack) -> Weight {
+    if let Some(inside) = contents_of(items, stack) {
+        return contents_weight(items, inside).add(Weight::new(1, 16));
+    }
+    let bees = stack
+        .data()
+        .and_then(|d| d.other("minecraft:bees"))
+        .is_some_and(|b| matches!(b, Tag::List(l) if !l.is_empty()));
+    if bees {
+        Weight::ONE
+    } else {
+        Weight::new(1, i128::from(max_stack(items, stack)))
+    }
+}
+
+fn contents_weight(items: &Items, inside: &[ItemStack]) -> Weight {
+    inside.iter().fold(Weight::ZERO, |w, s| {
+        w.add(item_weight(items, s).times(s.count))
+    })
+}
+
+/// `BundleContents.canItemBeInBundle`: shulker boxes don't fit.
+pub fn can_be_in_bundle(stack: &ItemStack) -> bool {
+    stack.count > 0 && !stack.item.ends_with("shulker_box")
+}
+
+/// `BundleContents.Mutable`.
+pub struct Contents {
+    items: Vec<ItemStack>,
+    weight: Weight,
+}
+
+impl Contents {
+    /// The bundle's contents; None when the stack is no bundle.
+    pub fn of(items: &Items, stack: &ItemStack) -> Option<Self> {
+        let inside = contents_of(items, stack)?.to_vec();
+        let weight = contents_weight(items, &inside);
+        Some(Self {
+            items: inside,
+            weight,
+        })
+    }
+
+    /// `getMaxAmountToAdd` for `stack`'s kind of item.
+    pub fn room_for(&self, items: &Items, stack: &ItemStack) -> u32 {
+        Weight::ONE
+            .sub(self.weight)
+            .how_many(item_weight(items, stack))
+    }
+
+    /// `tryInsert`: what fits moves to the front, merged with its kind.
+    pub fn try_insert(&mut self, items: &Items, stack: &mut ItemStack) -> u32 {
+        if !can_be_in_bundle(stack) {
+            return 0;
+        }
+        let weight = item_weight(items, stack);
+        let amount = stack
+            .count
+            .min(Weight::ONE.sub(self.weight).how_many(weight));
+        if amount == 0 {
+            return 0;
+        }
+        self.weight = self.weight.add(weight.times(amount));
+        // ItemStack.isStackable: a damaged stack is damageable.
+        let stackable = max_stack(items, stack) > 1 && stack.damage == 0;
+        let same = self
+            .items
+            .iter()
+            .position(|s| stackable && s.same_item_same_components(stack));
+        let added = match same {
+            Some(i) => {
+                let mut merged = self.items.remove(i);
+                merged.count += amount;
+                stack.count -= amount;
+                merged
+            }
+            None => {
+                let mut part = stack.clone();
+                part.count = amount;
+                stack.count -= amount;
+                part
+            }
+        };
+        self.items.insert(0, added);
+        amount
+    }
+
+    /// `removeOne`: the first stack (Horizon keeps no selected item).
+    pub fn remove_one(&mut self, items: &Items) -> Option<ItemStack> {
+        if self.items.is_empty() {
+            return None;
+        }
+        let stack = self.items.remove(0);
+        self.weight = self
+            .weight
+            .sub(item_weight(items, &stack).times(stack.count));
+        Some(stack)
+    }
+
+    /// `toImmutable`, written back into the bundle's component.
+    pub fn store(self, bundle: &mut ItemStack) {
+        bundle.data_mut().bundle_contents = self.items;
+        bundle.tidy();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Weight;
+
+    #[test]
+    fn weights_add_up_exactly() {
+        let w = Weight::new(1, 64)
+            .times(32)
+            .add(Weight::new(1, 16).times(4));
+        assert_eq!(w, Weight::new(3, 4));
+        assert_eq!(Weight::ONE.sub(w).how_many(Weight::new(1, 64)), 16);
+        assert_eq!(Weight::ONE.sub(Weight::ONE).how_many(Weight::ONE), 0);
+        // An over-full bundle (made by a command) has no room.
+        let over = Weight::ONE.sub(Weight::new(5, 4));
+        assert_eq!(over.how_many(Weight::new(1, 64)), 0);
+    }
+}
@@ -300,6 +300,10 @@ pub struct FixedStep {
    /// How many times `/tick step` started or stopped a step
    /// (`ServerTickRateManager.updateStepTicks` broadcasts each one).
    step_changes: u32,
+    /// In-frame ticks dropped since the last overload warning (`drop_ticks`).
+    dropped: u32,
+    /// When the last overload warning was due, on the frame clock.
+    last_overload_warning: std::time::Duration,
 }

 impl Default for FixedStep {
@@ -316,6 +320,8 @@ impl Default for FixedStep {
            tick_count: 0,
            client: false,
            step_changes: 0,
+            dropped: 0,
+            last_overload_warning: std::time::Duration::ZERO,
        }
    }
 }
@@ -430,6 +436,41 @@ impl FixedStep {
    pub fn sprinting(&self) -> bool {
        self.manager.is_sprinting()
    }
+    /// Whether a frame that ran its world in the frame, and whose ticks so
+    /// far took `spent`, may run another one. Vanilla's world ticks on the
+    /// integrated server's thread, so a slow tick costs its frames nothing:
+    /// the server falls behind and says so (`MinecraftServer.runServer`'s
+    /// "Can't keep up!"). In the frame, a world whose ticks take longer than
+    /// their length falls behind every frame, so every frame ran the client
+    /// timer's ten: at 57 ms a tick, 1.7 FPS. So a frame stops once its
+    /// ticks have taken a tick's length: ticks of a few milliseconds keep the
+    /// full ten, and a world that cannot keep up runs one tick a frame,
+    /// slower but drawn. A sprint (`/tick sprint`) runs its own frame's worth.
+    pub fn tick_fits(&self, spent: std::time::Duration) -> bool {
+        self.sprinting() || spent < self.tick_duration()
+    }
+    /// The frame skips its remaining `ticks` (`tick_fits`): the world runs
+    /// slower than its tick rate. Returns vanilla's overload warning when one
+    /// is due: a second's worth of ticks behind, at most every ten seconds
+    /// (`OVERLOADED_THRESHOLD_NANOS`, `OVERLOADED_WARNING_INTERVAL_NANOS`).
+    pub fn drop_ticks(&mut self, ticks: u32) -> Option<String> {
+        self.dropped = self.dropped.saturating_add(ticks);
+        let tick = self.tick_duration();
+        let behind = tick * self.dropped;
+        let threshold = std::time::Duration::from_secs(1) + tick * 20;
+        let interval = std::time::Duration::from_secs(10) + tick * 100;
+        if behind <= threshold || self.now < self.last_overload_warning + interval {
+            return None;
+        }
+        let warning = format!(
+            "Can't keep up! Is the server overloaded? Running {}ms or {} ticks behind",
+            behind.as_millis(),
+            self.dropped
+        );
+        self.dropped = 0;
+        self.last_overload_warning = self.now;
+        Some(warning)
+    }
    /// `requestGameToSprint`: true when a sprint was already running.
    pub fn start_sprint(&mut self, ticks: u32) -> bool {
        self.manager
@@ -490,6 +531,37 @@ impl FixedStep {
 mod tests {
    use super::*;

+    #[test]
+    fn a_frame_stops_ticking_after_a_ticks_length() {
+        let clock = FixedStep::default();
+        let ms = std::time::Duration::from_millis;
+        // Ticks of 4 ms: the ten the timer allows fit in 50 ms.
+        assert!(clock.tick_fits(ms(4 * 9)));
+        // Ticks of 40 ms: the second one runs, not a third.
+        assert!(clock.tick_fits(ms(40)));
+        assert!(!clock.tick_fits(ms(80)));
+        // One tick longer than its length still runs, once a frame.
+        assert!(clock.tick_fits(ms(0)));
+        assert!(!clock.tick_fits(ms(120)));
+    }
+    #[test]
+    fn dropped_ticks_warn_once_a_second_behind_and_not_again_for_ten() {
+        let mut clock = FixedStep::default();
+        let s = std::time::Duration::from_secs;
+        clock.now = s(20);
+        assert_eq!(
+            clock.drop_ticks(40),
+            None,
+            "two seconds: not past 1 s + 20 ticks"
+        );
+        let warning = clock.drop_ticks(1).expect("past the threshold");
+        assert!(warning.contains("2050ms or 41 ticks behind"), "{warning}");
+        clock.now = s(25);
+        assert_eq!(clock.drop_ticks(100), None, "within ten seconds");
+        clock.now = s(36);
+        assert!(clock.drop_ticks(0).unwrap().contains("100 ticks behind"));
+    }
+
    #[test]
    fn timer_carries_fractions_and_caps_nothing_itself() {
        let mut t = Timer::new(20.0, 0);
Author	SHA1	Message	Date
Ludovic Marie	0b56d62273	Merge pull request #1521 from ludovic111/fix/launcher-doc-crlf 🤖 Agent: merged after verify and CI parity passed, built merged with current main (launcher-ship-1). #1521: generated docs keep LF line endings on Windows, so the launcher builds there again (dry run 40035909909 green on all three OSes). #1522: Prepare no longer requires Netty's optional native transport jar, which Prism never downloads (fixes #1487; test plus a real Prism-layout prepare).	2026-10-24 02:16:48 +02:00
Ludovic MarieandClaude Opus 5.5	52bc81ca5b	Launcher: the command reference is the same on Windows launcher.yml's Windows build has failed since the reference test landed: Git for Windows checks text out with CRLF (core.autocrlf), so docs/launcher-commands.md never equalled what markdown() generates. .gitattributes now pins LF for the generated files tests compare byte for byte, and the launcher's check reads the file whatever line endings a clone gave it, with a test of a CRLF checkout. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-24 00:48:08 +02:00
Ludovic Marie	265461f2eb	Merge pull request #1467 from ludovic111/fix/bundle-clicks 🤖 Agent: merged after verify and CI parity passed, built merged with current main (reports-gate-2: each claim checked against vanilla 26.3, in-frame and --server-thread; evidence on the issue and in the PR body).	2026-10-24 00:32:56 +02:00
Ludovic Marie	d6dc08098a	Merge pull request #1419 from ludovic111/fix/st2-entity-hands 🤖 Agent: merged after verify and CI parity passed, built merged with current main (st2: entity use with either hand and server chat components; lan_e2e checks pass in both modes. The hands check's only flake was a vanilla crit arrow killing the cow, fixed in `c89695dd9`: 40 of 40 runs pass).	2026-10-24 00:08:06 +02:00
Ludovic Marie	455a9996d2	Merge pull request #1462 from ludovic111/fix/amd-regress-1 🤖 Agent: merged after verify and CI parity passed. A stopgap while in-frame is the default: an overloaded world slows down instead of dropping to 2 FPS (2,500 pigs: 1.7 → 16 FPS). It is removed with the in-frame path (FEATURES 4zg) once the server thread is the default again (#1463–#1466 and following).	2026-10-23 23:07:17 +02:00
Ludovic Marie	cbc469249e	Merge remote-tracking branch 'origin/main' into fix/bundle-clicks	2026-10-23 23:06:24 +02:00
Ludovic Marie	e436116e38	Merge pull request #1463 from ludovic111/fix/st-totem 🤖 Agent: merged after verify and CI parity passed, built merged with current main (st-default-1: server-thread gaps checked against vanilla, each with a lan_e2e check that fails on main and passes here, host and guest, both modes; tables in the PR body).	2026-10-23 22:33:17 +02:00
Ludovic Marie	35d2781e9d	Merge pull request #1454 from ludovic111/feat/client-probe-binary 🤖 Agent: merged after verify passed, with local proof: all 100 client harnesses ran on main and on the branch and their transcripts were diffed (89 byte-identical, the rest only timings or stamps). 81 client examples become one probe binary.	2026-10-23 22:16:12 +02:00
Ludovic Marie	66d1292d10	Merge pull request #1453 from ludovic111/feat/world-probe-binary 🤖 Agent: merged after verify passed, with local proof: all 217 world harnesses ran on main and on the branch and their transcripts were diffed (203 byte-identical, the rest only timings or known run-to-run counts). 168 world examples become one probe binary, with 1,097 duplicated helper lines and 11 dead examples gone.	2026-10-23 22:15:44 +02:00
Ludovic Marie	d3de3cd0a9	Merge remote-tracking branch 'origin/main' into fix/amd-regress-1	2026-10-23 22:10:55 +02:00
Ludovic Marie	e3b168688e	Merge remote-tracking branch 'origin/feat/world-probe-binary' into feat/client-probe-binary	2026-10-23 22:08:17 +02:00
Ludovic Marie	974e18e52a	Merge remote-tracking branch 'origin/main' into feat/world-probe-binary # Conflicts: # crates/horizon-client/examples/lan_flat.rs	2026-10-23 22:05:48 +02:00
Ludovic MarieandClaude Opus 5.5	c89695dd93	lan_e2e hands: shoot the cow with a half drawn bow so it lives A fully drawn bow fires a crit arrow: AbstractArrow.onHitEntity adds random.nextInt(damage / 2 + 2) to the 6 damage, so one shot in five does 10 and kills the 10 health cow. The off hand bucket then had nothing to milk ("the host's off hand holds minecraft:bucket"), on either side, in any mode. Under 20 ticks of draw the arrow is no crit and does at most 6. The check now also asserts the cow is still there after the shot. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 22:01:47 +02:00
Ludovic Marie	0a36a6d8c6	Merge remote-tracking branch 'origin/main' into mm1-1419 # Conflicts: # tools/lan_e2e.py	2026-10-23 21:20:14 +02:00
Ludovic Marie	b9501fc826	Merge remote-tracking branch 'origin/feat/world-probe-binary' into feat/client-probe-binary	2026-10-23 21:09:59 +02:00
Ludovic Marie	9dd9a83699	Merge pull request #1427 from ludovic111/fix/st-particles 🤖 Agent: merged after verify and CI parity passed, built merged with current main (st1: /particle and explosion particles from a server reach its players; lan_e2e evidence in the PR body).	2026-10-23 21:06:12 +02:00
Ludovic Marie	341576a084	Merge remote-tracking branch 'origin/main' into feat/world-probe-binary	2026-10-23 21:06:03 +02:00
Ludovic Marie	0b0e4a8aae	Merge remote-tracking branch 'origin/main' into fix/bundle-clicks	2026-10-23 20:53:33 +02:00
Ludovic MarieandClaude Opus 5.5	8acb46756b	Bundle clicks: the open menu's slotsChanged for the player's inventory BundleItem.broadcastChangesOnContainerMenu calls slotsChanged(player inventory) after a bundle click. The menus that don't check which container changed recompute from their inputs (crafting grids, loom, stonecutter, cartography, merchant, smithing's hasRecipeError). The menu click harness found it on a loom with a fixture result: 8000/8000 cases now match (seeds 7 and 11). Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 20:52:41 +02:00
Ludovic Marie	33e35d37c0	Merge pull request #1267 from ludovic111/feat/java-packs-photon-chocapic 🤖 Agent: merged after verify and CI parity passed (shaders stack: Java packs draw their own terrain, water and shadow map, as in Iris). BSL shows real shadows on Vulkan and Metal; frame times and screenshots are on #1326. Without a pack, nothing changes.	2026-10-23 20:32:04 +02:00
Ludovic Marie	81fb4c7371	Merge remote-tracking branch 'origin/main' into mm1-1419 # Conflicts: # crates/horizon-client/src/game.rs # crates/horizon-client/src/lan/entity.rs # tools/lan_e2e.py	2026-10-23 20:18:12 +02:00
Ludovic MarieandClaude Opus 5.5	7dac46ec3c	Bundles take and give items in inventories and containers A carried bundle clicked on a stack took its place instead of taking it in (#1456): Horizon's menus had no BundleItem click overrides. The PICKUP click now runs them first, as AbstractContainerMenu.tryItemClickBehaviourOverride: - a carried bundle takes as much of a clicked stack as its weight allows (tryTransfer), and a right click on an empty slot puts its first stack there (removeOne, the rest going back in); - a stack clicked onto a bundle in a slot goes in as far as it fits, and a right click with an empty hand takes the bundle's first stack out. BundleContents.Mutable is in horizon_client::bundle (exact Fraction weights: 1/max stack, 1 for a beehive with bees, a nested bundle's contents plus 1/16; shulker boxes don't fit), used by the menu engine and the LAN/server-thread container engine. The insert, insert-fail and remove-one sounds play at the player. In single player the inventory screen's empty-hand press went to an older click path instead of the menu engine; it now goes to the engine, as on a server, so the right click on a bundle works there too. The menu click harness now has bundles (empty, loaded, nested; often in hand) and compares the player's sounds: 3000/3000 bundle-heavy cases match, 2796/3000 without the overrides. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 19:58:48 +02:00
Ludovic MarieandClaude Opus 5.5	b8e729b950	Totems save a server's players: the guest's turn uses it up, and entity event 35 reaches every client A server's players (LAN guests, and single player's window on its server thread) never had a totem ready, and nothing applied one: lethal damage killed them with the totem still in hand (#1292). Each guest turn now readies the totem from the guest's hands and, when its hurt set it off, uses it up at the end of the turn (LivingEntity.checkTotemDeathProtection): 1 health, the item_used stat, the used_totem trigger, the use vibration, the totem's effects. Entity event 35 now goes to every client around, the holder's own too, and a client plays it as ClientPacketListener.handleEntityEvent does: the totem particles, the sound heard locally (not sent on as a sound packet, so no client hears it twice) and the holder's rumble. lan_e2e totem: host and guest, off hand and main hand, both modes. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 18:10:13 +02:00
Ludovic MarieandClaude Opus 5.5	55264459ce	In-frame ticks stop at a tick's length per frame: an overloaded world slows down instead of drawing at 2 FPS Single player's world ticks in the frame by default (#1428). When its ticks take longer than 50 ms, every frame fell behind and ran the client timer's ten, so the picture stalled at 1-2 FPS (a player's report on an AMD 680M, in-frame tick at 36.7 ms). Vanilla's world ticks on the integrated server's thread, which falls behind without costing frames and logs "Can't keep up!". A frame now stops running world ticks once they took a tick's length and drops the rest, logging vanilla's overload warning (1 s + 20 ticks behind, at most every 10 s + 100 ticks). Ticks of a few milliseconds still get the full ten per frame; sprints and server clients are unchanged. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 17:47:22 +02:00
Ludovic Marie	ab2bc22515	Merge origin/main into feat/java-packs-photon-chocapic # Conflicts: # crates/horizon-shaderpack/src/translate.rs # docs/shader-packs.md	2026-10-23 17:20:17 +02:00
Ludovic MarieandClaude Opus 5.5	441774c229	held_drop: pass its probe name Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:51:55 +02:00
Ludovic MarieandClaude Opus 5.5	693556ce32	Point the particle harnesses' source lists at the probe modules Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:51:55 +02:00
Ludovic Marie	dfbb106c69	Merge feat/world-probe-binary (harness fixes)	2026-10-23 16:51:54 +02:00
Ludovic MarieandClaude Opus 5.5	38bce65c21	Pass the probe name where the harness codemod missed it block_survival and state_provider hashed the name as an artifact instead of passing it; decorated_region runs chunk_dump through chunk_generation's binary. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:50:01 +02:00
Ludovic MarieandClaude Opus 5.5	82d6d27567	Point the audio harnesses at audio_common's new place Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:39 +02:00
Ludovic MarieandClaude Opus 5.5	a6da925837	Split the client probe list from its dispatch the same way Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:39 +02:00
Ludovic MarieandClaude Opus 5.5	4a922a5772	Document how the runner tracks probe-binary dependencies Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:38 +02:00
Ludovic MarieandClaude Opus 5.5	858f701ee8	Run the horizon-client parity probes from one binary 81 client examples that harnesses run become modules of examples/probe: harnesses run `probe <name> ...` (or `cargo run --example probe -- <name>`), and the shared helpers (audio_common, hud_fixture, chat_screen_fixture) move with them. The benchmarks and manual tools stay standalone examples. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:38 +02:00
Ludovic MarieandClaude Opus 5.5	ed847d43dc	Keep the probe list out of the harnesses' dependencies main.rs now only lists the probes; dispatch.rs runs them. The runner leaves main.rs out of a probe-binary harness's dependencies and keeps dispatch.rs, so adding a probe no longer reruns (or flake-checks) every harness of its crate. It also follows crate::<probe> references between probes. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:38 +02:00
Ludovic MarieandClaude Opus 5.5	ab4c246cda	Delete the 11 examples nothing references Eight benches (block_facts, chunk, entity_geometry, json_readers, load, save, streaming, tick_chunk_membership), lan_flat, save_parity and vanilla_diff: no harness, tool, doc or workflow names them (review plan, section 1, dead code). -2,222 lines; Git history keeps them. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:38 +02:00
Ludovic MarieandClaude Opus 5.5	7092f16a06	horizon-world probes: one copy of the helpers they shared Now that the probes are modules of one binary, the helpers copied between them live once in examples/probe/support: the collision probes' shape printer (emit, values, box_values, bounds, 8 copies each), the canonical NaN bits of f64 and f32 (50 copies), the registry JSON-to-NBT reader (15) and the JSON block position (4). -1,097 lines of copies. f64::NAN.to_bits() is 0x7ff8000000000000, the literal some copies used, so every probe prints the same bytes. tools/parity.py follows include!: three probes include another probe's source, and stay dependent on it. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:38 +02:00
Ludovic MarieandClaude Opus 5.5	fdae4b895c	horizon-world probes: one binary, `probe <name>` The 168 horizon-world examples the parity harnesses run become modules of one example, examples/probe, that dispatches on its first argument; crate::args() gives each the command line its example saw. Linking ~170 binaries, each instantiating horizon-world's generics again, was most of the parity job's probe build (review plan, section 1). The harnesses build `--example probe` and run `probe <name> ...`. tools/parity.py counts only the probes a harness ran, and the support modules they name, as its dependencies, so editing one probe still reruns only its own harnesses (and PARITY_RUST_SCOPE keeps working). The six manual tools (benches, loot_fill, structure_blocks, vanilla_diff, attribute_memory, behaviour_load_profile) stay separate examples. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 16:30:38 +02:00
Ludovic Marie	c1f8ec81d8	Merge #1444 (world_spawn shards), which touches the same harness	2026-10-23 16:30:37 +02:00
Ludovic Marie	2e953c625b	Merge #1443 (parity prebuild selection), which the probe binaries rely on	2026-10-23 16:30:37 +02:00
Ludovic MarieandClaude Opus 5.5	4b8fecfe58	Particles from a server: /particle and explosions reach its players A server never sent particles: /particle on single player's server thread drew into the server's own engine, and TNT exploded without its burst for anyone but an old-mode host. The protocol gains ClientboundLevelParticlesPacket and ClientboundExplodePacket; /particle sends the particles to each viewer in range (every player without viewers, as PlayerList.getPlayers) and an explosion sends its packet to the players within 64 blocks; their clients draw them as handleParticleEvent and handleExplosion do. /particle's spread was measured from the command's source as if it were a position; it is the spread as given (Vec3Argument.getVec3). Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 10:02:19 +02:00
Ludovic MarieandClaude Opus 5.5	4aa1f8e14a	World border on a server's clients: its state, its walls, its damage The server told joining players of a default border and never of a change, so on single player's server thread and for LAN guests the wall neither showed nor stopped anyone. Players now get the real border on entering a level and each change as BorderChangeListener sends it. The player's movement collides with the border's walls (CollisionGetter.borderCollision) instead of being clamped after moving, which a sprint-jump got past. A guest (and single player's own player on its server thread) outside the border takes its damage on the server, as the host's player did. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 10:02:19 +02:00
Ludovic Marie	0b7fa14030	Merge remote-tracking branch 'origin/main' into fix/st2-entity-hands # Conflicts: # tools/lan_e2e.py	2026-10-23 09:44:52 +02:00
Ludovic MarieandClaude Opus 5.5	337d7d7a7a	Entity use with either hand: bows and food past a mob, off-hand items on mobs, emptied frames - The remote client sends Interact for a targeted mob only for a hand vanilla's client-side Mob.interact would accept with it (leads, name tags, food, buckets, shears, saddled mounts, tamed pets, ...), so a bow drawn or food eaten while aiming at a cow goes on to useItem (#1350). - Both hands: the main hand's item, then the off hand's entity, block and item (Minecraft.startUseItem). The server runs Interact with the packet's hand (GuestUse::Entity), and mobs, armour stands, leads and mounts use the held hand's stack, so an off-hand bucket milks a cow and off-hand wheat feeds it (#1362). - The entity tracker sends an item frame's item and rotation when they go back to empty and 0, so a punched frame shows empty on clients (#1355). - lan_e2e `hands`: the bow, the golden apple, the off-hand bucket and wheat and the emptied frame, for the host and the guest. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-23 08:39:45 +02:00
Ludovic Marie	f642105e84	Merge remote-tracking branch 'origin/main' into feat/java-packs-photon-chocapic	2026-10-23 04:04:11 +02:00
Ludovic MarieandClaude Opus 5.5	91d89b4abf	Java shader packs: modf into a vector component works in an initialiser The comma form of modf (`v.y = trunc(x), x - trunc(x)`) printed without brackets in a declaration's initialiser, which naga's GLSL front end then read as a second declarator. A unary + around it has glsl-lang print the brackets. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-22 20:56:08 +02:00
Ludovic MarieandClaude Opus 5.5	60fc787288	Java shader packs: Photon, Chocapic13' and MakeUp Ultra Fast load The translator now legalises what these packs write and naga refuses: lookups without a level outside fragment shaders become textureLod at level 0; struct varyings travel as one varying per field; textureGather is emulated with texelFetch; a bool given to a numeric constructor becomes cond ? 1 : 0; `const in` parameters lose the const; array fields of private structs get their natural stride (naga lays every struct out as std140); modf into a vector component assigns it instead of passing a pointer. shaders.properties keeps the empty lines the preprocessor leaves, so Photon's `) \` before `#else` ends its value. real_packs_load now also parses every translated program again as WGSL, which is what wgpu is given. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-22 20:24:55 +02:00