yog_cli/

content.rs

//! `.yblock` / `.yitem` content files — a mod's blocks and items: their
//! properties, 3D model, block states and item form, in one JSON file each,
//! edited in Yog-IDLE's 3D model editor — and `.yrecipe` files, one recipe
//! each (crafting, shapeless, smelting), edited in its recipe editor. See
//! Yog-IDLE's `docs/blocks-items.md` for the formats.
//!
//! `yog build` reads `content/**/*.yblock` and `content/**/*.yitem` and
//!
//! - writes Minecraft's JSON for them: block models, blockstates, item
//!   models, 1.21.4+ item definitions (`assets/<ns>/items/`), block loot
//!   tables, the `mineable/<tool>` and `needs_<level>_tool` block tags;
//! - puts their names and tooltips into the lang files (a `@<Set>.<name>`
//!   text of a `.yres` file under the key Minecraft looks up, a literal into
//!   `en_us`);
//! - bundles textures given as paths inside `resources/`;
//! - generates `.yog-build/generated/yog-content.g.rs` — `Blocks`/`Items`
//!   with an id constant and a `BlockDef`/`ItemDef` builder per entry and
//!   a `register` function — pulled in by `yog_api::content!();`, which
//!   also registers them (unless an entry says `"register": "manual"`) and
//!   every recipe.

mod import;
pub mod json;
mod refs;

pub use import::import_command;

use crate::yres;
use json::{J, V, num_value};
use serde_json::{Map, Value, json};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::fmt::Write as _;
use std::path::{Path, PathBuf};

/// Where content files live, under the mod root.
pub const CONTENT_DIR: &str = "content";
/// The generated Rust code, under the mod root.
pub const GENERATED_FILE: &str = ".yog-build/generated/yog-content.g.rs";

/// A generated file: path inside the `.yog` and its bytes.
pub type Output = (String, Vec<u8>);

/// What a content file defines.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Kind {
    /// `.yblock` — a block and its item form.
    Block,
    /// `.yitem` — an item.
    Item,
    /// `.yrecipe` — a recipe.
    Recipe,
    /// `.ybook` — a guide book (`yog_book::Book` as JSON).
    Book,
}

impl Kind {
    pub fn of(path: &Path) -> Option<Kind> {
        match path.extension()?.to_str()? {
            "yblock" => Some(Kind::Block),
            "yitem" => Some(Kind::Item),
            "yrecipe" => Some(Kind::Recipe),
            "ybook" => Some(Kind::Book),
            _ => None,
        }
    }

    fn word(self) -> &'static str {
        match self {
            Kind::Block => "block",
            Kind::Item => "item",
            Kind::Recipe => "recipe",
            Kind::Book => "book",
        }
    }
}

/// Everything `yog build` makes of a mod's content files.
#[derive(Debug, Default)]
pub struct Compiled {
    /// Models, blockstates, item definitions, loot tables, textures.
    pub outputs: Vec<Output>,
    /// Lang entries: `(namespace, locale)` → key → text, merged into the
    /// lang files by [`merge_outputs`].
    lang: BTreeMap<(String, String), BTreeMap<String, String>>,
    /// `.yres` text keys to copy under another key: (from, to).
    lang_aliases: Vec<(String, String)>,
    /// Block tag path (`data/minecraft/tags/block/...json`) → entries.
    tags: BTreeMap<String, BTreeSet<String>>,
    /// The generated Rust code; `None` when the mod has no content files.
    pub source: Option<String>,
    pub warnings: Vec<String>,
    pub blocks: usize,
    pub items: usize,
    pub recipes: usize,
    pub books: usize,
}

// ── Vocabulary ───────────────────────────────────────────────────────────────

pub const DIRECTIONS: [&str; 6] = ["down", "up", "north", "south", "west", "east"];
pub const DISPLAY_SLOTS: [&str; 8] = [
    "thirdperson_righthand",
    "thirdperson_lefthand",
    "firstperson_righthand",
    "firstperson_lefthand",
    "gui",
    "head",
    "ground",
    "fixed",
];
/// The sound groups the loaders map (`BlockDef::sound`).
pub const SOUNDS: [&str; 10] = [
    "stone",
    "wood",
    "grass",
    "gravel",
    "sand",
    "snow",
    "metal",
    "glass",
    "wool",
    "nether_brick",
];
pub const TOOLS: [&str; 4] = ["pickaxe", "axe", "shovel", "hoe"];
pub const TOOL_LEVELS: [&str; 3] = ["stone", "iron", "diamond"];
pub const RENDER_LAYERS: [&str; 4] = ["solid", "cutout", "cutout_mipped", "translucent"];
pub const RECIPE_TYPES: [&str; 8] =
    ["shaped", "shapeless", "smelting", "blasting", "smoking", "campfire_cooking", "stonecutting", "smithing"];

/// A model template — `"parent": "cube_all"` — and the texture slots it takes.
pub struct Template {
    pub name: &'static str,
    /// The vanilla model it compiles to.
    pub parent: &'static str,
    /// Its texture slots; for item sprites, `layer0` (more layers allowed).
    pub slots: &'static [&'static str],
    /// An item sprite template (`generated`, `handheld`) — item models only.
    pub sprite: bool,
    /// The parent model defines `particle` itself.
    pub has_particle: bool,
}

pub const TEMPLATES: &[Template] = &[
    Template {
        name: "cube_all",
        parent: "minecraft:block/cube_all",
        slots: &["all"],
        sprite: false,
        has_particle: true,
    },
    Template {
        name: "cube_column",
        parent: "minecraft:block/cube_column",
        slots: &["end", "side"],
        sprite: false,
        has_particle: true,
    },
    Template {
        name: "cube_bottom_top",
        parent: "minecraft:block/cube_bottom_top",
        slots: &["top", "bottom", "side"],
        sprite: false,
        has_particle: true,
    },
    Template {
        name: "cube",
        parent: "minecraft:block/cube",
        slots: &["down", "up", "north", "south", "west", "east"],
        sprite: false,
        has_particle: false,
    },
    Template {
        name: "orientable",
        parent: "minecraft:block/orientable",
        slots: &["front", "side", "top"],
        sprite: false,
        has_particle: true,
    },
    Template {
        name: "cross",
        parent: "minecraft:block/cross",
        slots: &["cross"],
        sprite: false,
        has_particle: true,
    },
    Template {
        name: "generated",
        parent: "minecraft:item/generated",
        slots: &["layer0"],
        sprite: true,
        has_particle: true,
    },
    Template {
        name: "handheld",
        parent: "minecraft:item/handheld",
        slots: &["layer0"],
        sprite: true,
        has_particle: true,
    },
];

pub fn template(name: &str) -> Option<&'static Template> {
    TEMPLATES.iter().find(|t| t.name == name)
}

/// `[a-z0-9_.-]+` — a Minecraft namespace.
pub fn valid_namespace(s: &str) -> bool {
    !s.is_empty()
        && s.bytes().all(|b| {
            b.is_ascii_lowercase() || b.is_ascii_digit() || matches!(b, b'_' | b'.' | b'-')
        })
}

/// `[a-z0-9_./-]+` — a Minecraft resource path.
pub fn valid_path(s: &str) -> bool {
    !s.is_empty()
        && !s.starts_with('/')
        && !s.ends_with('/')
        && s.bytes().all(|b| {
            b.is_ascii_lowercase() || b.is_ascii_digit() || matches!(b, b'_' | b'.' | b'-' | b'/')
        })
}

/// `ns:path` (or `path`, in `minecraft`) as a valid resource id.
pub fn valid_id(s: &str) -> bool {
    match s.split_once(':') {
        Some((ns, path)) => valid_namespace(ns) && valid_path(path),
        None => valid_path(s),
    }
}

// ── Finding ──────────────────────────────────────────────────────────────────

/// Every `content/**/*.yblock|*.yitem|*.yrecipe|*.ybook` of the mod at `root`, sorted.
pub fn find(root: &Path) -> Vec<PathBuf> {
    fn walk(dir: &Path, out: &mut Vec<PathBuf>) {
        let Ok(entries) = std::fs::read_dir(dir) else {
            return;
        };
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_dir() {
                walk(&path, out);
            } else if Kind::of(&path).is_some() {
                out.push(path);
            }
        }
    }
    let mut out = Vec::new();
    walk(&root.join(CONTENT_DIR), &mut out);
    out.sort();
    out
}

fn display(root: &Path, p: &Path) -> String {
    p.strip_prefix(root)
        .unwrap_or(p)
        .to_string_lossy()
        .replace('\\', "/")
}

// ── Compiling ────────────────────────────────────────────────────────────────

/// A name or tooltip.
#[derive(Debug, Clone)]
enum Text {
    /// A `.yres` text: its key.
    Key(String),
    Literal(String),
}

#[derive(Debug, Clone, Default)]
struct BlockProps {
    hardness: Option<f64>,
    resistance: Option<f64>,
    sound: Option<String>,
    light: u8,
    tool: Option<String>,
    tool_level: Option<String>,
    requires_tool: bool,
    no_collision: bool,
    slipperiness: Option<f64>,
    /// `None` = full cube.
    shape: Option<[f64; 6]>,
    connect_groups: Vec<String>,
    connects: bool,
    /// The inventory screen it opens (a `.yui` `<Screen>` with `<Slot>`s).
    inventory: Option<String>,
    /// Gives off redstone power, set by the mod per position.
    redstone: bool,
}

#[derive(Debug, Clone, Default)]
struct ItemProps {
    stack_size: Option<u8>,
    durability: u32,
    fire_resistant: bool,
    fuel_ticks: u32,
    /// (nutrition, saturation, always_edible)
    food: Option<(u32, f64, bool)>,
}

/// One checked content file — what the Rust code needs.
#[derive(Debug, Clone)]
struct Entry {
    kind: Kind,
    id: String,
    file: String,
    auto: bool,
    block: BlockProps,
    item: ItemProps,
}

/// Per-file checking state.
struct Ctx<'a> {
    root: &'a Path,
    refs: &'a yres::Refs,
    file: String,
    ns: String,
    errors: &'a mut Vec<String>,
    warnings: &'a mut Vec<String>,
    /// Bundled texture path → its source file.
    textures: &'a mut BTreeMap<String, PathBuf>,
    /// `block.inventory` screen ids named so far: (file, line, id) —
    /// checked against the mod's screens once every file is read.
    inventories: &'a mut Vec<(String, usize, String)>,
}

impl Ctx<'_> {
    fn err(&mut self, line: usize, msg: impl std::fmt::Display) {
        self.errors.push(format!("{}:{line}: {msg}", self.file));
    }

    fn warn(&mut self, line: usize, msg: impl std::fmt::Display) {
        self.warnings.push(format!("{}:{line}: {msg}", self.file));
    }

    /// Reports keys of `obj` not in `known`.
    fn unknown_keys(&mut self, obj: &J, what: &str, known: &[&str]) {
        for (k, v) in obj.members() {
            if !known.contains(&k.as_str()) && !is_metadata(k) {
                self.err(
                    v.line,
                    format!(
                        "unknown key {k:?} in {what} (expected one of: {})",
                        known.join(", ")
                    ),
                );
            }
        }
    }

    fn number(&mut self, j: &J, what: &str, min: f64, max: f64) -> Option<f64> {
        match j.num() {
            Some(n) if (min..=max).contains(&n) => Some(n),
            Some(n) => {
                self.err(j.line, format!("{what} is {n}, must be {min}..{max}"));
                None
            }
            None => {
                self.err(j.line, format!("{what} must be a number, not {}", j.kind()));
                None
            }
        }
    }

    fn boolean(&mut self, j: &J, what: &str) -> Option<bool> {
        let b = j.bool();
        if b.is_none() {
            self.err(j.line, format!("{what} must be true or false"));
        }
        b
    }

    fn string<'j>(&mut self, j: &'j J, what: &str) -> Option<&'j str> {
        let s = j.str();
        if s.is_none() {
            self.err(j.line, format!("{what} must be a string, not {}", j.kind()));
        }
        s
    }

    fn one_of(&mut self, j: &J, what: &str, allowed: &[&str]) -> Option<String> {
        let s = self.string(j, what)?;
        if allowed.contains(&s) {
            Some(s.to_string())
        } else {
            self.err(
                j.line,
                format!("{what} {s:?} isn't one of: {}", allowed.join(", ")),
            );
            None
        }
    }

    fn vec<const N: usize>(&mut self, j: &J, what: &str, min: f64, max: f64) -> Option<[f64; N]> {
        let items = j.items();
        if !j.is_arr() || items.len() != N {
            self.err(j.line, format!("{what} must be an array of {N} numbers"));
            return None;
        }
        let mut out = [0.0; N];
        for (i, item) in items.iter().enumerate() {
            out[i] = self.number(item, what, min, max)?;
        }
        Some(out)
    }

    /// A name/tooltip: `@<Set>.<name>` of a `.yres` text, `@@...` for a
    /// literal `@`, or a literal.
    fn text(&mut self, j: &J, what: &str) -> Option<Text> {
        let s = self.string(j, what)?;
        match s.strip_prefix('@') {
            Some(rest) if rest.starts_with('@') => Some(Text::Literal(rest.to_string())),
            Some(rest) => match self.refs.texts.get(rest) {
                Some((key, _)) => Some(Text::Key(key.clone())),
                None => {
                    self.err(
                        j.line,
                        format!("{what} `{s}`: no text `{rest}` in resources/*.yres"),
                    );
                    None
                }
            },
            None => Some(Text::Literal(s.to_string())),
        }
    }

    /// A texture: `#slot`, `@<Set>.<name>` (a `.yres` image), a `.png` path
    /// inside `resources/` (bundled), or a texture id (`ns:block/x`,
    /// `block/stone` = `minecraft:block/stone`). → the model's form.
    fn texture(&mut self, j: &J, what: &str) -> Option<String> {
        let s = self.string(j, what)?.trim().to_string();
        if let Some(slot) = s.strip_prefix('#') {
            if slot.is_empty() {
                self.err(j.line, format!("{what}: `#` needs a slot name"));
                return None;
            }
            return Some(s);
        }
        if let Some(rest) = s.strip_prefix('@') {
            return match self.refs.images.get(rest) {
                Some(id) => Some(id.clone()),
                None => {
                    self.err(
                        j.line,
                        format!("{what} `{s}`: no image `{rest}` in resources/*.yres"),
                    );
                    None
                }
            };
        }
        if let Some(stem) = s.strip_suffix(".png") {
            let rel = stem.trim_start_matches("./").trim_start_matches('/');
            let rel = rel.strip_prefix("resources/").unwrap_or(rel);
            if rel.split('/').any(|p| p == "..") || !valid_path(rel) {
                self.err(
                    j.line,
                    format!("{what} `{s}`: a path inside resources/ — lower case a-z, 0-9, `_`, `-`, `.`, `/`"),
                );
                return None;
            }
            let file = self
                .root
                .join(yres::RESOURCES_DIR)
                .join(format!("{rel}.png"));
            if !file.is_file() {
                self.err(j.line, format!("{what}: resources/{rel}.png doesn't exist"));
                return None;
            }
            let target = format!("assets/{}/textures/{rel}.png", self.ns);
            if let Some(other) = self.textures.insert(target.clone(), file.clone())
                && other != file
            {
                self.err(
                    j.line,
                    format!(
                        "{what}: {target} also comes from {}",
                        display(self.root, &other)
                    ),
                );
            }
            let meta = self
                .root
                .join(yres::RESOURCES_DIR)
                .join(format!("{rel}.png.mcmeta"));
            if meta.is_file() {
                self.textures.insert(format!("{target}.mcmeta"), meta);
            }
            return Some(format!("{}:{rel}", self.ns));
        }
        if !valid_id(&s) {
            self.err(
                j.line,
                format!("{what} `{s}` isn't a texture — `#slot`, `@Set.image`, `path/in/resources.png` or a texture id like `minecraft:block/stone`"),
            );
            return None;
        }
        let id = if s.contains(':') {
            s
        } else {
            format!("minecraft:{s}")
        };
        let (ns, path) = id.split_once(':').unwrap_or_default();
        if ns == self.ns {
            let file = self
                .root
                .join("assets")
                .join(ns)
                .join("textures")
                .join(format!("{path}.png"));
            let bundled = self
                .textures
                .contains_key(&format!("assets/{ns}/textures/{path}.png"))
                || self.refs.images.values().any(|v| *v == id);
            if !file.is_file() && !bundled {
                self.warn(
                    j.line,
                    format!("{what}: texture {id} isn't in assets/{ns}/textures/ or resources/"),
                );
            }
        }
        Some(id)
    }
}

/// A checked model: Minecraft's JSON, its slots, its bounding box.
struct Model {
    json: Value,
    /// Elements' bounding box in pixels, when it has elements.
    bounds: Option<[f64; 6]>,
}

/// Checks a model object → Minecraft's model JSON. `item` = an item model
/// (sprite templates allowed).
fn model(cx: &mut Ctx, j: &J, what: &str, item: bool) -> Option<Model> {
    if !j.is_obj() {
        cx.err(j.line, format!("{what} must be an object"));
        return None;
    }
    cx.unknown_keys(
        j,
        what,
        &[
            "parent",
            "textures",
            "elements",
            "display",
            "ambient_occlusion",
            "gui_light",
        ],
    );
    let mut out = Map::new();
    let mut tpl: Option<&Template> = None;
    let mut raw_parent = false;
    if let Some(p) = j.get("parent") {
        let name = cx.string(p, &format!("{what}.parent"))?;
        if let Some(t) = template(name) {
            if t.sprite && !item {
                cx.err(p.line, format!("{what}.parent {name:?} is an item sprite — block models use cube_all, cube_column, ..."));
            }
            out.insert("parent".into(), Value::String(t.parent.into()));
            tpl = Some(t);
        } else if name.contains(':') && valid_id(name) {
            out.insert("parent".into(), Value::String(name.into()));
            raw_parent = true;
        } else {
            let names: Vec<&str> = TEMPLATES
                .iter()
                .filter(|t| item || !t.sprite)
                .map(|t| t.name)
                .collect();
            cx.err(
                p.line,
                format!("{what}.parent {name:?} isn't a template ({}) or a model id like `minecraft:block/stairs`", names.join(", ")),
            );
            return None;
        }
    }

    // Textures.
    let mut slots: Vec<String> = Vec::new();
    let mut textures = Map::new();
    if let Some(t) = j.get("textures") {
        if !t.is_obj() {
            cx.err(
                t.line,
                format!("{what}.textures must be an object of slot → texture"),
            );
        }
        for (slot, v) in t.members() {
            if slot.is_empty() || slot.starts_with('#') {
                cx.err(
                    v.line,
                    format!("{what}.textures: slot names are plain words (`all`, `side`, `0`)"),
                );
                continue;
            }
            if let Some(tex) = cx.texture(v, &format!("{what}.textures.{slot}")) {
                textures.insert(slot.clone(), Value::String(tex));
                slots.push(slot.clone());
            }
        }
    }
    let defined = |slot: &str, textures: &Map<String, Value>| textures.contains_key(slot);
    if let Some(t) = tpl {
        if t.sprite {
            if !defined("layer0", &textures) {
                cx.err(
                    j.line,
                    format!("{what}: parent {:?} needs textures.layer0", t.name),
                );
            }
            for slot in &slots {
                let n = slot
                    .strip_prefix("layer")
                    .and_then(|n| n.parse::<usize>().ok());
                match n {
                    Some(n) if n == 0 || defined(&format!("layer{}", n - 1), &textures) => {}
                    Some(_) => cx.err(j.line, format!("{what}: textures.{slot} without the layer before it")),
                    None if slot == "particle" => {}
                    None => cx.warn(j.line, format!("{what}: textures.{slot} isn't used by an item sprite (layer0, layer1, ...)")),
                }
            }
        } else {
            for slot in t.slots {
                if !defined(slot, &textures) {
                    cx.err(
                        j.line,
                        format!("{what}: parent {:?} needs textures.{slot}", t.name),
                    );
                }
            }
        }
    }

    // Elements.
    let mut bounds: Option<[f64; 6]> = None;
    if let Some(e) = j.get("elements") {
        if let Some(t) = tpl {
            cx.err(
                e.line,
                format!(
                    "{what}: elements replace the shape of parent {:?} — remove one of them",
                    t.name
                ),
            );
        }
        if !e.is_arr() {
            cx.err(e.line, format!("{what}.elements must be an array"));
        }
        let mut elements = Vec::new();
        for (i, el) in e.items().iter().enumerate() {
            if let Some((json, from, to)) = element(
                cx,
                el,
                &format!("{what}.elements[{i}]"),
                &textures,
                raw_parent,
            ) {
                let b = bounds.get_or_insert([16.0, 16.0, 16.0, 0.0, 0.0, 0.0]);
                for a in 0..3 {
                    b[a] = b[a].min(from[a].min(to[a]));
                    b[a + 3] = b[a + 3].max(from[a].max(to[a]));
                }
                elements.push(json);
            }
        }
        out.insert("elements".into(), Value::Array(elements));
    } else if tpl.is_none() && !raw_parent {
        cx.err(j.line, format!("{what}: no parent and no elements — give a template (\"parent\": \"cube_all\") or elements"));
    }

    // `particle` — the break/run particles. Default: the first texture —
    // also under a raw parent when the model brings its own elements (a
    // parent like `minecraft:block/block` names no particle texture).
    if !textures.contains_key("particle")
        && !tpl.is_some_and(|t| t.has_particle)
        && (!raw_parent || j.get("elements").is_some())
        && let Some(first) = slots.first()
    {
        let v = textures[first].clone();
        textures.insert("particle".into(), v);
    }
    if !textures.is_empty() {
        out.insert("textures".into(), Value::Object(textures));
    }

    if let Some(d) = j.get("display") {
        if !d.is_obj() {
            cx.err(d.line, format!("{what}.display must be an object"));
        }
        let mut display = Map::new();
        for (slot, t) in d.members() {
            let w = format!("{what}.display.{slot}");
            if !DISPLAY_SLOTS.contains(&slot.as_str()) {
                cx.err(
                    t.line,
                    format!(
                        "{w}: unknown display position (expected one of: {})",
                        DISPLAY_SLOTS.join(", ")
                    ),
                );
                continue;
            }
            cx.unknown_keys(t, &w, &["rotation", "translation", "scale"]);
            let mut m = Map::new();
            for (key, lim) in [("rotation", 360.0), ("translation", 80.0), ("scale", 4.0)] {
                if let Some(v) = t.get(key)
                    && let Some(v3) = cx.vec::<3>(v, &format!("{w}.{key}"), -lim, lim)
                {
                    m.insert(
                        key.into(),
                        Value::Array(v3.iter().map(|n| num_value(*n)).collect()),
                    );
                }
            }
            display.insert(slot.clone(), Value::Object(m));
        }
        out.insert("display".into(), Value::Object(display));
    }
    if let Some(ao) = j.get("ambient_occlusion")
        && let Some(b) = cx.boolean(ao, &format!("{what}.ambient_occlusion"))
    {
        out.insert("ambientocclusion".into(), Value::Bool(b));
    }
    if let Some(gl) = j.get("gui_light")
        && let Some(s) = cx.one_of(gl, &format!("{what}.gui_light"), &["front", "side"])
    {
        out.insert("gui_light".into(), Value::String(s));
    }
    Some(Model {
        json: Value::Object(out),
        bounds,
    })
}

/// Checks one element → (its JSON, from, to).
fn element(
    cx: &mut Ctx,
    j: &J,
    what: &str,
    textures: &Map<String, Value>,
    raw_parent: bool,
) -> Option<(Value, [f64; 3], [f64; 3])> {
    if !j.is_obj() {
        cx.err(j.line, format!("{what} must be an object"));
        return None;
    }
    cx.unknown_keys(
        j,
        what,
        &["name", "from", "to", "rotation", "shade", "faces"],
    );
    if let Some(n) = j.get("name") {
        cx.string(n, &format!("{what}.name"));
    }
    let (Some(from_j), Some(to_j)) = (j.get("from"), j.get("to")) else {
        cx.err(j.line, format!("{what} needs `from` and `to`"));
        return None;
    };
    let from = cx.vec::<3>(from_j, &format!("{what}.from"), -16.0, 32.0)?;
    let to = cx.vec::<3>(to_j, &format!("{what}.to"), -16.0, 32.0)?;
    let mut out = Map::new();
    out.insert(
        "from".into(),
        Value::Array(from.iter().map(|n| num_value(*n)).collect()),
    );
    out.insert(
        "to".into(),
        Value::Array(to.iter().map(|n| num_value(*n)).collect()),
    );
    if let Some(r) = j.get("rotation") {
        let w = format!("{what}.rotation");
        cx.unknown_keys(r, &w, &["origin", "axis", "angle", "rescale"]);
        let axis = r
            .get("axis")
            .and_then(|a| cx.one_of(a, &format!("{w}.axis"), &["x", "y", "z"]));
        let angle = r
            .get("angle")
            .and_then(|a| cx.number(a, &format!("{w}.angle"), -45.0, 45.0));
        if let Some(a) = angle
            && (a / 22.5).fract() != 0.0
        {
            cx.err(r.line, format!("{w}.angle is {a} — Minecraft rotates elements by -45, -22.5, 0, 22.5 or 45 degrees"));
        }
        let origin = match r.get("origin") {
            Some(o) => cx.vec::<3>(o, &format!("{w}.origin"), -16.0, 32.0),
            None => Some([8.0, 8.0, 8.0]),
        };
        if axis.is_none() || angle.is_none() {
            if r.get("axis").is_none() || r.get("angle").is_none() {
                cx.err(r.line, format!("{w} needs `axis` and `angle`"));
            }
        } else if let (Some(axis), Some(angle), Some(origin)) = (axis, angle, origin) {
            let mut rot = Map::new();
            rot.insert(
                "origin".into(),
                Value::Array(origin.iter().map(|n| num_value(*n)).collect()),
            );
            rot.insert("axis".into(), Value::String(axis));
            rot.insert("angle".into(), num_value(angle));
            if let Some(rs) = r.get("rescale")
                && let Some(b) = cx.boolean(rs, &format!("{w}.rescale"))
                && b
            {
                rot.insert("rescale".into(), Value::Bool(true));
            }
            out.insert("rotation".into(), Value::Object(rot));
        }
    }
    if let Some(s) = j.get("shade")
        && let Some(b) = cx.boolean(s, &format!("{what}.shade"))
        && !b
    {
        out.insert("shade".into(), Value::Bool(false));
    }
    let mut faces = Map::new();
    match j.get("faces") {
        None => cx.warn(j.line, format!("{what} has no faces — it's invisible")),
        Some(f) => {
            if !f.is_obj() {
                cx.err(
                    f.line,
                    format!("{what}.faces must be an object of direction → face"),
                );
            }
            for (dir, face) in f.members() {
                let w = format!("{what}.faces.{dir}");
                if !DIRECTIONS.contains(&dir.as_str()) {
                    cx.err(
                        face.line,
                        format!(
                            "{w}: unknown face (expected one of: {})",
                            DIRECTIONS.join(", ")
                        ),
                    );
                    continue;
                }
                cx.unknown_keys(face, &w, &["texture", "uv", "rotation", "cullface", "tint"]);
                let mut fo = Map::new();
                match face.get("texture") {
                    None => cx.err(face.line, format!("{w} needs a texture (`#slot`)")),
                    Some(t) => {
                        if let Some(s) = cx.string(t, &format!("{w}.texture")) {
                            let slot = s.strip_prefix('#').unwrap_or(s);
                            if !textures.contains_key(slot) && !raw_parent {
                                cx.err(
                                    t.line,
                                    format!("{w}.texture `#{slot}`: no such slot in textures"),
                                );
                            }
                            fo.insert("texture".into(), Value::String(format!("#{slot}")));
                        }
                    }
                }
                if let Some(uv) = face.get("uv")
                    && let Some(uv) = cx.vec::<4>(uv, &format!("{w}.uv"), 0.0, 16.0)
                {
                    fo.insert(
                        "uv".into(),
                        Value::Array(uv.iter().map(|n| num_value(*n)).collect()),
                    );
                }
                if let Some(r) = face.get("rotation") {
                    match r.num() {
                        Some(n) if [0.0, 90.0, 180.0, 270.0].contains(&n) => {
                            if n != 0.0 {
                                fo.insert("rotation".into(), num_value(n));
                            }
                        }
                        _ => cx.err(r.line, format!("{w}.rotation must be 0, 90, 180 or 270")),
                    }
                }
                if let Some(c) = face.get("cullface")
                    && let Some(c) = cx.one_of(c, &format!("{w}.cullface"), &DIRECTIONS)
                {
                    fo.insert("cullface".into(), Value::String(c));
                }
                if let Some(t) = face.get("tint")
                    && let Some(n) = cx.number(t, &format!("{w}.tint"), -1.0, 255.0)
                    && n >= 0.0
                {
                    fo.insert("tintindex".into(), num_value(n.floor()));
                }
                faces.insert(dir.clone(), Value::Object(fo));
            }
        }
    }
    out.insert("faces".into(), Value::Object(faces));
    Some((Value::Object(out), from, to))
}

/// The id of a file: `"id"` or the file stem; `ns:` defaults to the mod's.
fn entry_id(cx: &mut Ctx, j: &J, path: &Path, mod_ns: Option<&str>) -> Option<(String, String)> {
    let (raw, line) = match j.get("id") {
        Some(v) => (cx.string(v, "id")?.to_string(), v.line),
        None => (
            path.file_stem()
                .unwrap_or_default()
                .to_string_lossy()
                .into_owned(),
            1,
        ),
    };
    let (ns, p) = match raw.split_once(':') {
        Some((ns, p)) => (ns.to_string(), p.to_string()),
        None => match mod_ns {
            Some(ns) => (ns.to_string(), raw.clone()),
            None => {
                cx.err(
                    line,
                    "the mod id isn't a valid Minecraft namespace (a-z, 0-9, `_`, `-`, `.`), so give the namespace: \"id\": \"mynamespace:name\"",
                );
                return None;
            }
        },
    };
    if !valid_namespace(&ns) || !valid_path(&p) {
        cx.err(
            line,
            format!("id `{ns}:{p}` isn't a valid Minecraft id — lower case a-z, 0-9, `_`, `-`, `.` (and `/` in the path)"),
        );
        return None;
    }
    Some((ns, p))
}

/// The JSON of one block state: `{"model": ..., "x": .., "y": .., ...}`.
fn variant(model: &str, x: f64, y: f64, uvlock: bool, weight: Option<f64>) -> Value {
    let mut v = Map::new();
    v.insert("model".into(), Value::String(model.into()));
    if x != 0.0 {
        v.insert("x".into(), num_value(x));
    }
    if y != 0.0 {
        v.insert("y".into(), num_value(y));
    }
    if uvlock {
        v.insert("uvlock".into(), Value::Bool(true));
    }
    if let Some(w) = weight
        && w != 1.0
    {
        v.insert("weight".into(), num_value(w));
    }
    Value::Object(v)
}

fn pretty(v: &Value) -> Vec<u8> {
    let mut s = serde_json::to_string_pretty(v).unwrap_or_default();
    s.push('\n');
    s.into_bytes()
}

/// Compiles one file; pushes its outputs.
#[allow(clippy::too_many_arguments)]
fn compile_file(
    cx: &mut Ctx,
    j: &J,
    kind: Kind,
    path: &Path,
    mod_ns: Option<&str>,
    out: &mut Compiled,
    generated: &mut BTreeMap<String, String>,
) -> Option<Entry> {
    if !j.is_obj() {
        cx.err(
            j.line,
            format!("a .y{} file is one JSON object", kind.word()),
        );
        return None;
    }
    let common = [
        "$schema", "format", "id", "name", "tooltip", "register", "model",
    ];
    let specific: &[&str] = match kind {
        Kind::Block => &["block", "item_model", "states"],
        Kind::Item => &["item"],
        Kind::Recipe | Kind::Book => unreachable!("only blocks and items get here"),
    };
    let known: Vec<&str> = common.iter().chain(specific).copied().collect();
    cx.unknown_keys(j, &format!("a .y{}", kind.word()), &known);
    if let Some(f) = j.get("format")
        && f.num() != Some(1.0)
    {
        cx.err(f.line, "format must be 1 (this yog understands format 1)");
    }
    let (ns, p) = entry_id(cx, j, path, mod_ns)?;
    cx.ns = ns.clone();
    let id = format!("{ns}:{p}");

    let auto = match j.get("register") {
        None => true,
        Some(r) => cx
            .one_of(r, "register", &["auto", "manual"])
            .is_none_or(|s| s == "auto"),
    };

    // Name and tooltip → lang, under the keys the game looks up.
    let key = format!("{}.{ns}.{}", kind.word(), p.replace('/', "."));
    for (field, target) in [("name", key.clone()), ("tooltip", format!("{key}.desc"))] {
        let Some(v) = j.get(field) else { continue };
        match cx.text(v, field)? {
            Text::Key(from) if from == target => {}
            Text::Key(from) => out.lang_aliases.push((from, target)),
            Text::Literal(s) => {
                out.lang
                    .entry((ns.clone(), yres::NEUTRAL_LOCALE.to_string()))
                    .or_default()
                    .insert(target, s);
            }
        }
    }

    let mut emit = |cx: &mut Ctx, rel: String, value: &Value| {
        let full = format!("assets/{ns}/{rel}");
        if cx.root.join(&full).is_file() {
            cx.err(1, format!("{full} is written by this file — delete the hand-written one (or bring it in with `yog import model`)"));
        }
        if let Some(other) = generated.insert(full.clone(), cx.file.clone()) {
            cx.err(1, format!("{full} is also written by {other}"));
        }
        out.outputs.push((full, pretty(value)));
    };

    let mut entry = Entry {
        kind,
        id: id.clone(),
        file: cx.file.clone(),
        auto,
        block: BlockProps::default(),
        item: ItemProps::default(),
    };

    match kind {
        Kind::Recipe | Kind::Book => unreachable!("only blocks and items get here"),
        Kind::Item => {
            if let Some(it) = j.get("item") {
                cx.unknown_keys(
                    it,
                    "item",
                    &[
                        "stack_size",
                        "durability",
                        "fire_resistant",
                        "fuel_ticks",
                        "food",
                    ],
                );
                let props = &mut entry.item;
                if let Some(v) = it.get("stack_size") {
                    props.stack_size = cx.number(v, "item.stack_size", 1.0, 99.0).map(|n| n as u8);
                }
                if let Some(v) = it.get("durability") {
                    props.durability =
                        cx.number(v, "item.durability", 0.0, 1e9).unwrap_or(0.0) as u32;
                }
                if let Some(v) = it.get("fire_resistant") {
                    props.fire_resistant = cx.boolean(v, "item.fire_resistant").unwrap_or(false);
                }
                if let Some(v) = it.get("fuel_ticks") {
                    props.fuel_ticks =
                        cx.number(v, "item.fuel_ticks", 0.0, 1e9).unwrap_or(0.0) as u32;
                }
                if let Some(f) = it.get("food") {
                    cx.unknown_keys(
                        f,
                        "item.food",
                        &["nutrition", "saturation", "always_edible"],
                    );
                    let n = f
                        .get("nutrition")
                        .and_then(|v| cx.number(v, "item.food.nutrition", 0.0, 1000.0));
                    let s = f
                        .get("saturation")
                        .and_then(|v| cx.number(v, "item.food.saturation", 0.0, 100.0));
                    let a = f
                        .get("always_edible")
                        .and_then(|v| cx.boolean(v, "item.food.always_edible"));
                    if n.is_none() {
                        cx.err(f.line, "item.food needs nutrition");
                    }
                    props.food = n.map(|n| (n as u32, s.unwrap_or(0.0), a.unwrap_or(false)));
                }
                if props.durability > 0 && props.stack_size.is_some_and(|s| s > 1) {
                    cx.warn(
                        it.line,
                        "item.stack_size is ignored: an item with durability stacks to 1",
                    );
                }
            }
            let Some(mj) = j.get("model") else {
                cx.err(j.line, "an item needs a model — e.g. { \"parent\": \"generated\", \"textures\": { \"layer0\": \"@Textures.ruby\" } }");
                return Some(entry);
            };
            let m = model(cx, mj, "model", true)?;
            emit(cx, format!("models/item/{p}.json"), &m.json);
            emit(
                cx,
                format!("items/{p}.json"),
                &json!({ "model": { "type": "minecraft:model", "model": format!("{ns}:item/{p}") } }),
            );
        }
        Kind::Block => {
            let mut render_layer: Option<String> = None;
            let mut drops = Value::Null;
            let mut shape_auto = true;
            if let Some(b) = j.get("block") {
                cx.unknown_keys(
                    b,
                    "block",
                    &[
                        "hardness",
                        "resistance",
                        "sound",
                        "light",
                        "tool",
                        "tool_level",
                        "requires_tool",
                        "collision",
                        "slipperiness",
                        "shape",
                        "render_layer",
                        "drops",
                        "connect_groups",
                        "inventory",
                        "redstone",
                    ],
                );
                let props = &mut entry.block;
                if let Some(v) = b.get("hardness") {
                    props.hardness = cx.number(v, "block.hardness", -1.0, 1e6);
                }
                if let Some(v) = b.get("resistance") {
                    props.resistance = cx.number(v, "block.resistance", 0.0, 1e7);
                }
                if let Some(v) = b.get("sound") {
                    props.sound = cx.one_of(v, "block.sound", &SOUNDS);
                }
                if let Some(v) = b.get("light") {
                    props.light = cx.number(v, "block.light", 0.0, 15.0).unwrap_or(0.0) as u8;
                }
                if let Some(v) = b.get("tool") {
                    props.tool = cx.one_of(v, "block.tool", &TOOLS);
                }
                if let Some(v) = b.get("tool_level") {
                    props.tool_level = cx.one_of(v, "block.tool_level", &TOOL_LEVELS);
                }
                if let Some(v) = b.get("requires_tool") {
                    props.requires_tool = cx.boolean(v, "block.requires_tool").unwrap_or(false);
                }
                if let Some(v) = b.get("collision") {
                    props.no_collision = !cx.boolean(v, "block.collision").unwrap_or(true);
                }
                if let Some(v) = b.get("slipperiness") {
                    props.slipperiness = cx.number(v, "block.slipperiness", 0.0, 1.0);
                }
                if let Some(v) = b.get("shape") {
                    match &v.v {
                        V::Str(s) if s == "auto" => {}
                        V::Str(s) if s == "full" => shape_auto = false,
                        V::Arr(_) => {
                            shape_auto = false;
                            props.shape = cx.vec::<6>(v, "block.shape", 0.0, 16.0);
                        }
                        _ => cx.err(v.line, "block.shape must be \"auto\" (the model's bounds), \"full\" or [x1, y1, z1, x2, y2, z2] in pixels"),
                    }
                }
                if let Some(v) = b.get("render_layer") {
                    render_layer = cx.one_of(v, "block.render_layer", &RENDER_LAYERS);
                }
                if let Some(v) = b.get("redstone") {
                    props.redstone = cx.boolean(v, "block.redstone").unwrap_or(false);
                }
                if let Some(v) = b.get("inventory")
                    && let Some(id) = cx.string(v, "block.inventory")
                {
                    if valid_id(id) && id.contains(':') {
                        props.inventory = Some(id.to_string());
                        let at = (cx.file.clone(), v.line, id.to_string());
                        cx.inventories.push(at);
                    } else {
                        cx.err(v.line, format!("block.inventory `{id}`: the id of an inventory screen — a .yui <Screen id=\"mymod:name\"> with <Slot>s"));
                    }
                }
                if let Some(v) = b.get("connect_groups") {
                    for g in v.items() {
                        if let Some(s) = cx.string(g, "block.connect_groups[]") {
                            props.connect_groups.push(s.to_string());
                        }
                    }
                    if !v.is_arr() {
                        cx.err(
                            v.line,
                            "block.connect_groups must be an array of group names",
                        );
                    }
                }
                if props.tool_level.is_some() && props.tool.is_none() {
                    cx.warn(
                        b.line,
                        "block.tool_level without block.tool — any tool of that level mines it",
                    );
                }
                if let Some(d) = b.get("drops") {
                    drops = drops_table(cx, d, &id);
                }
            }
            if drops.is_null() && !j.get("block").and_then(|b| b.get("drops")).is_some() {
                drops = drops_table_self(&id);
            }

            let Some(mj) = j.get("model") else {
                cx.err(j.line, "a block needs a model — e.g. { \"parent\": \"cube_all\", \"textures\": { \"all\": \"@Textures.ruby_block\" } }");
                return Some(entry);
            };
            let mut m = model(cx, mj, "model", false)?;
            if let (Some(layer), Value::Object(o)) = (&render_layer, &mut m.json) {
                // Forge/NeoForge read it from the model; Fabric ignores it.
                o.insert(
                    "render_type".into(),
                    Value::String(format!("minecraft:{layer}")),
                );
            }
            if shape_auto {
                entry.block.shape = m
                    .bounds
                    .filter(|b| *b != [0.0, 0.0, 0.0, 16.0, 16.0, 16.0])
                    .map(|b| {
                        [
                            b[0].max(0.0),
                            b[1].max(0.0),
                            b[2].max(0.0),
                            b[3].min(16.0),
                            b[4].min(16.0),
                            b[5].min(16.0),
                        ]
                    });
            }
            let main = format!("{ns}:block/{p}");
            emit(cx, format!("models/block/{p}.json"), &m.json);

            // Block states.
            let mut rotations: Vec<Value> = Vec::new();
            let mut arm: Option<(String, bool)> = None;
            if let Some(s) = j.get("states") {
                cx.unknown_keys(s, "states", &["rotations", "connect"]);
                if let Some(r) = s.get("rotations") {
                    if !r.is_arr() || r.items().is_empty() {
                        cx.err(r.line, "states.rotations must be a non-empty array of { \"x\": 0, \"y\": 90, \"weight\": 1, \"uvlock\": false }");
                    }
                    for (i, rot) in r.items().iter().enumerate() {
                        let w = format!("states.rotations[{i}]");
                        cx.unknown_keys(rot, &w, &["x", "y", "weight", "uvlock"]);
                        let mut angle = |k: &str| -> f64 {
                            match rot.get(k).map(|v| (v, v.num())) {
                                None => 0.0,
                                Some((_, Some(n))) if [0.0, 90.0, 180.0, 270.0].contains(&n) => n,
                                Some((v, _)) => {
                                    cx.err(v.line, format!("{w}.{k} must be 0, 90, 180 or 270"));
                                    0.0
                                }
                            }
                        };
                        let (x, y) = (angle("x"), angle("y"));
                        let weight = rot
                            .get("weight")
                            .and_then(|v| cx.number(v, &format!("{w}.weight"), 1.0, 1e6));
                        let uvlock = rot
                            .get("uvlock")
                            .and_then(|v| cx.boolean(v, &format!("{w}.uvlock")))
                            .unwrap_or(false);
                        rotations.push(variant(&main, x, y, uvlock, weight));
                    }
                }
                if let Some(c) = s.get("connect") {
                    cx.unknown_keys(c, "states.connect", &["arm", "uvlock"]);
                    let uvlock = c
                        .get("uvlock")
                        .and_then(|v| cx.boolean(v, "states.connect.uvlock"))
                        .unwrap_or(false);
                    match c.get("arm") {
                        None => cx.err(
                            c.line,
                            "states.connect needs `arm` — the model of the arm towards north",
                        ),
                        Some(a) => {
                            if let Some(am) = model(cx, a, "states.connect.arm", false) {
                                let mut json = am.json;
                                if let (Some(layer), Value::Object(o)) = (&render_layer, &mut json)
                                {
                                    o.insert(
                                        "render_type".into(),
                                        Value::String(format!("minecraft:{layer}")),
                                    );
                                }
                                emit(cx, format!("models/block/{p}_arm.json"), &json);
                                arm = Some((format!("{ns}:block/{p}_arm"), uvlock));
                            }
                        }
                    }
                    entry.block.connects = true;
                    if entry.block.connect_groups.is_empty() {
                        entry.block.connect_groups.push(id.clone());
                    }
                }
            }
            let base: Value = match rotations.len() {
                0 => variant(&main, 0.0, 0.0, false, None),
                1 => rotations.remove(0),
                _ => Value::Array(rotations),
            };
            let blockstate = match &arm {
                None => json!({ "variants": { "": base } }),
                Some((arm, uvlock)) => {
                    let mut parts = vec![json!({ "apply": base })];
                    for (dir, x, y) in [
                        ("north", 0.0, 0.0),
                        ("east", 0.0, 90.0),
                        ("south", 0.0, 180.0),
                        ("west", 0.0, 270.0),
                        ("up", 270.0, 0.0),
                        ("down", 90.0, 0.0),
                    ] {
                        parts.push(json!({ "when": { dir: "true" }, "apply": variant(arm, x, y, *uvlock, None) }));
                    }
                    json!({ "multipart": parts })
                }
            };
            emit(cx, format!("blockstates/{p}.json"), &blockstate);

            // The item form: the block model, or its own.
            let item_model = match j.get("item_model") {
                None => Some(json!({ "parent": main })),
                Some(im) => model(cx, im, "item_model", true).map(|m| m.json),
            };
            if let Some(im) = item_model {
                emit(cx, format!("models/item/{p}.json"), &im);
            }
            emit(
                cx,
                format!("items/{p}.json"),
                &json!({ "model": { "type": "minecraft:model", "model": format!("{ns}:item/{p}") } }),
            );

            if !drops.is_null() {
                let full = format!("data/{ns}/loot_table/blocks/{p}.json");
                let plural = format!("data/{ns}/loot_tables/blocks/{p}.json");
                if cx.root.join(&full).is_file() || cx.root.join(&plural).is_file() {
                    cx.err(1, format!("{full} is written by this file (block.drops) — delete the hand-written one, or set \"drops\": \"none\""));
                }
                out.outputs.push((full, pretty(&drops)));
            }
            if let Some(tool) = &entry.block.tool {
                out.tags
                    .entry(format!("data/minecraft/tags/block/mineable/{tool}.json"))
                    .or_default()
                    .insert(id.clone());
            }
            if let Some(level) = &entry.block.tool_level {
                out.tags
                    .entry(format!("data/minecraft/tags/block/needs_{level}_tool.json"))
                    .or_default()
                    .insert(id.clone());
            }
        }
    }
    Some(entry)
}

fn drops_table_self(id: &str) -> Value {
    json!({
        "type": "minecraft:block",
        "pools": [{
            "rolls": 1,
            "entries": [{ "type": "minecraft:item", "name": id }],
            "conditions": [{ "condition": "minecraft:survives_explosion" }]
        }]
    })
}

/// `"self"`, `"none"` or `{ "item": "ns:x", "count": 2 | [1, 3] }`.
fn drops_table(cx: &mut Ctx, d: &J, id: &str) -> Value {
    match &d.v {
        V::Str(s) if s == "self" => drops_table_self(id),
        V::Str(s) if s == "none" => Value::Null,
        V::Obj(_) => {
            cx.unknown_keys(d, "block.drops", &["item", "count"]);
            let item = match d.get("item") {
                Some(i) => match cx.string(i, "block.drops.item") {
                    Some(s) if valid_id(s) => {
                        if s.contains(':') {
                            s.to_string()
                        } else {
                            format!("minecraft:{s}")
                        }
                    }
                    Some(s) => {
                        cx.err(i.line, format!("block.drops.item `{s}` isn't an item id"));
                        return Value::Null;
                    }
                    None => return Value::Null,
                },
                None => id.to_string(),
            };
            let mut entry = json!({ "type": "minecraft:item", "name": item });
            if let Some(c) = d.get("count") {
                let count = match &c.v {
                    V::Num(_) => cx.number(c, "block.drops.count", 1.0, 64.0).map(num_value),
                    V::Arr(_) => cx.vec::<2>(c, "block.drops.count", 0.0, 64.0).map(|[min, max]| {
                        json!({ "type": "minecraft:uniform", "min": num_value(min), "max": num_value(max) })
                    }),
                    _ => {
                        cx.err(c.line, "block.drops.count must be a number or [min, max]");
                        None
                    }
                };
                if let Some(count) = count {
                    entry["functions"] =
                        json!([{ "function": "minecraft:set_count", "count": count }]);
                }
            }
            json!({
                "type": "minecraft:block",
                "pools": [{
                    "rolls": 1,
                    "entries": [entry],
                    "conditions": [{ "condition": "minecraft:survives_explosion" }]
                }]
            })
        }
        _ => {
            cx.err(d.line, "block.drops must be \"self\", \"none\" or { \"item\": \"ns:item\", \"count\": [1, 3] }");
            Value::Null
        }
    }
}

// ── Recipes ──────────────────────────────────────────────────────────────────

/// What a recipe takes.
#[derive(Debug, Clone)]
enum RecipeKind {
    /// A crafting grid pattern: rows of key characters (space = empty);
    /// each key any of several items.
    Shaped { pattern: Vec<String>, key: Vec<(char, Vec<String>)> },
    /// Crafting ingredients in any arrangement.
    Shapeless(Vec<Vec<String>>),
    /// Cooking (`method`: `Smelting`, `Blasting`, `Smoking`, `Campfire`).
    Cooking { method: &'static str, input: Vec<String>, experience: f64, cook_time: u32 },
    Stonecutting(Vec<String>),
    Smithing { template: Vec<String>, base: Vec<String>, addition: Vec<String> },
    /// The mod's own kind of recipe (`mymod:infusion`), for its machines
    /// and books — not the game's: named slots, each a list of ingredients
    /// (an ingredient any of several items), and values (`time`, `energy`…).
    Custom { kind: String, slots: Vec<(String, Vec<Vec<String>>)>, values: serde_json::Map<String, Value> },
}

/// One checked `.ybook`.
struct BookFile {
    id: String,
    /// The book as the runtime reads it, references resolved.
    json: String,
}

/// Checks one `.ybook`: a `yog_book::Book` as JSON, whose references
/// (`@item:minecraft:stick`, see `yog_book::refs`) must name what exists
/// — in this mod, on every Minecraft version, or among the other mods'
/// ids `yog.toml` declares — and come out as plain ids. Texts may be
/// `@<Set>.<name>` (a `.yres` text), `@item:<id>` / `@block:<id>` /
/// `@entity:<id>` (its name) or `@@…` (a literal `@`); a book with text
/// references is shown in the player's language. An `id` without a
/// namespace gets the mod's.
fn compile_book(cx: &mut Ctx, j: &J, mod_ns: Option<&str>, known: &refs::Known) -> Option<BookFile> {
    use yog_book::refs::{self as r, RefKind};

    fn plain(j: &J) -> Value {
        match &j.v {
            V::Null => Value::Null,
            V::Bool(b) => Value::Bool(*b),
            V::Num(n) => serde_json::Number::from_f64(*n).map_or(Value::Null, |n| {
                // Whole numbers stay integers (sortnum, priority, version).
                if n.as_f64().is_some_and(|f| f.fract() == 0.0 && f.abs() < 9e15) {
                    Value::from(n.as_f64().unwrap_or(0.0) as i64)
                } else {
                    Value::Number(n)
                }
            }),
            V::Str(s) => Value::String(s.clone()),
            V::Arr(items) => Value::Array(items.iter().map(plain).collect()),
            V::Obj(members) => Value::Object(members.iter().map(|(k, v)| (k.clone(), plain(v))).collect()),
        }
    }

    /// The line of `path` (`entries[2].pages[0].item`) in the file.
    fn line_of(j: &J, path: &str) -> usize {
        let mut at = j;
        for seg in path.split('.') {
            let (key, idx) = match seg.split_once('[') {
                Some((k, rest)) => (k, rest.trim_end_matches(']').parse::<usize>().ok()),
                None => (seg, None),
            };
            let Some(next) = at.get(key) else { break };
            at = next;
            if let Some(i) = idx
                && let Some(item) = at.items().get(i)
            {
                at = item;
            }
        }
        at.line
    }

    struct Check<'a> {
        known: &'a refs::Known,
        texts: &'a HashMap<String, (String, String)>,
        entries: HashSet<String>,
        categories: HashSet<String>,
        text_refs: bool,
        errors: Vec<String>,
    }

    impl r::Resolver for Check<'_> {
        fn reference(&mut self, kind: RefKind, id: &str, _path: &str) -> Result<String, String> {
            let own = match kind {
                RefKind::Entry => Some(&self.entries),
                RefKind::Category => Some(&self.categories),
                _ => None,
            };
            match own {
                Some(set) if set.contains(id) => Ok(id.to_string()),
                Some(_) => Err(format!("no {} {id} in this book", kind.word())),
                None => self.known.check(kind, id).map(|()| id.to_string()),
            }
        }

        fn text(&mut self, text: &str, path: &str) -> Option<String> {
            let rest = text.strip_prefix('@')?;
            if let Some(lit) = rest.strip_prefix('@') {
                return Some(format!("@{lit}"));
            }
            // A name: the game's translation of the item, block or entity.
            if let Some((kind, id)) = r::parse(text) {
                let word = match kind {
                    RefKind::Item | RefKind::Block | RefKind::Entity => kind.word(),
                    _ => {
                        self.errors.push(format!("{path}: `{text}` has no name to show"));
                        return None;
                    }
                };
                if let Err(e) = self.known.check(kind, id) {
                    self.errors.push(format!("{path}: {e}"));
                }
                let (ns, p) = r::bare(id).split_once(':').unwrap_or(("minecraft", id));
                self.text_refs = true;
                return Some(format!("{word}.{ns}.{}", p.replace('/', ".")));
            }
            match self.texts.get(rest) {
                Some((key, _)) => {
                    self.text_refs = true;
                    Some(key.clone())
                }
                None => {
                    self.errors.push(format!("{path}: `{text}`: no text `{rest}` in resources/*.yres"));
                    None
                }
            }
        }

        fn text_of(&mut self, text: &str) -> Option<String> {
            self.texts.get(text.strip_prefix('@')?).map(|(_, t)| t.clone())
        }
    }

    if !matches!(j.v, V::Obj(_)) {
        cx.err(j.line, "a .ybook file is one JSON object");
        return None;
    }
    let mut value = plain(j);
    let obj = value.as_object_mut()?;
    let id = match obj.get("id").and_then(|v| v.as_str()) {
        Some(id) if id.contains(':') => id.to_string(),
        Some(id) => format!("{}:{id}", mod_ns.unwrap_or("minecraft")),
        None => {
            cx.err(j.line, "a book needs an `id` (the item that opens it)");
            return None;
        }
    };
    if !valid_id(&id) {
        cx.err(j.line, format!("book id `{id}`: not a valid id"));
        return None;
    }
    obj.insert("id".into(), id.clone().into());
    let ids = |key: &str| -> HashSet<String> {
        obj.get(key)
            .and_then(Value::as_array)
            .map(|a| a.iter().filter_map(|e| e.get("id")?.as_str().map(str::to_string)).collect())
            .unwrap_or_default()
    };
    let mut check = Check {
        known,
        texts: &cx.refs.texts,
        entries: ids("entries"),
        categories: ids("categories"),
        text_refs: false,
        errors: Vec::new(),
    };
    let mut errors = r::resolve(&mut value, &mut check);
    errors.append(&mut check.errors);
    let text_refs = check.text_refs;
    for e in &errors {
        let path = e.split(": ").next().unwrap_or_default();
        cx.err(line_of(j, path), e);
    }
    if !errors.is_empty() {
        return None;
    }
    if text_refs && let Some(obj) = value.as_object_mut() && !obj.contains_key("i18n") {
        obj.insert("i18n".into(), true.into());
    }
    if let Err(e) = serde_json::from_value::<yog_book::Book>(value.clone()) {
        cx.err(j.line, format!("not a book: {e}"));
        return None;
    }
    Some(BookFile { id, json: value.to_string() })
}

/// Keys a source file may carry for its authors and tools — `$…`, `_…`,
/// `comment`, `meta` — which nothing ships.
fn is_metadata(key: &str) -> bool {
    key.starts_with('$') || key.starts_with('_') || key == "comment" || key == "meta"
}

/// One checked `.yrecipe`.
#[derive(Debug, Clone)]
struct Recipe {
    id: String,
    file: String,
    kind: RecipeKind,
    result: String,
    count: u32,
    group: Option<String>,
    category: Option<String>,
    /// Item ids it names (not tags), by line — the mod's own are checked
    /// against its blocks and items.
    items: Vec<(usize, String)>,
}

impl Recipe {
    /// The `registry.add_recipe(...)` call registering it.
    fn registration(&self) -> String {
        let list = |items: &[String]| {
            let quoted: Vec<String> = items.iter().map(|i| format!("{i:?}.into()")).collect();
            format!("vec![{}]", quoted.join(", "))
        };
        let kind = match &self.kind {
            RecipeKind::Shaped { pattern, key } => {
                let rows: Vec<String> = pattern.iter().map(|r| format!("{r:?}.into()")).collect();
                let keys: Vec<String> = key.iter().map(|(c, items)| format!("({c:?}, {})", list(items))).collect();
                format!("Shaped {{ pattern: vec![{}], key: vec![{}] }}", rows.join(", "), keys.join(", "))
            }
            RecipeKind::Shapeless(ingredients) => {
                let all: Vec<String> = ingredients.iter().map(|i| list(i)).collect();
                format!("Shapeless {{ ingredients: vec![{}] }}", all.join(", "))
            }
            RecipeKind::Cooking { method, input, experience, cook_time } => format!(
                "Cooking {{ method: ::yog_api::Cooking::{method}, ingredient: {}, experience: {}_f32, cook_time: {cook_time} }}",
                list(input),
                float(*experience)
            ),
            RecipeKind::Stonecutting(input) => format!("Stonecutting {{ ingredient: {} }}", list(input)),
            RecipeKind::Custom { kind, slots, values } => {
                // Yog's recipe JSON as is: the host keeps it out of the game's data.
                let mut o = Map::new();
                o.insert("type".into(), kind.clone().into());
                o.insert("slots".into(), Value::Object(slots.iter().map(|(k, v)| (k.clone(), json!(v))).collect()));
                if !values.is_empty() {
                    o.insert("values".into(), Value::Object(values.clone()));
                }
                o.insert("result".into(), self.result.clone().into());
                if self.count != 1 {
                    o.insert("count".into(), self.count.into());
                }
                if let Some(g) = &self.group {
                    o.insert("group".into(), g.clone().into());
                }
                return format!("registry.add_recipe_json({:?}, {:?});", self.id, Value::Object(o).to_string());
            }
            RecipeKind::Smithing { template, base, addition } => format!(
                "Smithing {{ template: {}, base: {}, addition: {} }}",
                list(template),
                list(base),
                list(addition)
            ),
        };
        let opt = |o: &Option<String>| o.as_ref().map_or("None".to_string(), |v| format!("Some({v:?}.into())"));
        format!(
            "registry.add_recipe(::yog_api::Recipe {{ id: {:?}.into(), kind: ::yog_api::RecipeKind::{kind}, result: {:?}.into(), count: {}, group: {}, category: {} }});",
            self.id,
            self.result,
            self.count,
            opt(&self.group),
            opt(&self.category)
        )
    }
}

/// An item id (`minecraft:paper`), or — where `tags` — an item tag
/// (`#c:dusts`); the namespace is always written out.
fn recipe_item(cx: &mut Ctx, j: &J, what: &str, tags: bool, items: &mut Vec<(usize, String)>) -> Option<String> {
    let s = cx.string(j, what)?.trim().to_string();
    let (tag, id) = match s.strip_prefix('#') {
        Some(rest) => (true, rest),
        None => (false, s.as_str()),
    };
    if tag && !tags {
        cx.err(j.line, format!("{what} `{s}`: must be an item, not a tag"));
        return None;
    }
    let ok = id.split_once(':').is_some_and(|(ns, p)| valid_namespace(ns) && valid_path(p));
    if !ok {
        let hint = if id.contains(':') { String::new() } else { format!(" — write `minecraft:{id}`") };
        cx.err(
            j.line,
            format!("{what} `{s}`: expected an item id with its namespace (minecraft:paper){}{hint}", if tags { " or an item tag (#c:dusts)" } else { "" }),
        );
        return None;
    }
    if !tag {
        items.push((j.line, id.to_string()));
    }
    Some(s)
}

/// A recipe of the mod's own kind `kind`: `slots` (name → a list of
/// ingredients), `values`, `result`, `count`, `group`.
fn compile_custom_recipe(cx: &mut Ctx, j: &J, kind: String, id: String) -> Option<Recipe> {
    for key in ["pattern", "key", "ingredients", "ingredient", "experience", "cook_time", "template", "base", "addition", "category"] {
        if let Some(v) = j.get(key) {
            cx.err(v.line, format!("{key} is for the game's recipe types; {kind} takes \"slots\" and \"values\""));
        }
    }
    let mut items = Vec::new();
    let mut slots = Vec::new();
    match j.get("slots") {
        Some(sv) if sv.is_obj() => {
            for (name, list) in sv.members() {
                if !list.is_arr() || list.items().is_empty() {
                    cx.err(list.line, format!("slots.{name}: a list of ingredients — [\"minecraft:diamond\"], [[\"minecraft:coal\", \"minecraft:charcoal\"]]"));
                    continue;
                }
                let ings: Vec<Vec<String>> = list
                    .items()
                    .iter()
                    .filter_map(|i| recipe_ingredient(cx, i, &format!("slots.{name}[]"), &mut items))
                    .collect();
                slots.push((name.clone(), ings));
            }
        }
        Some(sv) => cx.err(sv.line, "slots must be an object: { \"core\": [\"minecraft:diamond\"] }"),
        None => cx.err(j.line, format!("a {kind} recipe needs \"slots\": what goes in, by slot name")),
    }
    let values = match j.get("values") {
        Some(v) if v.is_obj() => v.members().iter().map(|(k, x)| (k.clone(), json_value(x))).collect(),
        Some(v) => {
            cx.err(v.line, "values must be an object: { \"time\": 200 }");
            Map::new()
        }
        None => Map::new(),
    };
    let result = match j.get("result") {
        Some(v) => recipe_item(cx, v, "result", false, &mut items),
        None => {
            cx.err(j.line, "a recipe needs a \"result\": the item it makes");
            None
        }
    };
    let count = match j.get("count") {
        Some(v) => cx.number(v, "count", 1.0, 64.0).map(|n| n as u32),
        None => Some(1),
    };
    let group = j.get("group").and_then(|v| cx.string(v, "group").map(str::to_owned));
    Some(Recipe {
        id,
        file: cx.file.clone(),
        kind: RecipeKind::Custom { kind, slots, values },
        result: result?,
        count: count?,
        group,
        category: None,
        items,
    })
}

/// `j` as plain JSON.
fn json_value(j: &J) -> Value {
    match &j.v {
        V::Null => Value::Null,
        V::Bool(b) => Value::Bool(*b),
        V::Num(n) => num_value(*n),
        V::Str(s) => Value::String(s.clone()),
        V::Arr(items) => Value::Array(items.iter().map(json_value).collect()),
        V::Obj(members) => Value::Object(members.iter().map(|(k, v)| (k.clone(), json_value(v))).collect()),
    }
}

/// Checks one `.yrecipe`.
fn compile_recipe(cx: &mut Ctx, j: &J, path: &Path, mod_ns: Option<&str>) -> Option<Recipe> {
    if !j.is_obj() {
        cx.err(j.line, "a .yrecipe file is one JSON object");
        return None;
    }
    cx.unknown_keys(
        j,
        "a .yrecipe",
        &[
            "$schema", "format", "id", "type", "pattern", "key", "ingredients", "ingredient",
            "result", "count", "experience", "cook_time", "template", "base", "addition", "group",
            "category", "slots", "values",
        ],
    );
    if let Some(f) = j.get("format")
        && f.num() != Some(1.0)
    {
        cx.err(f.line, "format must be 1 (this yog understands format 1)");
    }
    let (ns, p) = entry_id(cx, j, path, mod_ns)?;
    let Some(t) = j.get("type") else {
        cx.err(j.line, format!("a recipe needs a \"type\": {}", RECIPE_TYPES.join(", ")));
        return None;
    };
    // The mod's own kind of recipe: `<mod id>:<kind>`.
    if let Some(own) = t.str().filter(|ty| mod_ns.is_some_and(|m| ty.split_once(':').is_some_and(|(n, k)| n == m && valid_path(k)))) {
        return compile_custom_recipe(cx, j, own.to_string(), format!("{ns}:{p}"));
    }
    let ty = cx.one_of(t, "type", &RECIPE_TYPES)?;
    let cooking = matches!(ty.as_str(), "smelting" | "blasting" | "smoking" | "campfire_cooking");
    // Keys of the other types.
    for (key, owners) in [
        ("pattern", &["shaped"][..]),
        ("key", &["shaped"]),
        ("ingredients", &["shapeless"]),
        ("ingredient", &["smelting", "blasting", "smoking", "campfire_cooking", "stonecutting"]),
        ("experience", &["smelting", "blasting", "smoking", "campfire_cooking"]),
        ("cook_time", &["smelting", "blasting", "smoking", "campfire_cooking"]),
        ("template", &["smithing"]),
        ("base", &["smithing"]),
        ("addition", &["smithing"]),
    ] {
        if !owners.contains(&ty.as_str())
            && let Some(v) = j.get(key)
        {
            cx.err(v.line, format!("{key} is for {} recipes, this one is {ty}", owners.join("/")));
        }
    }
    let mut items = Vec::new();
    let result = match j.get("result") {
        Some(v) => recipe_item(cx, v, "result", false, &mut items),
        None => {
            cx.err(j.line, "a recipe needs a \"result\": the item it makes");
            None
        }
    };
    let count = match j.get("count") {
        Some(v) => cx.number(v, "count", 1.0, 64.0).map(|n| n as u32),
        None => Some(1),
    };
    let text = |cx: &mut Ctx, key: &str| j.get(key).and_then(|v| cx.string(v, key).map(str::to_owned));
    let group = text(cx, "group");
    let category = text(cx, "category");
    let kind = match ty.as_str() {
        "shaped" => {
            let Some(pv) = j.get("pattern") else {
                cx.err(j.line, "a shaped recipe needs a \"pattern\": 1–3 rows of 1–3 key characters, e.g. [\"ISI\", \" S \"]");
                return None;
            };
            let rows: Vec<String> = pv.items().iter().filter_map(|r| cx.string(r, "pattern[]").map(str::to_owned)).collect();
            let width = rows.first().map_or(0, |r| r.chars().count());
            if !pv.is_arr() || rows.is_empty() || rows.len() > 3 || width == 0 || width > 3 || rows.iter().any(|r| r.chars().count() != width) {
                cx.err(pv.line, "pattern must be 1–3 rows of the same 1–3 characters each");
                return None;
            }
            let mut key = Vec::new();
            match j.get("key") {
                Some(kv) if kv.is_obj() => {
                    for (k, v) in kv.members() {
                        let mut chars = k.chars();
                        match (chars.next(), chars.next()) {
                            (Some(c), None) if c != ' ' => {
                                if let Some(alts) = recipe_ingredient(cx, v, &format!("key {k:?}"), &mut items) {
                                    if !rows.iter().any(|r| r.contains(c)) {
                                        cx.warn(v.line, format!("key {k:?} isn't used by the pattern"));
                                    }
                                    key.push((c, alts));
                                }
                            }
                            _ => cx.err(v.line, format!("key {k:?}: one character other than space")),
                        }
                    }
                }
                Some(kv) => cx.err(kv.line, "key must be an object: { \"I\": \"minecraft:iron_ingot\", ... }"),
                None => cx.err(j.line, "a shaped recipe needs a \"key\": what each pattern character stands for"),
            }
            for c in rows.iter().flat_map(|r| r.chars()).filter(|c| *c != ' ') {
                if !key.iter().any(|(k, _)| *k == c) && j.get("key").is_some_and(|kv| kv.get(&c.to_string()).is_none()) {
                    cx.err(pv.line, format!("pattern uses {c:?}, which key doesn't define"));
                    return None;
                }
            }
            RecipeKind::Shaped { pattern: rows, key }
        }
        "shapeless" => {
            let Some(iv) = j.get("ingredients") else {
                cx.err(j.line, "a shapeless recipe needs \"ingredients\": 1–9 items or tags");
                return None;
            };
            let list: Vec<Vec<String>> = iv
                .items()
                .iter()
                .filter_map(|i| recipe_ingredient(cx, i, "ingredients[]", &mut items))
                .collect();
            if !iv.is_arr() || iv.items().is_empty() || iv.items().len() > 9 {
                cx.err(iv.line, "ingredients must be an array of 1–9 items or tags");
                return None;
            }
            RecipeKind::Shapeless(list)
        }
        "smithing" => {
            let mut part = |cx: &mut Ctx, key: &str| match j.get(key) {
                Some(v) => recipe_ingredient(cx, v, key, &mut items),
                None => {
                    cx.err(j.line, format!("a smithing recipe needs a \"{key}\""));
                    None
                }
            };
            let template = part(cx, "template");
            let base = part(cx, "base");
            let addition = part(cx, "addition");
            RecipeKind::Smithing { template: template?, base: base?, addition: addition? }
        }
        _ => {
            let Some(iv) = j.get("ingredient") else {
                cx.err(j.line, format!("a {ty} recipe needs an \"ingredient\": the item or tag it takes"));
                return None;
            };
            let input = recipe_ingredient(cx, iv, "ingredient", &mut items)?;
            if !cooking {
                RecipeKind::Stonecutting(input)
            } else {
                let (method, default_time) = match ty.as_str() {
                    "smelting" => ("Smelting", 200.0),
                    "blasting" => ("Blasting", 100.0),
                    "smoking" => ("Smoking", 100.0),
                    _ => ("Campfire", 600.0),
                };
                let experience = match j.get("experience") {
                    Some(v) => cx.number(v, "experience", 0.0, 1000.0)?,
                    None => 0.1,
                };
                let cook_time = match j.get("cook_time") {
                    Some(v) => cx.number(v, "cook_time", 1.0, 32767.0)?,
                    None => default_time,
                } as u32;
                RecipeKind::Cooking { method, input, experience, cook_time }
            }
        }
    };
    Some(Recipe {
        id: format!("{ns}:{p}"),
        file: cx.file.clone(),
        kind,
        result: result?,
        count: count?,
        group,
        category,
        items,
    })
}

/// An ingredient: an item, a tag, or an array of either (any of them).
fn recipe_ingredient(cx: &mut Ctx, j: &J, what: &str, items: &mut Vec<(usize, String)>) -> Option<Vec<String>> {
    if j.is_arr() {
        let alts: Vec<String> = j.items().iter().filter_map(|i| recipe_item(cx, i, what, true, items)).collect();
        if alts.is_empty() {
            cx.err(j.line, format!("{what}: an array of items or tags, at least one"));
            return None;
        }
        return Some(alts);
    }
    recipe_item(cx, j, what, true, items).map(|i| vec![i])
}

/// Ids of the `.yui` screens under `dir` that lay out an inventory (have
/// `<Slot>`s or a `<PlayerInventory>`).
fn inventory_screens(dir: &Path) -> BTreeSet<String> {
    let mut out = BTreeSet::new();
    let Ok(entries) = std::fs::read_dir(dir) else {
        return out;
    };
    for e in entries.flatten() {
        let path = e.path();
        if path.is_dir() {
            out.extend(inventory_screens(&path));
            continue;
        }
        if path.extension().is_none_or(|x| x != "yui") {
            continue;
        }
        let Ok(text) = std::fs::read_to_string(&path) else { continue };
        if !text.contains("<Slot") && !text.contains("<PlayerInventory") {
            continue;
        }
        if let Some(screen) = text.find("<Screen")
            && let Some(at) = text[screen..].find(" id=\"")
        {
            let rest = &text[screen + at + 5..];
            if let Some(end) = rest.find('"') {
                out.insert(rest[..end].to_string());
            }
        }
    }
    out
}

/// Compiles the mod's content files (see the module docs). Any error fails
/// the whole thing, listing every problem.
pub fn compile(root: &Path, mod_id: &str, refs: &yres::Refs) -> Result<Compiled, String> {
    let mut out = Compiled::default();
    let files = find(root);
    if files.is_empty() {
        return Ok(out);
    }
    let mod_ns = valid_namespace(mod_id).then_some(mod_id);
    let mut errors: Vec<String> = Vec::new();
    let mut warnings: Vec<String> = Vec::new();
    let mut textures: BTreeMap<String, PathBuf> = BTreeMap::new();
    let mut generated: BTreeMap<String, String> = BTreeMap::new();
    let mut entries: Vec<Entry> = Vec::new();
    let mut ids: HashMap<String, String> = HashMap::new();
    let mut recipes: Vec<Recipe> = Vec::new();
    let mut recipe_ids: HashMap<String, String> = HashMap::new();
    let mut books: Vec<BookFile> = Vec::new();
    let mut book_ids: HashMap<String, String> = HashMap::new();
    let mut inventories: Vec<(String, usize, String)> = Vec::new();
    let mut pending_books: Vec<(String, J)> = Vec::new();
    for path in &files {
        let shown = display(root, path);
        let Some(kind) = Kind::of(path) else { continue };
        let text = match std::fs::read_to_string(path) {
            Ok(t) => t,
            Err(e) => {
                errors.push(format!("{shown}: {e}"));
                continue;
            }
        };
        let j = match json::parse(&text) {
            Ok(j) => j,
            Err(e) => {
                errors.push(format!("{shown}:{}", e.trim_start_matches("line ")));
                continue;
            }
        };
        let mut cx = Ctx {
            root,
            refs,
            file: shown.clone(),
            ns: mod_ns.unwrap_or("minecraft").to_string(),
            errors: &mut errors,
            warnings: &mut warnings,
            textures: &mut textures,
            inventories: &mut inventories,
        };
        if kind == Kind::Book {
            // Checked once every block, item and recipe is known.
            pending_books.push((shown.clone(), j));
            continue;
        }
        if kind == Kind::Recipe {
            if let Some(r) = compile_recipe(&mut cx, &j, path, mod_ns) {
                if let Some(other) = recipe_ids.insert(r.id.clone(), shown.clone()) {
                    errors.push(format!("{shown}: recipe {} is also defined by {other}", r.id));
                }
                recipes.push(r);
            }
            continue;
        }
        if let Some(entry) = compile_file(&mut cx, &j, kind, path, mod_ns, &mut out, &mut generated)
        {
            if let Some(other) = ids.insert(entry.id.clone(), shown.clone()) {
                errors.push(format!(
                    "{shown}: id {} is also defined by {other}",
                    entry.id
                ));
            }
            entries.push(entry);
        }
    }
    // Books name the mod's content, vanilla's and other mods' declared ids.
    let externals = crate::manifest::YogToml::read(&root.join("yog.toml")).map(|t| t.externals).unwrap_or_default();
    let mut known = refs::Known::new(mod_ns.unwrap_or("minecraft"), &externals);
    for e in &entries {
        known.add(if e.kind == Kind::Block { yog_book::refs::RefKind::Block } else { yog_book::refs::RefKind::Item }, e.id.clone());
    }
    for r in &recipes {
        known.add(yog_book::refs::RefKind::Recipe, r.id.clone());
    }
    for (shown, j) in &pending_books {
        let mut cx = Ctx {
            root,
            refs,
            file: shown.clone(),
            ns: mod_ns.unwrap_or("minecraft").to_string(),
            errors: &mut errors,
            warnings: &mut warnings,
            textures: &mut textures,
            inventories: &mut inventories,
        };
        if let Some(b) = compile_book(&mut cx, j, mod_ns, &known) {
            if let Some(other) = book_ids.insert(b.id.clone(), shown.clone()) {
                errors.push(format!("{shown}: book {} is also defined by {other}", b.id));
            }
            books.push(b);
        }
    }
    // What recipes name from this mod must be its blocks and items (vanilla
    // and other mods' ids can't be checked here).
    if let Some(ns) = mod_ns {
        for r in &recipes {
            for (line, item) in &r.items {
                if item.split_once(':').is_some_and(|(n, _)| n == ns) && !ids.contains_key(item) {
                    errors.push(format!(
                        "{}:{line}: no block or item {item} in {CONTENT_DIR}/",
                        r.file
                    ));
                }
            }
        }
        let screens = inventory_screens(&root.join("src"));
        for (file, line, id) in &inventories {
            if id.split_once(':').is_some_and(|(n, _)| n == ns) && !screens.contains(id) {
                errors.push(format!(
                    "{file}:{line}: block.inventory `{id}`: no .yui <Screen id=\"{id}\"> with <Slot>s in src/"
                ));
            }
        }
    }
    for (target, source) in &textures {
        match std::fs::read(source) {
            Ok(bytes) => out.outputs.push((target.clone(), bytes)),
            Err(e) => errors.push(format!("{}: {e}", display(root, source))),
        }
    }
    out.warnings = warnings;
    if !errors.is_empty() {
        return Err(format!(
            "invalid blocks/items in content/:\n  {}",
            errors.join("\n  ")
        ));
    }
    out.blocks = entries.iter().filter(|e| e.kind == Kind::Block).count();
    out.items = entries.len() - out.blocks;
    out.recipes = recipes.len();
    out.books = books.len();
    if (entries.iter().any(|e| e.auto) || !recipes.is_empty() || !books.is_empty())
        && !mentions_content_macro(&root.join("src"))
    {
        out.warnings.push(format!(
            "{} has blocks/items, but src/ never calls `yog_api::content!();` — they get models but aren't registered",
            CONTENT_DIR
        ));
    }
    out.source = Some(rust_source(&entries, &recipes, &books));
    Ok(out)
}

/// Whether any `src/**/*.rs` has `content!(` — the include of the generated code.
fn mentions_content_macro(dir: &Path) -> bool {
    let Ok(entries) = std::fs::read_dir(dir) else {
        return false;
    };
    entries.flatten().any(|e| {
        let p = e.path();
        if p.is_dir() {
            mentions_content_macro(&p)
        } else {
            p.extension().is_some_and(|x| x == "rs")
                && std::fs::read_to_string(&p).is_ok_and(|t| t.contains("content!("))
        }
    })
}

/// `ruby_ore`, `ores/ruby` → `ores_ruby`; a Rust keyword gets `r#`.
fn rust_ident(path: &str) -> String {
    let mut s: String = path
        .chars()
        .map(|c| {
            if c.is_ascii_alphanumeric() {
                c.to_ascii_lowercase()
            } else {
                '_'
            }
        })
        .collect();
    if s.starts_with(|c: char| c.is_ascii_digit()) {
        s.insert(0, '_');
    }
    s
}

fn float(n: f64) -> String {
    let s = format!("{n:?}");
    if s.contains('.') || s.contains('e') {
        s
    } else {
        format!("{s}.0")
    }
}

fn rust_source(entries: &[Entry], recipes: &[Recipe], books: &[BookFile]) -> String {
    let mut code = String::from(
        "// <auto-generated>\n//     Generated by `yog build` from content/**/*.yblock and *.yitem — don't edit,\n//     it's rewritten on every build. Included by `yog_api::content!()`.\n// </auto-generated>\n",
    );
    for (kind, set, def) in [
        (Kind::Block, "Blocks", "BlockDef"),
        (Kind::Item, "Items", "ItemDef"),
    ] {
        let mine: Vec<&Entry> = entries.iter().filter(|e| e.kind == kind).collect();
        let _ = writeln!(
            code,
            "\n/// The {} of `content/`: the id and a [`::yog_api::{def}`] of each.\n#[allow(dead_code)]\npub struct {set};\n\n#[allow(dead_code, clippy::all)]\nimpl {set} {{",
            if kind == Kind::Block {
                "blocks"
            } else {
                "items"
            }
        );
        let mut used: HashMap<String, usize> = HashMap::new();
        for e in mine {
            let path = e.id.split_once(':').map_or(e.id.as_str(), |(_, p)| p);
            let mut ident = rust_ident(path);
            let n = used.entry(ident.clone()).or_insert(0);
            *n += 1;
            if *n > 1 {
                let _ = write!(ident, "_{n}");
            }
            let upper = ident.to_ascii_uppercase();
            let ident = if is_keyword(&ident) {
                format!("r#{ident}")
            } else {
                ident
            };
            let _ = writeln!(
                code,
                "    /// `{}` — `{}`.\n    pub const {upper}: &'static str = {:?};",
                e.id, e.file, e.id
            );
            let mut b = format!("::yog_api::{def}::new(Self::{upper})");
            match kind {
                Kind::Recipe | Kind::Book => unreachable!("only blocks and items get here"),
                Kind::Block => {
                    let p = &e.block;
                    if p.hardness.is_some() || p.resistance.is_some() {
                        let _ = write!(
                            b,
                            "\n            .strength({}, {})",
                            float(p.hardness.unwrap_or(1.5)),
                            float(p.resistance.unwrap_or(6.0))
                        );
                    }
                    if let Some(s) = &p.sound {
                        let _ = write!(b, "\n            .sound({s:?})");
                    }
                    if p.light > 0 {
                        let _ = write!(b, "\n            .light_level({})", p.light);
                    }
                    if p.requires_tool {
                        b.push_str("\n            .requires_tool()");
                    }
                    if p.no_collision {
                        b.push_str("\n            .no_collision()");
                    }
                    if let Some(s) = p.slipperiness {
                        let _ = write!(b, "\n            .slipperiness({})", float(s));
                    }
                    if let Some(s) = p.shape {
                        let args: Vec<String> = s.iter().map(|n| float(*n)).collect();
                        let _ = write!(b, "\n            .shape({})", args.join(", "));
                    }
                    if p.connects {
                        b.push_str("\n            .connects_to_neighbors()");
                    }
                    if !p.connect_groups.is_empty() {
                        let groups: Vec<String> =
                            p.connect_groups.iter().map(|g| format!("{g:?}")).collect();
                        let _ =
                            write!(b, "\n            .connect_groups(&[{}])", groups.join(", "));
                    }
                    if let Some(inv) = &p.inventory {
                        let _ = write!(b, "\n            .inventory({inv:?})");
                    }
                    if p.redstone {
                        b.push_str("\n            .redstone_source()");
                    }
                }
                Kind::Item => {
                    let p = &e.item;
                    if let Some(s) = p.stack_size {
                        let _ = write!(b, "\n            .max_stack({s})");
                    }
                    if p.durability > 0 {
                        let _ = write!(b, "\n            .max_damage({})", p.durability);
                    }
                    if p.fire_resistant {
                        b.push_str("\n            .fire_resistant()");
                    }
                    if p.fuel_ticks > 0 {
                        let _ = write!(b, "\n            .fuel({})", p.fuel_ticks);
                    }
                    if let Some((n, s, always)) = p.food {
                        let _ = write!(
                            b,
                            "\n            .food(::yog_api::FoodDef::new({n}, {}){})",
                            float(s),
                            if always { ".can_always_eat()" } else { "" }
                        );
                    }
                }
            }
            let _ = writeln!(
                code,
                "    /// The definition from `{}` (name and tooltip come from the lang files).\n    pub fn {ident}() -> ::yog_api::{def} {{\n        {b}\n    }}",
                e.file
            );
        }
        code.push_str("}\n");
    }

    code.push_str("\n/// Registers every block and item of `content/` whose file doesn't say\n/// `\"register\": \"manual\"` — `yog_api::content!()` calls it after\n/// `Mod::register`.\n#[allow(unused_variables)]\npub fn register(registry: &mut ::yog_api::Registry) {\n");
    let mut used: HashMap<(Kind, String), usize> = HashMap::new();
    for e in entries {
        let path = e.id.split_once(':').map_or(e.id.as_str(), |(_, p)| p);
        let mut ident = rust_ident(path);
        let n = used.entry((e.kind, ident.clone())).or_insert(0);
        *n += 1;
        if *n > 1 {
            let _ = write!(ident, "_{n}");
        }
        let ident = if is_keyword(&ident) {
            format!("r#{ident}")
        } else {
            ident
        };
        if !e.auto {
            continue;
        }
        let _ = match e.kind {
            Kind::Block => writeln!(code, "    registry.register_block(Blocks::{ident}());"),
            Kind::Item => writeln!(code, "    registry.register_item(Items::{ident}());"),
            Kind::Recipe | Kind::Book => unreachable!("only blocks and items get here"),
        };
    }
    for r in recipes {
        let _ = writeln!(code, "    {}", r.registration());
    }
    for b in books {
        let _ = writeln!(code, "    registry.register_book_json({:?}, {:?});", b.id, b.json);
    }
    code.push_str("}\n");
    if entries.iter().any(|e| e.auto) || !recipes.is_empty() || !books.is_empty() {
        code.push_str(
            "\n// Runs when the mod's library loads: `export_mod!` calls `register` after\n// `Mod::register`.\n#[::yog_api::ctor::ctor(unsafe, crate_path = ::yog_api::ctor)]\nfn __yog_content_auto_register() {\n    ::yog_api::__yog_content_registrars()\n        .lock()\n        .unwrap_or_else(|e| e.into_inner())\n        .push(register);\n}\n",
        );
    }
    code
}

fn is_keyword(s: &str) -> bool {
    const KW: &[&str] = &[
        "as", "break", "const", "continue", "crate", "else", "enum", "extern", "false", "fn",
        "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref",
        "return", "self", "static", "struct", "super", "trait", "true", "type", "unsafe", "use",
        "where", "while", "async", "await", "dyn", "abstract", "become", "box", "do", "final",
        "macro", "override", "priv", "typeof", "unsized", "virtual", "yield", "try", "gen",
    ];
    KW.contains(&s)
}

/// Writes `compiled.source` to [`GENERATED_FILE`] (only when it changed);
/// deletes it when the mod has no content files.
pub fn write_source(root: &Path, compiled: &Compiled) -> Result<(), String> {
    let out = root.join(GENERATED_FILE);
    let Some(code) = &compiled.source else {
        let _ = std::fs::remove_file(&out);
        return Ok(());
    };
    crate::write_if_changed(&out, code)?;
    Ok(())
}

/// Outputs in order, keyed by path: [`OutputSet::put`] replaces a path's
/// output (moving it to the end) without rescanning the list.
#[derive(Default)]
pub struct OutputSet {
    items: Vec<Option<Output>>,
    at: HashMap<String, usize>,
}

impl OutputSet {
    pub fn get(&self, path: &str) -> Option<&[u8]> {
        let i = *self.at.get(path)?;
        self.items[i].as_ref().map(|(_, b)| b.as_slice())
    }

    pub fn contains(&self, path: &str) -> bool {
        self.at.contains_key(path)
    }

    pub fn paths(&self) -> impl Iterator<Item = &String> {
        self.at.keys()
    }

    /// Sets `path`'s output, dropping the one it had.
    pub fn put(&mut self, path: String, bytes: Vec<u8>) {
        if let Some(i) = self.at.insert(path.clone(), self.items.len()) {
            self.items[i] = None;
        }
        self.items.push(Some((path, bytes)));
    }

    pub fn into_vec(self) -> Vec<Output> {
        self.items.into_iter().flatten().collect()
    }
}

impl From<Vec<Output>> for OutputSet {
    fn from(outputs: Vec<Output>) -> Self {
        let mut set = OutputSet::default();
        for (path, bytes) in outputs {
            set.put(path, bytes);
        }
        set
    }
}

/// A JSON object output at `path`: the one already in `outputs`, else the
/// mod's own file there, else empty.
fn json_output(outputs: &OutputSet, root: &Path, path: &str) -> Result<Map<String, Value>, String> {
    let read;
    let bytes = match outputs.get(path) {
        Some(b) => b,
        None => match std::fs::read(root.join(path)) {
            Ok(b) => {
                read = b;
                &read
            }
            Err(_) => return Ok(Map::new()),
        },
    };
    serde_json::from_slice::<Map<String, Value>>(bytes).map_err(|e| format!("{path}: {e}"))
}

/// Adds the content's outputs to `outputs` (the `.yres` ones, say): lang
/// entries and tags merged into what's there (or into the mod's own files),
/// the rest appended.
pub fn merge_outputs(
    root: &Path,
    outputs: &mut Vec<Output>,
    compiled: Compiled,
) -> Result<(), String> {
    let mut set = OutputSet::from(std::mem::take(outputs));
    let mut errors = Vec::new();
    // `.yres` texts under the keys the game looks up: in every lang file
    // that has the text.
    if !compiled.lang_aliases.is_empty() {
        let mut lang_files: BTreeSet<String> =
            set.paths().filter(|p| is_lang_path(p)).cloned().collect();
        if let Ok(dirs) = std::fs::read_dir(root.join("assets")) {
            for ns in dirs.flatten() {
                if let Ok(files) = std::fs::read_dir(ns.path().join("lang")) {
                    for f in files.flatten() {
                        if let Ok(rel) = f.path().strip_prefix(root) {
                            let rel = rel.to_string_lossy().replace('\\', "/");
                            if is_lang_path(&rel) {
                                lang_files.insert(rel);
                            }
                        }
                    }
                }
            }
        }
        for path in lang_files {
            let mut map = match json_output(&set, root, &path) {
                Ok(m) => m,
                Err(e) => {
                    errors.push(e);
                    continue;
                }
            };
            let mut changed = false;
            for (from, to) in &compiled.lang_aliases {
                if let Some(text) = map.get(from).cloned()
                    && !map.contains_key(to)
                {
                    map.insert(to.clone(), text);
                    changed = true;
                }
            }
            if changed {
                set.put(path, pretty(&Value::Object(map)));
            }
        }
    }
    for ((ns, locale), entries) in &compiled.lang {
        let path = format!("assets/{ns}/lang/{locale}.json");
        let mut map = match json_output(&set, root, &path) {
            Ok(m) => m,
            Err(e) => {
                errors.push(e);
                continue;
            }
        };
        for (k, v) in entries {
            map.entry(k.clone())
                .or_insert_with(|| Value::String(v.clone()));
        }
        set.put(path, pretty(&Value::Object(map)));
    }
    for (path, ids) in &compiled.tags {
        // The mod's own tag file may use the pre-1.21 spelling; the loader
        // maps both to one file, so merge into whichever it has.
        let plural = path.replacen("/tags/block/", "/tags/blocks/", 1);
        let path = if !set.contains(path) && root.join(&plural).is_file() {
            plural
        } else {
            path.clone()
        };
        let mut map = match json_output(&set, root, &path) {
            Ok(m) => m,
            Err(e) => {
                errors.push(e);
                continue;
            }
        };
        let values = map
            .entry("values")
            .or_insert_with(|| Value::Array(Vec::new()));
        if let Value::Array(list) = values {
            for id in ids {
                if !list.iter().any(|v| v.as_str() == Some(id)) {
                    list.push(Value::String(id.clone()));
                }
            }
        }
        map.entry("replace").or_insert(Value::Bool(false));
        set.put(path, pretty(&Value::Object(map)));
    }
    for (path, bytes) in compiled.outputs {
        set.put(path, bytes);
    }
    *outputs = set.into_vec();
    if errors.is_empty() {
        Ok(())
    } else {
        Err(format!(
            "merging blocks/items into the mod's files:\n  {}",
            errors.join("\n  ")
        ))
    }
}

fn is_lang_path(p: &str) -> bool {
    let parts: Vec<&str> = p.split('/').collect();
    parts.len() == 4 && parts[0] == "assets" && parts[2] == "lang" && parts[3].ends_with(".json")
}

#[cfg(test)]
mod tests {
    use super::*;

    fn project(files: &[(&str, &str)]) -> PathBuf {
        use std::sync::atomic::{AtomicUsize, Ordering};
        static N: AtomicUsize = AtomicUsize::new(0);
        let dir = std::env::temp_dir().join(format!(
            "yog-content-test-{}-{}",
            std::process::id(),
            N.fetch_add(1, Ordering::SeqCst)
        ));
        let _ = std::fs::remove_dir_all(&dir);
        for (path, text) in files {
            let p = dir.join(path);
            std::fs::create_dir_all(p.parent().unwrap()).unwrap();
            std::fs::write(p, text).unwrap();
        }
        dir
    }

    fn output(c: &Compiled, path: &str) -> Value {
        let (_, b) = c
            .outputs
            .iter()
            .find(|(p, _)| p == path)
            .unwrap_or_else(|| {
                panic!(
                    "no {path} in {:?}",
                    c.outputs.iter().map(|(p, _)| p).collect::<Vec<_>>()
                )
            });
        serde_json::from_slice(b).unwrap()
    }

    #[test]
    fn compiles_a_cube_block() {
        let root = project(&[
            ("resources/block/ruby_ore.png", "png"),
            (
                "content/blocks/ruby_ore.yblock",
                r#"{
  "name": "Ruby Ore",
  "block": { "hardness": 3, "resistance": 3, "sound": "stone", "tool": "pickaxe", "tool_level": "iron", "requires_tool": true,
             "drops": { "item": "mymod:ruby", "count": [1, 3] } },
  "model": { "parent": "cube_all", "textures": { "all": "block/ruby_ore.png" } }
}"#,
            ),
        ]);
        let c = compile(&root, "mymod", &yres::Refs::default()).unwrap();
        assert_eq!(c.blocks, 1);
        assert_eq!(
            output(&c, "assets/mymod/models/block/ruby_ore.json"),
            json!({ "parent": "minecraft:block/cube_all", "textures": { "all": "mymod:block/ruby_ore" } })
        );
        assert_eq!(
            output(&c, "assets/mymod/blockstates/ruby_ore.json"),
            json!({ "variants": { "": { "model": "mymod:block/ruby_ore" } } })
        );
        assert_eq!(
            output(&c, "assets/mymod/models/item/ruby_ore.json"),
            json!({ "parent": "mymod:block/ruby_ore" })
        );
        assert_eq!(
            output(&c, "assets/mymod/items/ruby_ore.json")["model"]["model"],
            json!("mymod:item/ruby_ore")
        );
        let loot = output(&c, "data/mymod/loot_table/blocks/ruby_ore.json");
        assert_eq!(loot["pools"][0]["entries"][0]["name"], json!("mymod:ruby"));
        assert_eq!(
            loot["pools"][0]["entries"][0]["functions"][0]["count"]["max"],
            json!(3)
        );
        assert!(
            c.outputs
                .iter()
                .any(|(p, _)| p == "assets/mymod/textures/block/ruby_ore.png")
        );
        let src = c.source.as_ref().unwrap();
        assert!(
            src.contains("pub const RUBY_ORE: &'static str = \"mymod:ruby_ore\";"),
            "{src}"
        );
        assert!(src.contains(".strength(3.0, 3.0)"), "{src}");
        assert!(src.contains(".requires_tool()"), "{src}");
        assert!(
            src.contains("registry.register_block(Blocks::ruby_ore());"),
            "{src}"
        );

        let mut outputs = Vec::new();
        merge_outputs(&root, &mut outputs, c).unwrap();
        let find = |p: &str| -> Value {
            serde_json::from_slice(&outputs.iter().find(|(q, _)| q == p).unwrap().1).unwrap()
        };
        assert_eq!(
            find("assets/mymod/lang/en_us.json")["block.mymod.ruby_ore"],
            json!("Ruby Ore")
        );
        assert_eq!(
            find("data/minecraft/tags/block/mineable/pickaxe.json")["values"],
            json!(["mymod:ruby_ore"])
        );
        assert_eq!(
            find("data/minecraft/tags/block/needs_iron_tool.json")["values"],
            json!(["mymod:ruby_ore"])
        );
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn raw_parent_with_elements_gets_a_particle() {
        let root = project(&[(
            "content/cable.yblock",
            r##"{ "model": { "parent": "minecraft:block/block", "textures": { "all": "minecraft:block/stone" },
                 "elements": [ { "from": [5, 5, 5], "to": [11, 11, 11], "faces": { "up": { "texture": "#all" } } } ] } }"##,
        )]);
        let c = compile(&root, "mymod", &yres::Refs::default()).unwrap();
        let m = output(&c, "assets/mymod/models/block/cable.json");
        assert_eq!(m["textures"]["particle"], json!("minecraft:block/stone"));
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn compiles_elements_shape_and_connect() {
        let root = project(&[(
            "content/pipe.yblock",
            r##"{
  "block": { "render_layer": "cutout" },
  "model": {
    "textures": { "0": "minecraft:block/stone" },
    "elements": [ { "from": [6, 6, 6], "to": [10, 10, 10],
                    "rotation": { "axis": "y", "angle": 22.5 },
                    "faces": { "north": { "texture": "#0", "uv": [0, 0, 4, 4], "cullface": "north" } } } ]
  },
  "states": { "connect": { "arm": { "textures": { "0": "minecraft:block/stone" },
     "elements": [ { "from": [6, 6, 0], "to": [10, 10, 6], "faces": { "up": { "texture": "#0" } } } ] } } }
}"##,
        )]);
        let c = compile(&root, "mymod", &yres::Refs::default()).unwrap();
        let m = output(&c, "assets/mymod/models/block/pipe.json");
        assert_eq!(m["textures"]["particle"], json!("minecraft:block/stone"));
        assert_eq!(m["render_type"], json!("minecraft:cutout"));
        assert_eq!(m["elements"][0]["rotation"]["origin"], json!([8, 8, 8]));
        let bs = output(&c, "assets/mymod/blockstates/pipe.json");
        assert_eq!(bs["multipart"].as_array().unwrap().len(), 7);
        assert_eq!(bs["multipart"][5]["apply"]["x"], json!(270));
        let src = c.source.unwrap();
        assert!(
            src.contains(".shape(6.0, 6.0, 6.0, 10.0, 10.0, 10.0)"),
            "{src}"
        );
        assert!(src.contains(".connects_to_neighbors()"), "{src}");
        assert!(src.contains(".connect_groups(&[\"mymod:pipe\"])"), "{src}");
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn reports_errors_with_lines() {
        let root = project(&[(
            "content/bad.yblock",
            "{\n  \"model\": {\n    \"textures\": { \"0\": \"minecraft:block/stone\" },\n    \"elements\": [ {\n      \"from\": [0, 0, 0], \"to\": [16, 16, 16],\n      \"rotation\": { \"axis\": \"q\", \"angle\": 30 },\n      \"faces\": { \"north\": { \"texture\": \"#1\" } }\n    } ]\n  },\n  \"bogus\": 1\n}",
        )]);
        let e = compile(&root, "mymod", &yres::Refs::default()).unwrap_err();
        assert!(
            e.contains("content/bad.yblock:6: model.elements[0].rotation.axis"),
            "{e}"
        );
        assert!(
            e.contains("content/bad.yblock:6: model.elements[0].rotation.angle is 30"),
            "{e}"
        );
        assert!(
            e.contains("content/bad.yblock:7: model.elements[0].faces.north.texture `#1`"),
            "{e}"
        );
        assert!(
            e.contains("content/bad.yblock:10: unknown key \"bogus\""),
            "{e}"
        );
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn compiles_recipes() {
        let root = project(&[
            ("content/ruby.yitem", r#"{ "model": { "parent": "generated", "textures": { "layer0": "minecraft:item/emerald" } } }"#),
            (
                "content/recipes/ruby_block.yrecipe",
                r##"{ "type": "shaped", "pattern": ["RR", "RR"], "key": { "R": "mymod:ruby" }, "result": "minecraft:emerald_block" }"##,
            ),
            (
                "content/recipes/ruby.yrecipe",
                r##"{ "type": "shapeless", "ingredients": ["minecraft:emerald", "#c:dusts"], "result": "mymod:ruby", "count": 2 }"##,
            ),
            (
                "content/recipes/smelt_ruby.yrecipe",
                r##"{ "type": "smelting", "ingredient": "#c:ores", "result": "mymod:ruby", "experience": 0.7, "$comment": "metadata goes", "_editor": { "x": 1 } }"##,
            ),
            (
                "content/recipes/cut.yrecipe",
                r##"{ "type": "stonecutting", "ingredient": ["minecraft:stone", "minecraft:andesite"], "result": "mymod:ruby", "group": "rubies" }"##,
            ),
        ]);
        let c = compile(&root, "mymod", &yres::Refs::default()).unwrap();
        assert_eq!(c.recipes, 4);
        let src = c.source.clone().unwrap();
        for want in [
            r#"kind: ::yog_api::RecipeKind::Shaped { pattern: vec!["RR".into(), "RR".into()], key: vec![('R', vec!["mymod:ruby".into()])] }, result: "minecraft:emerald_block".into(), count: 1"#,
            r##"Shapeless { ingredients: vec![vec!["minecraft:emerald".into()], vec!["#c:dusts".into()]] }, result: "mymod:ruby".into(), count: 2"##,
            r##"Cooking { method: ::yog_api::Cooking::Smelting, ingredient: vec!["#c:ores".into()], experience: 0.7_f32, cook_time: 200 }"##,
            r##"Stonecutting { ingredient: vec!["minecraft:stone".into(), "minecraft:andesite".into()] }"##,
            r##"group: Some("rubies".into())"##,
        ] {
            assert!(src.contains(want), "missing {want}\n{src}");
        }
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn recipe_mistakes() {
        let bad = |recipe: &str| {
            let root = project(&[("content/r.yrecipe", recipe)]);
            let e = compile(&root, "mymod", &yres::Refs::default()).unwrap_err();
            let _ = std::fs::remove_dir_all(root);
            e
        };
        let e = bad(r#"{ "type": "shaped", "pattern": ["AB"], "key": { "A": "minecraft:stick" }, "result": "minecraft:stick" }"#);
        assert!(e.contains("pattern uses 'B'"), "{e}");
        let e = bad(r#"{ "type": "shapeless", "ingredients": ["stick"], "result": "minecraft:stick" }"#);
        assert!(e.contains("write `minecraft:stick`"), "{e}");
        let e = bad(r##"{ "type": "smelting", "ingredient": "minecraft:sand", "result": "#c:glass" }"##);
        assert!(e.contains("must be an item, not a tag"), "{e}");
        let e = bad(r#"{ "type": "shapeless", "ingredients": ["minecraft:sand"], "result": "mymod:nothing" }"#);
        assert!(e.contains("no block or item mymod:nothing"), "{e}");
        let e = bad(r#"{ "type": "shapeless", "pattern": ["A"], "ingredients": ["minecraft:sand"], "result": "minecraft:glass" }"#);
        assert!(e.contains("pattern is for shaped recipes"), "{e}");
    }

    #[test]
    fn block_inventory_names_a_screen() {
        let block = r#"{ "block": { "inventory": "mymod:bench" }, "model": { "parent": "cube_all", "textures": { "all": "minecraft:block/stone" } } }"#;
        let root = project(&[
            ("content/bench.yblock", block),
            ("src/bench.yui", r#"<Screen id="mymod:bench" width="176" height="166" x:ViewModel="Vm"><Slot index="0"/></Screen>"#),
        ]);
        let c = compile(&root, "mymod", &yres::Refs::default()).unwrap();
        assert!(c.source.unwrap().contains(r#".inventory("mymod:bench")"#));
        let _ = std::fs::remove_dir_all(root);

        let root = project(&[("content/bench.yblock", block)]);
        let e = compile(&root, "mymod", &yres::Refs::default()).unwrap_err();
        assert!(e.contains("no .yui <Screen id=\"mymod:bench\"> with <Slot>s"), "{e}");
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn compiles_a_book() {
        let book = r#"{
            "id": "guide",
            "name": "@Book.title",
            "categories": [{ "id": "basics", "name": "Basics", "icon": "@item:minecraft:book" }],
            "entries": [{
                "id": "ruby", "name": "@item:mymod:ruby", "category": "@category:basics",
                "pages": [
                    { "type": "text", "text": "@@not a ref, {link=@entry:ruby|see}" },
                    { "type": "spotlight", "item": "@item:mymod:ruby" },
                    { "type": "entity", "entity": "@entity:minecraft:allay" }
                ]
            }]
        }"#;
        let ruby = r#"{ "name": "Ruby", "model": { "parent": "generated", "textures": { "layer0": "minecraft:item/emerald" } } }"#;
        let root = project(&[("content/guide.ybook", book), ("content/ruby.yitem", ruby)]);
        let mut refs = yres::Refs::default();
        refs.texts.insert("Book.title".into(), ("mymod.book.title".into(), "Guide".into()));
        let out = compile(&root, "mymod", &refs).unwrap();
        assert_eq!(out.books, 1);
        let src = out.source.unwrap();
        assert!(src.contains("registry.register_book_json(\"mymod:guide\""), "{src}");
        assert!(src.contains("mymod.book.title") && src.contains("item.mymod.ruby"), "{src}");
        assert!(src.contains("not a ref") && src.contains("i18n"), "{src}");
        assert!(src.contains(r#"\"item\":\"mymod:ruby\""#) && src.contains(r#"\"category\":\"basics\""#), "references become ids: {src}");

        // Bare ids, missing content and version-only ids are errors, each on its line.
        let bad = r#"{ "id": "x",
            "categories": [{ "id": "c", "name": "C" }],
            "entries": [{ "id": "e", "name": "E", "category": "c",
                "pages": [
                    { "type": "spotlight", "item": "minecraft:stick" },
                    { "type": "spotlight", "item": "@item:minecraft:short_grass" },
                    { "type": "recipe", "recipe": "@recipe:mymod:nope" },
                    { "type": "entity", "entity": "@entity:create:train" }
                ] }] }"#;
        let e = compile(&project(&[("content/bad.ybook", bad)]), "mymod", &yres::Refs::default()).unwrap_err();
        assert!(e.contains("bad.ybook:3: entries[0].category: `c`: name it by a reference — `@category:c`"), "{e}");
        assert!(e.contains("bad.ybook:5:") && e.contains("`@item:minecraft:stick`"), "{e}");
        assert!(e.contains("not in 1.20.1"), "{e}");
        assert!(e.contains("no recipe mymod:nope in this mod"), "{e}");
        assert!(e.contains("[external.create]"), "{e}");

        let bad = project(&[("content/bad.ybook", r#"{ "id": "x", "entries": [{ "pages": [{ "type": "nope" }] }] }"#)]);
        let e = compile(&bad, "mymod", &yres::Refs::default()).unwrap_err();
        assert!(e.contains("not a book"), "{e}");
    }

    #[test]
    fn compiles_a_recipe_of_the_mods_own_kind() {
        let r = r##"{ "type": "mymod:infusion", "slots": { "core": ["minecraft:diamond"], "ring": [["minecraft:coal", "minecraft:charcoal"], "#c:dusts"] },
                     "values": { "time": 200 }, "result": "minecraft:emerald", "count": 2 }"##;
        let c = compile(&project(&[("content/infusion.yrecipe", r)]), "mymod", &yres::Refs::default()).unwrap();
        let src = c.source.unwrap();
        assert!(src.contains("registry.add_recipe_json(\"mymod:infusion\""), "{src}");
        assert!(src.contains(r#"\"type\":\"mymod:infusion\""#) && src.contains(r#"\"time\":200"#), "{src}");

        let bad = r#"{ "type": "mymod:infusion", "ingredient": "minecraft:stone", "result": "minecraft:emerald" }"#;
        let e = compile(&project(&[("content/bad.yrecipe", bad)]), "mymod", &yres::Refs::default()).unwrap_err();
        assert!(e.contains("takes \"slots\"") && e.contains("needs \"slots\""), "{e}");
        // Another mod's kind isn't the mod's own: not a Yog recipe type.
        let other = r#"{ "type": "create:mixing", "result": "minecraft:emerald" }"#;
        assert!(compile(&project(&[("content/o.yrecipe", other)]), "mymod", &yres::Refs::default()).is_err());
    }

    #[test]
    fn compiles_an_item_with_resource_refs() {
        let root = project(&[(
            "content/items/ruby.yitem",
            r#"{ "name": "@Items.ruby", "tooltip": "@Strings.ruby_tip",
                 "item": { "stack_size": 16, "food": { "nutrition": 4, "saturation": 0.3 } },
                 "model": { "parent": "generated", "textures": { "layer0": "@Textures.ruby" } } }"#,
        )]);
        let mut refs = yres::Refs::default();
        refs.texts.insert(
            "Items.ruby".into(),
            ("item.mymod.ruby".into(), "Ruby".into()),
        );
        refs.texts.insert(
            "Strings.ruby_tip".into(),
            ("mymod.ruby_tip".into(), "Shiny".into()),
        );
        refs.images
            .insert("Textures.ruby".into(), "mymod:item/ruby".into());
        let c = compile(&root, "mymod", &refs).unwrap();
        assert_eq!(
            output(&c, "assets/mymod/models/item/ruby.json"),
            json!({ "parent": "minecraft:item/generated", "textures": { "layer0": "mymod:item/ruby" } })
        );
        let src = c.source.clone().unwrap();
        assert!(src.contains(".max_stack(16)"), "{src}");
        assert!(
            src.contains(".food(::yog_api::FoodDef::new(4, 0.3))"),
            "{src}"
        );
        // The .yres lang file gets the tooltip under the key the game reads.
        let mut outputs = vec![(
            "assets/mymod/lang/ru_ru.json".to_string(),
            r#"{"item.mymod.ruby": "Рубин", "mymod.ruby_tip": "Блестит"}"#
                .as_bytes()
                .to_vec(),
        )];
        merge_outputs(&root, &mut outputs, c).unwrap();
        let ru: Value = serde_json::from_slice(&outputs[0].1).unwrap();
        assert_eq!(ru["item.mymod.ruby.desc"], json!("Блестит"));
        let _ = std::fs::remove_dir_all(root);
    }

    #[test]
    fn namespace_needed_for_odd_mod_ids() {
        let root = project(&[(
            "content/x.yitem",
            r#"{ "model": { "parent": "generated", "textures": { "layer0": "minecraft:item/apple" } } }"#,
        )]);
        let e = compile(&root, "Example-Mod", &yres::Refs::default()).unwrap_err();
        assert!(e.contains("give the namespace"), "{e}");
        let _ = std::fs::remove_dir_all(root);
    }
}