igneum/igneum-pow/tests/packs.rs

//! The checked-in packs under proto-cuda/packs/ against this crate (their source since generator version 2,
//! 4 October 2026): every program instruction by instruction from its seed bytes, the generator version, attempt
//! and program id, the dataset and cache self-test words, the 96 hash vectors per pack, and every emitted file
//! byte for byte. A pack that drifts from the emitters, or a generator change that moves a vector, fails here.
//!
//! Packs: igneum-genesis-mh and igneum-devnet-v4-epoch0 (memory-hard; the latter from the devnet genesis hash as
//! the epoch seed and the day bytes of 2026-10-04), igneum-genesis and igneum-hourly (closed-form dataset,
//! interpreter regression only); and, under `proto-cuda/packs-ca2-mixer/`, the class v3 packs mx8-genesis and
//! mx8-devnet-epoch0 (Counter ASIC 2.0, 5 October 2026: generator 3 on `V3_CLASS` = mixer x8 with the cache growth
//! rule, decided 22:05 UTC under the delegated rule; the same seeds and days as the two memory-hard v2 packs, so the
//! v2 program and cache carry over and only the dataset words and the hashes change) and the x4 candidate's packs
//! mx4-genesis and mx4-devnet-epoch0 (generator 2 with the load class in the id, the record of the x4 rows).

use igneum_pow::accept;
use igneum_pow::emit::{
    cuda_kernel, cuda_kernel_bound, cuda_memhard_header, export_pack, metal_memhard, metal_memhard_for, metal_program,
    metal_program_bound, opencl_kernel, opencl_kernel_bound, program_header, program_json, LoadSource,
};
use igneum_pow::generator::{generate_from_seed_bytes, generate_from_seed_bytes_class, generate_from_seed_bytes_program_class, LoadClass, Op, ProgramClass, GENERATOR_VERSION, GENERATOR_VERSION_V3, LOAD_SLOTS, V3_CLASS};
use igneum_pow::memhard::{Shape, CACHE_WORDS};
use igneum_pow::verify::{DatasetMode, DatasetSource, Epoch};
use serde_json::Value;
use std::path::PathBuf;
use std::sync::OnceLock;

const PACKS: [&str; 8] = [
    "igneum-genesis-mh",
    "igneum-devnet-v4-epoch0",
    "igneum-genesis",
    "igneum-hourly",
    "mx8-genesis",
    "mx8-devnet-epoch0",
    "mx4-genesis",
    "mx4-devnet-epoch0",
];
/// The class v3 packs (generator 3 through the seam).
const PACKS_V3: [&str; 2] = ["mx8-genesis", "mx8-devnet-epoch0"];

fn packs_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../proto-cuda/packs")
}

/// The directory a pack lives in: the class v3 packs under packs-ca2-mixer, the rest under packs.
fn pack_dir(pack: &str) -> PathBuf {
    if pack.starts_with("mx4-") || pack.starts_with("mx8-") {
        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../proto-cuda/packs-ca2-mixer").join(pack)
    } else {
        packs_dir().join(pack)
    }
}

fn read(pack: &str, file: &str) -> String {
    let p = pack_dir(pack).join(file);
    std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("read {}: {e}", p.display()))
}

fn json(pack: &str, file: &str) -> Value {
    serde_json::from_str(&read(pack, file)).unwrap_or_else(|e| panic!("{pack}/{file}: {e}"))
}

fn hex32(v: &Value) -> u32 {
    u32::from_str_radix(v.as_str().unwrap().trim_start_matches("0x"), 16).unwrap()
}
fn hex64(v: &Value) -> u64 {
    u64::from_str_radix(v.as_str().unwrap().trim_start_matches("0x"), 16).unwrap()
}
fn unhex(v: &Value) -> Vec<u8> {
    igneum_pow::bind::unhex(v.as_str().unwrap()).unwrap()
}

/// The epoch a pack describes, rebuilt from program.json alone: the program from `seed_bytes`, the dataset from
/// `dataset.day_bytes` in the pack's mode and size. Memory-hard packs fill a 256 MiB cache (about 0.2 s), so
/// each is built once.
fn epoch(pack: &str) -> &'static Epoch {
    static E: OnceLock<Vec<(String, Epoch)>> = OnceLock::new();
    let all = E.get_or_init(|| {
        PACKS
            .iter()
            .map(|p| {
                let j = json(p, "program.json");
                let seed = j["seed"].as_str().unwrap();
                let seed_bytes = unhex(&j["seed_bytes"]);
                let day_bytes = unhex(&j["dataset"]["day_bytes"]);
                let mode = match j["dataset_mode"].as_str().unwrap() {
                    "memory-hard" => DatasetMode::MemoryHard,
                    _ => DatasetMode::ClosedForm,
                };
                let log2 = j["dataset"]["log2_words"].as_u64().unwrap() as u32;
                // a class v3 pack: generator 3 on V3_CLASS through the seam, the era bytes it records, the dataset
                // in the class's shape on day 0 (the growth rule's genesis cache: every pinned pack is a day-0 size)
                let program = match j["generator"].as_u64().unwrap() as u32 {
                    GENERATOR_VERSION_V3 => {
                        let era = j.get("era_seed_bytes").map(unhex);
                        generate_from_seed_bytes_program_class(seed, &seed_bytes, ProgramClass::V3, era.as_deref())
                    }
                    // a generator 2 pack with a load class (the x4 candidate's packs): the class from program.json
                    _ => match j.get("load_class").and_then(|c| c.as_str()) {
                        Some(c) => generate_from_seed_bytes_class(seed, &seed_bytes, LoadClass::parse(c).expect("a load class name")),
                        None => generate_from_seed_bytes(seed, &seed_bytes),
                    },
                };
                let shape = Shape::for_class(&program.class);
                let mut dataset =
                    DatasetSource::from_key_shape(igneum_pow::seed::seed_words_from_bytes(&day_bytes), mode, log2, shape);
                dataset.key_bytes = day_bytes;
                (p.to_string(), Epoch { program, dataset })
            })
            .collect()
    });
    &all.iter().find(|(n, _)| n == pack).unwrap().1
}

fn day_label(pack: &str) -> String {
    json(pack, "program.json")["dataset"]["day"].as_str().unwrap().to_string()
}

fn check_program_json(pack: &str) {
    let j = json(pack, "program.json");
    let p = &epoch(pack).program;
    assert_eq!(j["format"].as_str().unwrap(), "igneum-program-pack-3");
    assert_eq!(j["generator"].as_u64().unwrap() as u32, p.generator, "{pack}: generator version");
    assert_eq!(p.generator, if PACKS_V3.contains(&pack) { GENERATOR_VERSION_V3 } else { GENERATOR_VERSION });
    assert_eq!(j["attempt"].as_u64().unwrap() as u32, p.attempt, "{pack}: attempt");
    assert_eq!(hex64(&j["program_id"]), p.program_id(), "{pack}: program id");
    let sw: Vec<u32> = j["seed_words"].as_array().unwrap().iter().map(hex32).collect();
    assert_eq!(p.seed.to_vec(), sw, "{pack}: seed words");
    assert_eq!(p.loads_per_hash() as u64, j["loads_per_hash"].as_u64().unwrap(), "{pack}: loads per hash");
    assert_eq!(p.loads_per_hash(), 8 * LOAD_SLOTS);
    assert!(accept::check(p).is_ok(), "{pack}: the pack's program passes the acceptance rule");
    let instrs = j["instructions"].as_array().unwrap();
    assert_eq!(instrs.len(), p.instrs.len(), "{pack}: instruction count");
    for (k, (ins, ji)) in p.instrs.iter().zip(instrs).enumerate() {
        assert_eq!(ji["i"].as_u64().unwrap() as usize, k);
        assert_eq!(Op::from_name(ji["op"].as_str().unwrap()).unwrap(), ins.op, "{pack} #{k} op");
        assert_eq!(ji["dst"].as_u64().unwrap(), ins.dst as u64, "{pack} #{k} dst");
        assert_eq!(ji["src"].as_u64().unwrap(), ins.src as u64, "{pack} #{k} src");
        assert_eq!(ji["src2"].as_u64().unwrap(), ins.src2 as u64, "{pack} #{k} src2");
        assert_eq!(hex32(&ji["imm"]), ins.imm, "{pack} #{k} imm");
        assert_eq!(hex32(&ji["imm2"]), ins.imm2, "{pack} #{k} imm2");
        assert_eq!(ji["rot"].as_u64().unwrap(), ins.rot as u64, "{pack} #{k} rot");
        assert_eq!(ji["bit"].as_u64().unwrap(), ins.bit as u64, "{pack} #{k} bit");
        assert_eq!(ji["mask"].as_u64().unwrap(), ins.mask as u64, "{pack} #{k} mask");
    }
    let mix = j["op_mix"].as_object().unwrap();
    for (name, count) in p.histogram() {
        assert_eq!(mix[name].as_u64().unwrap() as usize, count, "{pack}: op_mix {name}");
    }
    assert_eq!(mix.len(), p.histogram().len());
}

#[test]
fn program_json_matches_all_packs() {
    for pack in PACKS {
        check_program_json(pack);
    }
}

/// The genesis program of generator v2 (spec 01 section 1.4.3 vector).
#[test]
fn genesis_program_shape() {
    let p = &epoch("igneum-genesis-mh").program;
    assert_eq!(p.attempt, 0);
    assert_eq!(p.op_mix(), "load=16 add=8 shfl=8 xor=6 mad=5 mul=5 mulhi=5 sub=4 rotl=3 rotr=3 or=1");
    assert_eq!(p.program_id(), 0xbcc1248b10cc90f2);
    assert_eq!(&epoch("igneum-genesis").program, p, "closed-form and memory-hard packs share the program");
}

#[test]
fn mixer_params_match_pack() {
    for pack in ["igneum-genesis-mh", "igneum-devnet-v4-epoch0", "mx8-genesis", "mx8-devnet-epoch0", "mx4-genesis", "mx4-devnet-epoch0"] {
        let j = json(pack, "program.json");
        let mp = &epoch(pack).dataset.memhard().unwrap().params;
        let key: Vec<u32> = j["dataset"]["key"].as_array().unwrap().iter().map(hex32).collect();
        assert_eq!(mp.key.to_vec(), key);
        let rot: Vec<u32> =
            j["dataset"]["mixer"]["rot"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap() as u32).collect();
        assert_eq!(mp.rot.to_vec(), rot);
        let mul: Vec<u32> = j["dataset"]["mixer"]["mul"].as_array().unwrap().iter().map(hex32).collect();
        assert_eq!(mp.mul.to_vec(), mul);
        let rc: Vec<u32> = j["dataset"]["mixer"]["rc"].as_array().unwrap().iter().map(hex32).collect();
        assert_eq!(mp.rc.to_vec(), rc);
        assert_eq!(hex32(&j["dataset"]["d0"]), mp.key[0]);
        assert_eq!(hex32(&j["dataset"]["d1"]), mp.key[1]);
    }
}

#[test]
fn cache_matches_vectors() {
    let v = json("igneum-genesis-mh", "vectors.json");
    let m = epoch("igneum-genesis-mh").dataset.memhard().unwrap();
    let w = m.cache.words();
    assert_eq!(w.len(), CACHE_WORDS);
    let head: Vec<u32> = v["cache_head"].as_array().unwrap().iter().map(hex32).collect();
    assert_eq!(&w[..16], &head[..]);
    let last: Vec<u32> = v["cache_last_line"].as_array().unwrap().iter().map(hex32).collect();
    assert_eq!(&w[CACHE_WORDS - 16..], &last[..]);
    assert_eq!(m.cache.fnv1a64(), 0x48c4f5bf24166b2e, "cache FNV-1a 64 of day 2026-10-03 (MEMHARD.md), unchanged by v2");
    assert_eq!(m.cache.fnv1a64(), hex64(&v["cache_fnv1a64"]));
    let v = json("igneum-devnet-v4-epoch0", "vectors.json");
    let m = epoch("igneum-devnet-v4-epoch0").dataset.memhard().unwrap();
    assert_eq!(m.cache.fnv1a64(), hex64(&v["cache_fnv1a64"]));
    assert_eq!(m.cache.fnv1a64(), 0x448274a57f508cbc, "cache FNV-1a 64 of day bytes igneum-day/20730");
}

fn check_dataset_words(pack: &str) {
    let v = json(pack, "vectors.json");
    let e = epoch(pack);
    let ds = &e.dataset;
    // a pack's self-test words are read under its program's layout (the era layout; linear for every v2 pack)
    let head: Vec<u32> = v["dataset_head"].as_array().unwrap().iter().map(hex32).collect();
    for (i, h) in head.iter().enumerate() {
        assert_eq!(e.dataset_word(i as u32), *h, "{pack}: dataset[{i}]");
    }
    let last_index = v["dataset_last_index"].as_u64().unwrap() as u32;
    assert_eq!(last_index, ds.mask);
    assert_eq!(e.dataset_word(last_index), hex32(&v["dataset_last"]), "{pack}: dataset[MASK]");
    let samples = v["dataset_samples"].as_array().unwrap();
    assert_eq!(samples.len(), 64);
    for s in samples {
        let idx = s["index"].as_u64().unwrap() as u32;
        assert_eq!(e.dataset_word(idx), hex32(&s["value"]), "{pack}: dataset[{idx}]");
    }
}

#[test]
fn dataset_words_match_all_packs() {
    for pack in PACKS {
        check_dataset_words(pack);
    }
}

/// Returns the number of hashes compared (3 warps x 32 lanes = 96).
fn check_vectors(pack: &str) -> usize {
    let v = json(pack, "vectors.json");
    let e = epoch(pack);
    assert_eq!(v["dataset_mode"].as_str().unwrap(), e.dataset.mode().name());
    assert_eq!(v["dataset_log2_words"].as_u64().unwrap() as u32, e.dataset.log2_words);
    let warps = v["warps"].as_array().unwrap();
    assert_eq!(warps.len(), 3);
    let mut n = 0;
    for w in warps {
        let base = w["base_nonce"].as_u64().unwrap() as u32;
        let expected: Vec<u64> = w["expected"].as_array().unwrap().iter().map(hex64).collect();
        let got = e.hash_warp(base);
        for lane in 0..32 {
            assert_eq!(got[lane], expected[lane], "{pack}: base {base} lane {lane}");
            n += 1;
        }
        // The single-nonce API agrees with the warp.
        assert_eq!(e.hash(base + 7), expected[7]);
        assert!(e.verify_block(base + 7, expected[7]));
        assert!(!e.verify_block(base + 7, expected[7] - 1));
    }
    n
}

#[test]
fn vectors_96_per_pack() {
    for pack in PACKS {
        assert_eq!(check_vectors(pack), 96, "{pack}");
    }
}

/// The spec 01 section 1.17 vectors (igneum-genesis-mh, generator v2).
#[test]
fn spec_vectors_genesis_mh() {
    let e = epoch("igneum-genesis-mh");
    let w = e.hash_warp(0);
    assert_eq!(w[0], 0x42246ba99fc58e4f);
    assert_eq!(w[31], 0xb08446b1f2de7793);
    assert_eq!(e.hash_warp(4096)[0], 0x3d3903e310ca038f);
    assert_eq!(e.hash_warp(1_000_000)[0], 0xf218c1bd58e6dfe0);
}

fn assert_same_text(pack: &str, file: &str, got: &str) {
    let want = read(pack, file);
    if got != want {
        let (gl, wl): (Vec<&str>, Vec<&str>) = (got.lines().collect(), want.lines().collect());
        for i in 0..gl.len().max(wl.len()) {
            let g = gl.get(i).copied().unwrap_or("<eof>");
            let w = wl.get(i).copied().unwrap_or("<eof>");
            if g != w {
                panic!("{pack}/{file} differs at line {}:\n  pack: {w}\n  rust: {g}", i + 1);
            }
        }
        panic!("{pack}/{file} differs only in trailing bytes (len {} vs {})", got.len(), want.len());
    }
}

fn check_sources(pack: &str) {
    let e = epoch(pack);
    let p = &e.program;
    let day = day_label(pack);
    let mp = e.dataset.memhard().map(|m| &m.params);
    assert_same_text(pack, "kernel.cu", &cuda_kernel(p, mp));
    assert_same_text(pack, "kernel_bound.cu", &cuda_kernel_bound(p, mp));
    assert_same_text(pack, "program.metal", &metal_program(p, e.dataset.log2_words, LoadSource::Stored));
    assert_same_text(pack, "program_bound.metal", &metal_program_bound(p, e.dataset.log2_words));
    assert_same_text(pack, "kernel.cl", &opencl_kernel(p, mp));
    assert_same_text(pack, "kernel_bound.cl", &opencl_kernel_bound(p, mp));
    assert_same_text(pack, "program.h", &program_header(p, &day, &e.dataset));
    if let Some(mp) = mp {
        assert_same_text(pack, "memhard.h", &cuda_memhard_header(p, mp));
        assert_same_text(pack, "memhard.metal", &igneum_pow::emit::metal_memhard_layout(mp, p.class.layout()));
    }
    let got = program_json(p, &day, &e.dataset);
    assert_same_text(pack, "program.json", &got);
    let _: Value = serde_json::from_str(&got).expect("program.json is valid JSON");
    // Every load in every emitted hash kernel has the masked form, and there are exactly 16 of them (a class with
    // the era layout inside has the era form instead: `((rotl_imm(rN * M, R) & WM) | OFF) & mask`, checked by
    // era_emitted_sources_match_and_loads_have_the_era_form over the era packs, and here by the same count).
    let era_load = if p.class.era.is_some() { "((rotl_imm(r" } else { "" };
    for (file, load, masked) in [
        ("kernel.cu", "ds[r", " & mask]"),
        ("kernel_bound.cu", "ds[r", " & mask]"),
        ("program.metal", "dataset[r", " & MASK]"),
        ("program_bound.metal", "dataset[r", " & MASK]"),
    ] {
        let text = read(pack, file);
        let load = if era_load.is_empty() { load } else { era_load };
        assert_eq!(text.matches(load).count(), LOAD_SLOTS, "{pack}/{file}: 16 loads");
        assert_eq!(text.matches(masked).count(), LOAD_SLOTS, "{pack}/{file}: 16 masked loads");
    }
}

#[test]
fn emitted_sources_match_all_packs() {
    for pack in PACKS {
        check_sources(pack);
    }
}

/// The whole pack as `export` writes it: vectors.json and vectors.h match, and the file list is the full set.
/// The class v3 packs (Counter ASIC 2.0, `docs/plans/mixer-x4.md`): generator 3 on V3_CLASS = mx8; the program of
/// each is the v2 program of the same seed instruction for instruction (v2 loads take no width roll); the cache is
/// the v2 cache (day 0 of the growth rule: 2^26 words, the same FNV-1a 64); the dataset words differ from v2's;
/// program.json, program.h and the emitted memhard core say so; the id carries generator 3.
#[test]
fn v3_packs_are_the_v2_seeds_under_mixer_x8() {
    assert_eq!(V3_CLASS.name(), "mx8");
    assert_eq!(V3_CLASS.mixer_mult, 8);
    assert!(V3_CLASS.growth);
    assert_eq!(LoadClass { mixer_mult: 4, ..V3_CLASS }, LoadClass::MX4, "the x4 candidate differs from v3 in the multiplier alone");
    for (v3, v2) in [("mx8-genesis", "igneum-genesis-mh"), ("mx8-devnet-epoch0", "igneum-devnet-v4-epoch0")] {
        let e3 = epoch(v3);
        let e2 = epoch(v2);
        let j = json(v3, "program.json");
        assert_eq!(j["program_class"].as_str().unwrap(), "v3");
        assert!(j["load_class"].as_str().unwrap().starts_with("mx8"), "{v3}: mx8, or mx8 with the era inside");
        assert_eq!(j["mixer_mult"].as_u64().unwrap(), 8);
        assert_eq!(j["cache_growth"].as_bool().unwrap(), true);
        assert_eq!(j["dataset"]["mixer_mult"].as_u64().unwrap(), 8);
        assert_eq!(j["dataset"]["cache"]["log2_words"].as_u64().unwrap(), 26);
        assert_eq!(e3.program.generator, GENERATOR_VERSION_V3);
        if e3.program.era_bytes.is_some() {
            // the era layout composed into class v3 (docs/plans/era-layout.md, 5 October 2026): a chain pack carries an
            // era, so its class is V3_CLASS with the era drawn inside and its stream takes two window draws per
            // instruction; the v2 program carries over only in the seed, the attempt and the day
            assert_eq!(LoadClass { era: None, ..e3.program.class }, V3_CLASS, "{v3}: the composed class");
            assert!(e3.program.class.era.is_some());
            assert_ne!(e3.program.instrs, e2.program.instrs, "{v3}: the era windows change the stream");
        } else {
            assert_eq!(e3.program.class, V3_CLASS);
            assert_eq!(e3.program.instrs, e2.program.instrs, "{v3}: the v2 program under the v3 construction");
        }
        assert_eq!(e3.program.seed, e2.program.seed);
        assert_eq!(e3.program.attempt, e2.program.attempt);
        assert_ne!(e3.program.program_id(), e2.program.program_id());
        assert_eq!(e3.program.program_id(), igneum_pow::generator::program_id(GENERATOR_VERSION_V3, &e3.program.seed, e3.program.attempt));
        let m3 = e3.dataset.memhard().unwrap();
        let m2 = e2.dataset.memhard().unwrap();
        assert_eq!(m3.shape(), Shape { mixer_mult: 8, cache_log2_words: 26, derive_len: 0 });
        assert_eq!(m3.cache.fnv1a64(), m2.cache.fnv1a64(), "{v3}: the same cache as v2 on day 0");
        assert_eq!(m3.params.rot, m2.params.rot);
        assert_eq!(e3.dataset.log2_words, 28);
        assert_ne!(e3.dataset.word(0), e2.dataset.word(0), "{v3}: the dataset words differ");
        assert_ne!(e3.hash_warp(0), e2.hash_warp(0));
        let h = read(v3, "program.h");
        assert!(h.contains("#define IGNEUM_GENERATOR 3\n"));
        assert!(h.contains("#define IGNEUM_PROGRAM_CLASS \"v3\"\n"));
        assert!(h.contains("#define IGNEUM_MIXER_MULT 8"));
        assert!(h.contains("#define IGNEUM_CACHE_GROWTH 1"));
        assert!(h.contains("#define IGNEUM_CACHE_LOG2_WORDS 26\n"));
        assert!(h.contains("#define IGNEUM_LOAD_CLASS \"mx8"), "mx8, or mx8 with the era inside");
        for file in ["memhard.h", "memhard.metal", "kernel.cl"] {
            let text = read(v3, file);
            assert_eq!(text.matches("j < 8u; ++j) mh_mixer(s, 0x9E3779B9u * (r * 8u + j + 1u))").count(), 1, "{v3}/{file}");
            assert_eq!(text.matches("j < 8u; ++j) mh_mixer(s, 0x9E3779B9u * (64u + j + 1u))").count(), 1, "{v3}/{file}");
        }
        for file in ["memhard.h", "memhard.metal", "kernel.cl"] {
            let text = read(v2, file);
            assert_eq!(text.matches("j < 8u").count(), 0, "{v2}/{file}: the v2 text has no multiplier loop");
        }
    }
    // the devnet v3 pack records era 0's stand-in, the devnet genesis hash
    let j = json("mx8-devnet-epoch0", "program.json");
    assert_eq!(unhex(&j["era_seed_bytes"]), unhex(&j["seed_bytes"]));
    assert!(read("mx8-devnet-epoch0", "program.h").contains("#define IGNEUM_ERA_SEED_HEX \"edc4fa844da9dc98"));
    assert!(json("mx8-genesis", "program.json").get("era_seed_bytes").is_none());
    // the x4 candidate's packs: generator 2, the class in the id, the v2 program of the seed, mixer x4
    for (x4, v2) in [("mx4-genesis", "igneum-genesis-mh"), ("mx4-devnet-epoch0", "igneum-devnet-v4-epoch0")] {
        let e4 = epoch(x4);
        let j = json(x4, "program.json");
        assert_eq!(e4.program.generator, GENERATOR_VERSION);
        assert_eq!(j["load_class"].as_str().unwrap(), "mx4");
        assert_eq!(e4.program.class, LoadClass::MX4);
        assert_eq!(e4.program.instrs, epoch(v2).program.instrs);
        assert_eq!(e4.dataset.memhard().unwrap().shape(), Shape { mixer_mult: 4, cache_log2_words: 26, derive_len: 0 });
        assert!(read(x4, "memhard.h").contains("j < 4u; ++j) mh_mixer(s, 0x9E3779B9u * (r * 4u + j + 1u))"));
    }
}

fn check_export(pack: &str) {
    let e = epoch(pack);
    let v = json(pack, "vectors.json");
    let source = v["source"].as_str().unwrap();
    let out = export_pack(e, &day_label(pack), source);
    let file = |name: &str| -> &str { &out.files.iter().find(|(n, _)| n == name).unwrap().1 };
    assert_same_text(pack, "vectors.json", file("vectors.json"));
    assert_same_text(pack, "vectors.h", file("vectors.h"));
    let mut expected = vec![
        "program.json",
        "vectors.json",
        "kernel.cu",
        "kernel.cl",
        "program.h",
        "vectors.h",
        "program.metal",
        "program_bound.metal",
        "kernel_bound.cu",
        "kernel_bound.cl",
    ];
    if e.dataset.mode() == DatasetMode::MemoryHard {
        expected.extend(["memhard.h", "memhard.metal"]);
    }
    assert_eq!(out.files.iter().map(|(n, _)| n.as_str()).collect::<Vec<_>>(), expected);
    let mut on_disk: Vec<String> = std::fs::read_dir(pack_dir(pack))
        .unwrap()
        .map(|d| d.unwrap().file_name().to_string_lossy().to_string())
        .filter(|n| !n.starts_with('.'))
        .collect();
    on_disk.sort();
    let mut want: Vec<String> = expected.iter().map(|s| s.to_string()).collect();
    want.sort();
    assert_eq!(on_disk, want, "{pack}: no stale file in the pack directory");
}

#[test]
fn export_pack_matches_all_packs() {
    for pack in PACKS {
        check_export(pack);
    }
}

#[test]
fn item_is_independent_of_dataset_size() {
    // MEMHARD.md 1.7: a smaller dataset is a prefix of items, so dataset[w] is the same at every size.
    let big = &epoch("igneum-genesis-mh").dataset;
    let m = big.memhard().unwrap();
    for w in [0u32, 1, 15, 16, 17, 0x00ff_ffff, 0x03ff_ffff] {
        assert_eq!(big.word(w), m.word(w));
    }
}

/// The devnet pack is the chain's own derivation: epoch seed = the devnet genesis hash, day bytes = `bind::day_bytes(20730)`.
#[test]
fn devnet_pack_is_the_chain_derivation() {
    let j = json("igneum-devnet-v4-epoch0", "program.json");
    let genesis = igneum_pow::bind::unhex("edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07").unwrap();
    assert_eq!(unhex(&j["seed_bytes"]), genesis);
    assert_eq!(unhex(&j["dataset"]["day_bytes"]), igneum_pow::bind::day_bytes(20_730).to_vec());
    let e = Epoch::from_seed_bytes(&genesis, &igneum_pow::bind::day_bytes(20_730), "devnet");
    assert_eq!(e.program.instrs, epoch("igneum-devnet-v4-epoch0").program.instrs);
    assert_eq!(e.hash_warp(0), epoch("igneum-devnet-v4-epoch0").hash_warp(0));
}

// ---------------------------------------------------------------------------------------------------------
// Era layout packs (5 October 2026, docs/plans/era-layout.md): proto-cuda/packs-ca2-era/era-<n>, n in 0..5, the
// devnet epoch seed and day bytes under the era class of test era seed igneum-era-test/<n>, the width pinned at
// 4 bytes (allowed_widths in program.json). Checked like the pinned packs, plus the one load form of 1.3 by text search.
// ---------------------------------------------------------------------------------------------------------

use igneum_pow::generator::{generate_era, EraParams, V3_ALLOWED};

const ERA_PACKS: [&str; 6] = ["era-0", "era-1", "era-2", "era-3", "era-4", "era-5"];

fn era_packs_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../proto-cuda/packs-ca2-era")
}

fn era_read(pack: &str, file: &str) -> String {
    let p = era_packs_dir().join(pack).join(file);
    std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("read {}: {e}", p.display()))
}

fn era_json(pack: &str, file: &str) -> Value {
    serde_json::from_str(&era_read(pack, file)).unwrap_or_else(|e| panic!("{pack}/{file}: {e}"))
}

/// The era class of a pack: the era bytes from program.json (`era_seed_bytes`, the chain's `E_n`; the test seed
/// `igneum-era-test/<n>` of the pack's number gives the same bytes), the allowed set from `era.allowed_widths`
/// (class v3's `V3_ALLOWED`); the pack's recorded stream words and draw must be the class's.
fn era_class(pack: &str) -> LoadClass {
    let j = era_json(pack, "program.json");
    let n: u64 = pack.trim_start_matches("era-").parse().unwrap();
    let eb = unhex(&j["era_seed_bytes"]);
    assert_eq!(eb, EraParams::test_era_bytes(&format!("igneum-era-test/{n}")).to_vec(), "{pack}: the era bytes of test seed {n}");
    let allowed: Vec<u8> = j["era"]["allowed_widths"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap() as u8).collect();
    assert_eq!(allowed, V3_ALLOWED.to_vec(), "{pack}: class v3's width set");
    // the measurement packs of 5 October 2026: the era layout over version 2's construction (mixer x1, the genesis
    // cache), generator 3 and the era bytes recorded; the chain's class v3 composes the same draw over LoadClass::MX4
    // (generator tests era_programs_are_accepted and program_classes), and the integration re-exports these packs
    let c = LoadClass::era(LoadClass::V2, &eb, &allowed);
    let e = c.era.unwrap();
    let words: Vec<u32> = j["era"]["seed_words"].as_array().unwrap().iter().map(hex32).collect();
    assert_eq!(e.words.to_vec(), words, "{pack}: era seed words");
    assert_eq!(e.width_words as u64, j["era"]["width_words"].as_u64().unwrap(), "{pack}: width");
    assert_eq!(e.stride_mul, hex32(&j["era"]["stride_mul"]), "{pack}: stride mul");
    assert_eq!(e.stride_rot as u64, j["era"]["stride_rot"].as_u64().unwrap(), "{pack}: stride rot");
    let pos: Vec<u8> = j["era"]["interleave"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap() as u8).collect();
    assert_eq!(e.pos.to_vec(), pos, "{pack}: interleave");
    c
}

fn era_epoch(pack: &str) -> &'static Epoch {
    static E: OnceLock<Vec<(String, Epoch)>> = OnceLock::new();
    let all = E.get_or_init(|| {
        ERA_PACKS
            .iter()
            .map(|p| {
                let j = era_json(p, "program.json");
                let seed = j["seed"].as_str().unwrap();
                let seed_bytes = unhex(&j["seed_bytes"]);
                let day_bytes = unhex(&j["dataset"]["day_bytes"]);
                assert_eq!(j["dataset_mode"].as_str().unwrap(), "memory-hard");
                let log2 = j["dataset"]["log2_words"].as_u64().unwrap() as u32;
                let class = era_class(p);
                assert_eq!(log2, igneum_pow::verify::DEFAULT_DATASET_LOG2);
                let eb = unhex(&j["era_seed_bytes"]);
                let program = generate_era(seed, &seed_bytes, LoadClass::V2, &eb, &V3_ALLOWED);
                assert_eq!(program.class, class, "{p}: the pack's era class");
                assert_eq!(program.generator, GENERATOR_VERSION_V3);
                assert_eq!(program.era_bytes.as_deref(), Some(&eb[..]));
                let mut dataset = DatasetSource::from_key(igneum_pow::seed::seed_words_from_bytes(&day_bytes), DatasetMode::MemoryHard, log2);
                dataset.key_bytes = day_bytes;
                (p.to_string(), Epoch { program, dataset })
            })
            .collect()
    });
    &all.iter().find(|(n, _)| n == pack).unwrap().1
}

/// program.json of an era pack: generator, attempt, id, class, every instruction with width, win and off, and the
/// program passes the acceptance rule.
#[test]
fn era_program_json_matches() {
    for pack in ERA_PACKS {
        let j = era_json(pack, "program.json");
        let p = &era_epoch(pack).program;
        assert_eq!(j["generator"].as_u64().unwrap() as u32, GENERATOR_VERSION_V3, "{pack}: a class v3 pack");
        assert_eq!(j["program_class"].as_str().unwrap(), "v3");
        assert_eq!(j["attempt"].as_u64().unwrap() as u32, p.attempt, "{pack}: attempt");
        assert_eq!(hex64(&j["program_id"]), p.program_id(), "{pack}: program id");
        assert_eq!(j["load_class"].as_str().unwrap(), p.class.name(), "{pack}: class");
        assert_eq!(j["bytes_per_hash"].as_u64().unwrap() as usize, p.bytes_per_hash());
        assert_eq!(p.loads_per_hash(), 8 * LOAD_SLOTS);
        assert!(accept::check(p).is_ok(), "{pack}: acceptance");
        let instrs = j["instructions"].as_array().unwrap();
        assert_eq!(instrs.len(), p.instrs.len());
        for (k, (ins, ji)) in p.instrs.iter().zip(instrs).enumerate() {
            assert_eq!(Op::from_name(ji["op"].as_str().unwrap()).unwrap(), ins.op, "{pack} #{k} op");
            assert_eq!(ji["dst"].as_u64().unwrap(), ins.dst as u64);
            assert_eq!(ji["src"].as_u64().unwrap(), ins.src as u64);
            assert_eq!(hex32(&ji["imm"]), ins.imm);
            assert_eq!(ji["width"].as_u64().unwrap(), ins.width as u64, "{pack} #{k} width");
            assert_eq!(ji["win"].as_u64().unwrap(), ins.win as u64, "{pack} #{k} win");
            assert_eq!(ji["off"].as_u64().unwrap(), ins.off as u64, "{pack} #{k} off");
            if ins.op == Op::Load {
                assert_eq!(ins.width, p.class.era.unwrap().width_words);
                assert!(ins.win <= 2 && (ins.off as u32) < (1u32 << ins.win));
            }
        }
    }
}

/// The six era packs are the same program seed under six draws: the instruction lists agree, the widths and layouts
/// follow the draw, and the dataset words differ from the linear layout exactly when the interleave is not linear.
#[test]
fn era_packs_share_the_program_and_differ_in_layout() {
    let linear = &epoch("igneum-devnet-v4-epoch0").dataset;
    for pack in ERA_PACKS {
        let e = era_epoch(pack);
        assert_eq!(e.program.seed_bytes, epoch("igneum-devnet-v4-epoch0").program.seed_bytes, "{pack}: the devnet seed");
        let strip = |p: &igneum_pow::generator::Program| {
            p.instrs.iter().map(|i| (i.op, i.dst, i.src, i.src2, i.imm, i.imm2, i.rot, i.bit, i.mask, i.win, i.off)).collect::<Vec<_>>()
        };
        assert_eq!(strip(&e.program), strip(&era_epoch("era-0").program), "{pack}: same stream as era-0");
        let l = e.program.class.layout();
        let same_at_1 = (0..64u32).all(|w| e.dataset_word(w * 977 + 1) == linear.word(w * 977 + 1));
        assert_eq!(same_at_1, l.is_linear(), "{pack}: layout {:?}", l.pos);
        assert_eq!(e.dataset_word(0), linear.word(0), "{pack}: word 0 is item 0 word 0 in every layout");
        // the chain's shared day cache serves every era: the day's dataset source is the pinned pack's, bit for bit
        assert_eq!(e.dataset.key, linear.key);
        assert_eq!(e.dataset.memhard().unwrap().cache.fnv1a64(), linear.memhard().unwrap().cache.fnv1a64());
    }
}

#[test]
fn era_dataset_words_and_vectors_match() {
    for pack in ERA_PACKS {
        let v = era_json(pack, "vectors.json");
        let e = era_epoch(pack);
        let ds = &e.dataset;
        let head: Vec<u32> = v["dataset_head"].as_array().unwrap().iter().map(hex32).collect();
        for (i, h) in head.iter().enumerate() {
            assert_eq!(e.dataset_word(i as u32), *h, "{pack}: dataset[{i}]");
        }
        assert_eq!(e.dataset_word(ds.mask), hex32(&v["dataset_last"]), "{pack}: dataset[MASK]");
        for s in v["dataset_samples"].as_array().unwrap() {
            let idx = s["index"].as_u64().unwrap() as u32;
            assert_eq!(e.dataset_word(idx), hex32(&s["value"]), "{pack}: dataset[{idx}]");
        }
        assert_eq!(ds.memhard().unwrap().cache.fnv1a64(), hex64(&v["cache_fnv1a64"]));
        let mut n = 0;
        for w in v["warps"].as_array().unwrap() {
            let base = w["base_nonce"].as_u64().unwrap() as u32;
            let expected: Vec<u64> = w["expected"].as_array().unwrap().iter().map(hex64).collect();
            let got = e.hash_warp(base);
            for lane in 0..32 {
                assert_eq!(got[lane], expected[lane], "{pack}: base {base} lane {lane}");
                n += 1;
            }
            assert_eq!(e.hash(base + 7), expected[7]);
        }
        assert_eq!(n, 96, "{pack}");
    }
}

/// Every emitted file of every era pack matches the emitters byte for byte, the export reproduces vectors.json and
/// vectors.h, and every dataset load in every hash kernel has the one era form (no plain `ds[rN & mask]` remains).
#[test]
fn era_emitted_sources_match_and_loads_have_the_era_form() {
    for pack in ERA_PACKS {
        let e = era_epoch(pack);
        let day = era_json(pack, "program.json")["dataset"]["day"].as_str().unwrap().to_string();
        let source = era_json(pack, "vectors.json")["source"].as_str().unwrap().to_string();
        let out = export_pack(e, &day, &source);
        for (name, text) in &out.files {
            let want = era_read(pack, name);
            assert!(text == &want, "{pack}/{name} differs from the emitter");
        }
        let mut on_disk: Vec<String> = std::fs::read_dir(era_packs_dir().join(pack))
            .unwrap()
            .map(|d| d.unwrap().file_name().to_string_lossy().to_string())
            .filter(|n| !n.starts_with('.') && n != "seeds.txt")
            .collect();
        on_disk.sort();
        let mut want: Vec<String> = out.files.iter().map(|(n, _)| n.clone()).collect();
        want.sort();
        assert_eq!(on_disk, want, "{pack}: the pack holds the export's files and seeds.txt only");
        let era = e.program.class.era.unwrap();
        let mul = format!("0x{:08x}u", era.stride_mul);
        for (file, mask) in [
            ("kernel.cu", "mask"),
            ("kernel_bound.cu", "mask"),
            ("kernel.cl", "mask"),
            ("kernel_bound.cl", "mask"),
            ("program.metal", "MASK"),
            ("program_bound.metal", "MASK"),
        ] {
            let text = era_read(pack, file);
            let kernels = if file.starts_with("kernel_bound") || file == "kernel.cu" || file == "kernel.cl" || file.starts_with("program") { 1 } else { 1 };
            // kernel_bound.cl carries igneum_hash and igneum_hash_bound: two kernels
            let kernels = if file == "kernel_bound.cl" { 2 } else { kernels };
            let era_form: usize = text
                .lines()
                .filter(|l| l.contains("rotl_imm(r") && l.contains(&format!(" * {mul}, {}u) & ", era.stride_rot)) && l.contains(&format!(") & {mask}")))
                .filter(|l| l.contains("ds[") || l.contains("dataset[") || l.contains("b_ = "))
                .count();
            assert_eq!(era_form, LOAD_SLOTS * kernels, "{pack}/{file}: {} loads of the era form", LOAD_SLOTS * kernels);
            let plain = text.lines().filter(|l| l.contains("ds[r") || l.contains("dataset[r")).count();
            assert_eq!(plain, 0, "{pack}/{file}: a load without the era form");
        }
        // the layout helpers appear exactly when the layout is not linear
        let mh = era_read(pack, "memhard.h");
        assert_eq!(mh.contains("mh_addr("), !era.layout().is_linear(), "{pack}: memhard.h layout helpers");
    }
}

/// An era pack's dataset is a prefix at every size of at least 2^16 words: the 2^20-word source gives the pack's
/// words below 2^20.
#[test]
fn era_dataset_is_a_prefix_at_smaller_sizes() {
    for pack in ["era-1", "era-3"] {
        let e = era_epoch(pack);
        let small = DatasetSource::from_key(e.dataset.key, DatasetMode::MemoryHard, 20);
        let l = e.program.class.layout();
        for w in [0u32, 1, 2, 3, 16, 255, 4096, 65_535, 65_536, 0x000f_ffff] {
            assert_eq!(small.word_at(l, w), e.dataset_word(w), "{pack}: w {w}");
        }
    }
}

// ---------------------------------------------------------------------------------------------------------
// Hot-table experiment (5 October 2026, docs/plans/hot-table.md): the five packs under proto-cuda/packs-ca2-hot/ are
// pinned the same way (program, vectors, every emitted file byte for byte), plus the hot table's fingerprint and the
// one-form load check: exactly 16 - k masked dataset loads and exactly k hot loads in every hash kernel.
// ---------------------------------------------------------------------------------------------------------

const HOT_PACKS: [&str; 8] = ["hot32k4", "hot64k4", "hot96k4", "hot64k2", "hot64k8", "hot32k4a", "hot64k4a", "hot96k4a"];

fn hot_packs_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../proto-cuda/packs-ca2-hot")
}

fn hread(pack: &str, file: &str) -> String {
    let p = hot_packs_dir().join(pack).join(file);
    std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("read {}: {e}", p.display()))
}

fn hjson(pack: &str, file: &str) -> Value {
    serde_json::from_str(&hread(pack, file)).unwrap_or_else(|e| panic!("{pack}/{file}: {e}"))
}

/// The epoch of a hot pack from program.json alone: the class from `load_class`, the program from the seed bytes,
/// the dataset from the day bytes, the hot table from the seed bytes (what `Epoch::from_seed_bytes_class` does).
fn hepoch(pack: &str) -> &'static Epoch {
    static E: OnceLock<Vec<(String, Epoch)>> = OnceLock::new();
    let all = E.get_or_init(|| {
        HOT_PACKS
            .iter()
            .map(|p| {
                let j = hjson(p, "program.json");
                let seed = j["seed"].as_str().unwrap();
                let seed_bytes = unhex(&j["seed_bytes"]);
                let day_bytes = unhex(&j["dataset"]["day_bytes"]);
                assert_eq!(j["dataset_mode"].as_str().unwrap(), "memory-hard");
                let class = LoadClass::parse(j["load_class"].as_str().unwrap()).unwrap();
                assert_eq!(class.name(), *p, "the pack directory is the class name");
                let log2 = j["dataset"]["log2_words"].as_u64().unwrap() as u32;
                let program = generate_from_seed_bytes_class(seed, &seed_bytes, class);
                let mut dataset =
                    DatasetSource::from_key(igneum_pow::seed::seed_words_from_bytes(&day_bytes), DatasetMode::MemoryHard, log2);
                dataset.key_bytes = day_bytes;
                dataset.attach_hot_for(&program);
                (p.to_string(), Epoch { program, dataset })
            })
            .collect()
    });
    &all.iter().find(|(n, _)| n == pack).unwrap().1
}

fn hassert_same_text(pack: &str, file: &str, got: &str) {
    let want = hread(pack, file);
    if got != want {
        let (gl, wl): (Vec<&str>, Vec<&str>) = (got.lines().collect(), want.lines().collect());
        for i in 0..gl.len().max(wl.len()) {
            let g = gl.get(i).copied().unwrap_or("<eof>");
            let w = wl.get(i).copied().unwrap_or("<eof>");
            if g != w {
                panic!("{pack}/{file} differs at line {}:\n  pack: {w}\n  rust: {g}", i + 1);
            }
        }
        panic!("{pack}/{file} differs only in trailing bytes (len {} vs {})", got.len(), want.len());
    }
}

#[test]
fn hot_packs_program_and_vectors() {
    for pack in HOT_PACKS {
        let e = hepoch(pack);
        let p = &e.program;
        let j = hjson(pack, "program.json");
        let h = p.class.hot.unwrap();
        assert_eq!(j["generator"].as_u64().unwrap() as u32, GENERATOR_VERSION);
        assert_eq!(j["attempt"].as_u64().unwrap() as u32, p.attempt);
        assert_eq!(hex64(&j["program_id"]), p.program_id(), "{pack}: program id");
        let dataset_slots = if h.added { 16 } else { 16 - h.k as usize };
        assert_eq!(j["loads_per_hash"].as_u64().unwrap() as usize, (dataset_slots + h.k as usize) * 8);
        assert_eq!(j["hot_table"]["mb"].as_u64().unwrap(), h.mb as u64);
        assert_eq!(j["hot_table"]["slots"].as_u64().unwrap(), h.k as u64);
        assert_eq!(j["hot_table"]["dataset_slots"].as_u64().unwrap() as usize, dataset_slots);
        assert_eq!(j["hot_table"]["words"].as_u64().unwrap() as u32, p.hot_words());
        assert_eq!(j["op_mix"]["hot"].as_u64().unwrap(), h.k as u64, "{pack}: k hot instructions");
        assert_eq!(j["op_mix"]["load"].as_u64().unwrap() as usize, dataset_slots);
        assert_eq!(p.items_per_warp(), dataset_slots * 8 * 32);
        assert!(accept::check(p).is_ok(), "{pack}: passes the acceptance rule");
        let v2 = &epoch("igneum-genesis-mh").program;
        if !h.added {
            // replaced form: the version 2 genesis program with k loads redirected (attempt 0 on both)
            assert_eq!(p.attempt, v2.attempt);
            for (a, b) in p.instrs.iter().zip(v2.instrs.iter()) {
                if a.op == Op::Hot {
                    assert_eq!(b.op, Op::Load);
                } else {
                    assert_eq!(a, b);
                }
            }
        } else {
            // added form: 16 + k load slots, so another slot draw and another program; 16 dataset loads stay
            assert_ne!(p.instrs, v2.instrs);
            assert_eq!(p.instrs.iter().filter(|i| i.op == Op::Load).count(), 16);
            assert!(p.instrs.iter().all(|i| i.width == 1));
        }
        // the hot table: the pack's head, last line and fingerprint
        let v = hjson(pack, "vectors.json");
        let t = e.dataset.hot.as_ref().unwrap();
        assert_eq!(t.n_words(), p.hot_words());
        let head: Vec<u32> = v["hot_head"].as_array().unwrap().iter().map(hex32).collect();
        assert_eq!(&t.words()[..16], &head[..]);
        let last: Vec<u32> = v["hot_last_line"].as_array().unwrap().iter().map(hex32).collect();
        assert_eq!(&t.words()[t.words().len() - 16..], &last[..]);
        assert_eq!(t.fnv1a64(), hex64(&v["hot_fnv1a64"]), "{pack}: hot_fnv1a64");
        assert_eq!(t.key, igneum_pow::memhard::hot_key(&p.seed_bytes));
        // the cache is the day's, unchanged by the class
        assert_eq!(e.dataset.memhard().unwrap().cache.fnv1a64(), 0x48c4f5bf24166b2e);
        // 96 vectors
        let warps = v["warps"].as_array().unwrap();
        assert_eq!(warps.len(), 3);
        for w in warps {
            let base = w["base_nonce"].as_u64().unwrap() as u32;
            let expected: Vec<u64> = w["expected"].as_array().unwrap().iter().map(hex64).collect();
            let got = e.hash_warp(base);
            for lane in 0..32 {
                assert_eq!(got[lane], expected[lane], "{pack}: base {base} lane {lane}");
            }
            assert_eq!(e.hash(base + 5), expected[5]);
        }
        // the dataset words are the day's
        let head: Vec<u32> = v["dataset_head"].as_array().unwrap().iter().map(hex32).collect();
        for (i, hd) in head.iter().enumerate() {
            assert_eq!(e.dataset.word(i as u32), *hd);
        }
    }
    // the same k at three sizes: identical programs, three fingerprints, three vector sets
    let a = hepoch("hot32k4");
    let b = hepoch("hot64k4");
    let c = hepoch("hot96k4");
    assert_eq!(a.program.instrs, b.program.instrs);
    assert_eq!(b.program.instrs, c.program.instrs);
    assert_ne!(a.hash_warp(0), b.hash_warp(0));
    assert_ne!(b.hash_warp(0), c.hash_warp(0));
}

#[test]
fn hot_packs_emitted_sources_and_load_forms() {
    for pack in HOT_PACKS {
        let e = hepoch(pack);
        let p = &e.program;
        let k = p.class.hot.unwrap().k as usize;
        let dataset_loads = p.class.dataset_slots();
        let day = hjson(pack, "program.json")["dataset"]["day"].as_str().unwrap().to_string();
        let mp = &e.dataset.memhard().unwrap().params;
        hassert_same_text(pack, "kernel.cu", &cuda_kernel(p, Some(mp)));
        hassert_same_text(pack, "kernel_bound.cu", &cuda_kernel_bound(p, Some(mp)));
        hassert_same_text(pack, "program.metal", &metal_program(p, e.dataset.log2_words, LoadSource::Stored));
        hassert_same_text(pack, "program_bound.metal", &metal_program_bound(p, e.dataset.log2_words));
        hassert_same_text(pack, "kernel.cl", &opencl_kernel(p, Some(mp)));
        hassert_same_text(pack, "kernel_bound.cl", &opencl_kernel_bound(p, Some(mp)));
        hassert_same_text(pack, "program.h", &program_header(p, &day, &e.dataset));
        hassert_same_text(pack, "memhard.h", &cuda_memhard_header(p, mp));
        hassert_same_text(pack, "memhard.metal", &metal_memhard_for(p, mp));
        assert_ne!(metal_memhard_for(p, mp), metal_memhard(mp), "{pack}: the hot fill kernel is in memhard.metal");
        let got = program_json(p, &day, &e.dataset);
        hassert_same_text(pack, "program.json", &got);
        let _: Value = serde_json::from_str(&got).expect("program.json is valid JSON");
        let v = hjson(pack, "vectors.json");
        let out = export_pack(e, &day, v["source"].as_str().unwrap());
        let file = |name: &str| -> &str { &out.files.iter().find(|(n, _)| n == name).unwrap().1 };
        hassert_same_text(pack, "vectors.json", file("vectors.json"));
        hassert_same_text(pack, "vectors.h", file("vectors.h"));
        assert_eq!(out.files.len(), 12);
        // One form per dialect, exactly 16 - k masked dataset loads and k hot loads in every hash kernel; the fill
        // kernel is present once per source that builds the table.
        for (file, load, masked, hot) in [
            ("kernel.cu", "ds[r", " & mask]", "hot[__umulhi(r"),
            ("kernel_bound.cu", "ds[r", " & mask]", "hot[__umulhi(r"),
            ("program.metal", "dataset[r", " & MASK]", "hot[mulhi(r"),
            ("program_bound.metal", "dataset[r", " & MASK]", "hot[mulhi(r"),
            ("kernel.cl", "ds[r", " & mask]", "hot[mul_hi(r"),
        ] {
            let text = hread(pack, file);
            assert_eq!(text.matches(load).count(), dataset_loads, "{pack}/{file}: {dataset_loads} dataset loads");
            assert_eq!(text.matches(masked).count(), dataset_loads, "{pack}/{file}: masked loads");
            assert_eq!(text.matches(hot).count(), k, "{pack}/{file}: {k} hot loads");
            assert!(text.contains(&format!("#define HOT_WORDS 0x{:08x}u", p.hot_words())), "{pack}/{file}: HOT_WORDS literal");
        }
        // kernel_bound.cl carries both kernels
        let text = hread(pack, "kernel_bound.cl");
        assert_eq!(text.matches("hot[mul_hi(r").count(), 2 * k);
        assert_eq!(text.matches("ds[r").count(), 2 * dataset_loads);
        for file in ["kernel.cu", "kernel.cl", "kernel_bound.cl", "memhard.metal"] {
            assert_eq!(hread(pack, file).matches("igneum_hot_fill(").count(), 1, "{pack}/{file}: one hot fill kernel");
        }
        assert_eq!(hread(pack, "memhard.h").matches("void ht_segment(").count(), 1);
        let ph = hread(pack, "program.h");
        assert!(ph.contains(&format!("#define IGNEUM_HOT_MB {}", p.class.hot.unwrap().mb)));
        assert!(ph.contains(&format!("#define IGNEUM_HOT_SLOTS {k}")));
        assert!(ph.contains("igneum_launch_hot_fill("));
    }
}