// SPDX-FileCopyrightText: 2026 Milovann Yanatchkov
// SPDX-License-Identifier: MIT

//! The eval walk — the relation graph built from the AST (goal 4).
//!
//! Per-entity behavior lives in the node modules ([`crate::nodes`]); this
//! file owns the walk itself: program → bindings → dispatch.

use parser::ast::{Expression, FunctionCall, Program};

use crate::error::Error;
use crate::store::Store;

/// Evaluate a program: walk the statements once, build the graph.
///
/// `file` is the source name the GUIDs derive from
/// (`stable_hash(file, name)`).
pub fn eval_program(program: &Program, file: &str) -> Result<Store, Error> {
    let mut store = Store::new();
    for stmt in &program.statements {
        let assignment = &stmt.assignment;
        eval_binding(
            &mut store,
            file,
            &assignment.identifier,
            &assignment.expression,
        )?;
        // The statement log — to_bimr's walk. Engine-created nodes (a
        // Divide's items) never enter it.
        let guid = store
            .named
            .get(&assignment.identifier)
            .copied()
            .expect("a statement binds its name");
        store.statements.push(guid);
    }
    Ok(store)
}

/// One binding: `name = <expression>`.
fn eval_binding(
    store: &mut Store,
    file: &str,
    name: &str,
    expression: &Expression,
) -> Result<(), Error> {
    let Expression::FunctionCall(call) = expression else {
        return Err(Error::Unsupported(
            "right-hand side must be a constructor call",
        ));
    };
    eval_call(store, file, name, call)
}

fn eval_call(store: &mut Store, file: &str, name: &str, call: &FunctionCall) -> Result<(), Error> {
    crate::nodes::call(store, file, name, call.name.as_str(), &call.arguments)
}

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

    const WALL: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "p2 = Point(500,0,0)\n",
        "l1 = Line(p1,p2)\n",
        "w1 = Wall(l1,20,300)\n",
    );

    fn eval_src(src: &str) -> Result<Store, Error> {
        let program = parser::parse(src).expect("parse ok");
        eval_program(&program, "wall.bimr")
    }

    #[test]
    fn wall_sample_builds_four_nodes() {
        let store = eval_src(WALL).expect("eval ok");
        assert_eq!(store.arena.len(), 4);
        assert_eq!(
            store
                .order
                .iter()
                .map(|g| store.name_of(*g).unwrap())
                .collect::<Vec<_>>(),
            vec!["p1", "p2", "l1", "w1"]
        );
        assert_eq!(store.order[0], Guid::from_name("wall.bimr", "p1"));
    }

    #[test]
    fn wall_holds_line_by_value_with_guid_backref() {
        let store = eval_src(WALL).expect("eval ok");
        let w = store.resolve(Guid::from_name("wall.bimr", "w1")).unwrap();
        assert_eq!(w.refs, vec![Guid::from_name("wall.bimr", "l1")]);
        match &w.entity {
            bimr::Entity::Wall(wall) => {
                assert_eq!(wall.line.start.x, 0.0);
                assert_eq!(wall.line.end.x, 500.0);
                assert_eq!(wall.width, 20.0);
                assert_eq!(wall.height, 300.0);
            }
            other => panic!("expected Wall, got {}", other.type_name()),
        }
    }

    #[test]
    fn line_records_both_point_edges() {
        let store = eval_src(WALL).expect("eval ok");
        let l = store.resolve(Guid::from_name("wall.bimr", "l1")).unwrap();
        assert_eq!(
            l.refs,
            vec![
                Guid::from_name("wall.bimr", "p1"),
                Guid::from_name("wall.bimr", "p2"),
            ]
        );
    }

    #[test]
    fn unknown_constructors_are_rejected() {
        // No curated blocklist: anything outside the dispatch is simply an
        // unknown call.
        for src in [
            "x = Each(source=s, element=\"wall\", params=p)\n",
            "x = Level(elevation=0, entities=e)\n",
            "x = Mesh(e)\n",
            "x = Frob(p1)\n",
        ] {
            let err = eval_src(src).unwrap_err();
            assert!(
                matches!(err, Error::Unsupported("call")),
                "{src}: got {err:?}"
            );
        }
    }

    #[test]
    fn unknown_keywords_are_rejected() {
        let err = eval_src("p1 = Point(x=0, y=0, z=0)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
    }

    #[test]
    fn wall_keyword_form_round_trips() {
        // The reference to_bimr() emits this exact keyword form — the eval must
        // accept what its own serializer produces.
        let store = eval_src("w1 = Wall(l1, thickness=20, height=300)\n");
        assert!(store.is_err()); // l1 undefined — but the failure must come
        // from resolution, not the keyword form
        let src = "a = Point(0,0,0)\nb = Point(1,0,0)\nl1 = Line(a, b)\nw1 = Wall(l1, thickness=20, height=300)\n";
        assert!(eval_src(src).is_ok());
    }

    #[test]
    fn unknown_name_is_reported() {
        let err = eval_src("l1 = Line(nope, p2)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    #[test]
    fn wrong_nature_is_reported() {
        let src = "p1 = Point(0,0,0)\np2 = Point(1,0,0)\nw1 = Wall(p1, 20, 300)\n";
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p1".to_string(),
                expected: "Line",
                got: "Point",
            }
        );
    }

    #[test]
    fn arity_is_rejected() {
        let err = eval_src("p1 = Point(0, 0)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
    }

    const LIST_SRC: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "p2 = Point(1,0,0)\n",
        "lst = List(p1, p2)\n",
    );

    #[test]
    fn list_builds_one_node_with_item_edges() {
        let store = eval_src(LIST_SRC).expect("eval ok");
        assert_eq!(store.arena.len(), 3);
        let l = store.resolve(Guid::from_name("wall.bimr", "lst")).unwrap();
        assert_eq!(
            l.refs,
            vec![
                Guid::from_name("wall.bimr", "p1"),
                Guid::from_name("wall.bimr", "p2"),
            ]
        );
        match &l.entity {
            bimr::Entity::List(list) => {
                assert_eq!(list.kind(), "Point");
                assert_eq!(list.length(), 2);
            }
            other => panic!("expected List, got {}", other.type_name()),
        }
    }

    #[test]
    fn list_compact_form_round_trips() {
        let store = eval_src(LIST_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\np2 = Point(1, 0, 0)\nlst = List(p1, p2)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn list_holds_walls_of_the_first_items_nature() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "w1 = Wall(l1, 20, 300)\n",
            "w2 = Wall(l1, 30, 200)\n",
            "lst = List(w1, w2)\n",
        );
        let store = eval_src(src).expect("eval ok");
        match &store.arena[5].entity {
            bimr::Entity::List(list) => assert_eq!(list.kind(), "Wall"),
            other => panic!("expected List, got {}", other.type_name()),
        }
    }

    #[test]
    fn mixed_list_is_rejected() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lst = List(p1, l1)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "l1".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
    }

    #[test]
    fn empty_list_is_rejected() {
        let err = eval_src("lst = List()\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
    }

    #[test]
    fn list_keywords_are_rejected() {
        let err = eval_src("lst = List(items=p1)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
    }

    #[test]
    fn list_unknown_item_is_reported() {
        let err = eval_src("lst = List(nope)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    #[test]
    fn list_is_not_mesh_bearing() {
        let store = eval_src(LIST_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_ifcx(&store),
            crate::serialize::to_ifcx(&empty_store())
        );
    }

    fn empty_store() -> crate::store::Store {
        let program = parser::parse("").expect("parse ok");
        eval_program(&program, "wall.bimr").expect("eval ok")
    }

    // ── Circle: a curve primitive over a named center ───────────────────────

    const CIRCLE_SRC: &str = concat!("p1 = Point(0,0,0)\n", "c1 = Circle(p1, 200)\n",);

    #[test]
    fn circle_builds_from_resolved_center() {
        let store = eval_src(CIRCLE_SRC).expect("eval ok");
        assert_eq!(store.arena.len(), 2);
        let c = store.resolve(Guid::from_name("wall.bimr", "c1")).unwrap();
        assert_eq!(c.refs, vec![Guid::from_name("wall.bimr", "p1")]);
        match &c.entity {
            bimr::Entity::Circle(circle) => {
                assert_eq!(circle.center.x, 0.0);
                assert_eq!(circle.radius, 200.0);
            }
            other => panic!("expected Circle, got {}", other.type_name()),
        }
    }

    #[test]
    fn circle_compact_form_round_trips() {
        let store = eval_src(CIRCLE_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\nc1 = Circle(p1, 200)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn circle_center_must_be_a_point() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "c1 = Circle(l1, 200)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "l1".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
    }

    #[test]
    fn circle_arity_is_rejected() {
        let err = eval_src("p1 = Point(0,0,0)\nc1 = Circle(p1)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
    }

    #[test]
    fn circle_keywords_are_rejected() {
        let err = eval_src("p1 = Point(0,0,0)\nc1 = Circle(p1, r=200)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
    }

    #[test]
    fn circle_unknown_center_is_reported() {
        let err = eval_src("c1 = Circle(nope, 200)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    #[test]
    fn circle_is_not_mesh_bearing() {
        let store = eval_src(CIRCLE_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_ifcx(&store),
            crate::serialize::to_ifcx(&empty_store())
        );
    }

    // ── Divide: the operator entity — circle division first ─────────────────

    const DIVIDE_SRC: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "c1 = Circle(p1, 100)\n",
        "d1 = Divide(c1, 4)\n",
    );

    #[test]
    fn divide_holds_source_by_value_with_edge() {
        let store = eval_src(DIVIDE_SRC).expect("eval ok");
        // p1, c1, the record, and the 4 created items.
        assert_eq!(store.arena.len(), 7);
        let d = store.resolve(Guid::from_name("wall.bimr", "d1")).unwrap();
        assert_eq!(d.refs, vec![Guid::from_name("wall.bimr", "c1")]);
        match &d.entity {
            bimr::Entity::Divide(div) => {
                assert_eq!(div.source().type_name(), "Circle");
                assert_eq!(div.n(), 4);
            }
            other => panic!("expected Divide, got {}", other.type_name()),
        }
        // The created items: named <binding>_<i>, edges to the record.
        let record = Guid::from_name("wall.bimr", "d1");
        let items = store.outputs_of(record);
        assert_eq!(items.len(), 4);
        for (i, &guid) in items.iter().enumerate() {
            let node = store.resolve(guid).unwrap();
            assert_eq!(store.name_of(guid), Some(format!("d1_{i}").as_str()));
            assert_eq!(node.refs, vec![record]);
            assert!(matches!(node.entity, bimr::Entity::Point(_)));
        }
        // The record is a statement; its items are engine-owned.
        assert_eq!(store.statements.len(), 3);
        assert!(!store.statements.contains(&items[0]));
    }

    #[test]
    fn divide_items_are_created_at_the_divided_positions() {
        let store = eval_src(DIVIDE_SRC).expect("eval ok");
        let record = Guid::from_name("wall.bimr", "d1");
        let first = store.resolve(store.outputs_of(record)[0]).unwrap();
        match &first.entity {
            // i = 0 starts on the positive x-axis: (100, 0).
            bimr::Entity::Point(p) => assert_eq!((p.x, p.y, p.z), (100.0, 0.0, 0.0)),
            other => panic!("expected Point, got {}", other.type_name()),
        }
    }

    #[test]
    fn divide_compact_form_round_trips() {
        let store = eval_src(DIVIDE_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\nc1 = Circle(p1, 100)\nd1 = Divide(c1, 4)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn divide_source_must_be_a_circle() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "d1 = Divide(l1, 4)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "l1".to_string(),
                expected: "Circle or Curve",
                got: "Line",
            }
        );
    }

    #[test]
    fn divide_count_must_be_a_positive_integer() {
        for n in ["0", "-2", "2.5"] {
            let src = format!("p1 = Point(0,0,0)\nc1 = Circle(p1, 100)\nd1 = Divide(c1, {n})\n");
            let err = eval_src(&src).unwrap_err();
            assert!(matches!(err, Error::Unsupported("arity")), "{n}: {err:?}");
        }
    }

    #[test]
    fn divide_keywords_are_rejected() {
        let err = eval_src("p1 = Point(0,0,0)\nc1 = Circle(p1, 100)\nd1 = Divide(c1, n=4)\n")
            .unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
    }

    #[test]
    fn divide_unknown_source_is_reported() {
        let err = eval_src("d1 = Divide(nope, 4)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    #[test]
    fn divide_item_name_collision_is_rejected() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "c1 = Circle(p1, 100)\n",
            "d1_0 = Point(1,1,1)\n",
            "d1 = Divide(c1, 4)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(err, Error::NameCollision("d1_0".to_string()));
    }

    #[test]
    fn divide_is_not_mesh_bearing() {
        let store = eval_src(DIVIDE_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_ifcx(&store),
            crate::serialize::to_ifcx(&empty_store())
        );
    }

    #[test]
    fn column_over_divide_lifts_a_ring_of_columns() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "c1 = Circle(p1, 100)\n",
            "d1 = Divide(c1, 6)\n",
            "cols = Column(d1, 300, 30, 30)\n",
        );
        let store = eval_src(src).expect("eval ok");
        // p1, c1, d1, 6 created items, cols.
        assert_eq!(store.arena.len(), 10);
        let cols = store.resolve(Guid::from_name("wall.bimr", "cols")).unwrap();
        assert_eq!(cols.refs, vec![Guid::from_name("wall.bimr", "d1")]);
        match &cols.entity {
            bimr::Entity::List(list) => {
                assert_eq!(list.kind(), "Column");
                assert_eq!(list.length(), 6);
                // i = 0 starts on the positive x-axis — the first column's
                // base sits at (100, 0).
                assert!(matches!(
                    list.get(0),
                    Some(bimr::Entity::Column(col)) if col.base.x == 100.0 && col.base.y == 0.0
                ));
            }
            other => panic!("expected List, got {}", other.type_name()),
        }
        // And the lifted statement round-trips.
        let src2 = crate::serialize::to_bimr(&store);
        assert!(
            src2.contains("cols = Column(d1, height=300, section_width=30, section_height=30)")
        );
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    // ── Vector: a graph parameter ───────────────────────────────────────────

    #[test]
    fn vector_builds_a_leaf() {
        let store = eval_src("v1 = Vector(0, 0, 300)\n").expect("eval ok");
        assert_eq!(store.arena.len(), 1);
        let v = store.resolve(Guid::from_name("wall.bimr", "v1")).unwrap();
        assert!(v.refs.is_empty());
        match &v.entity {
            bimr::Entity::Vector(vec) => assert_eq!((vec.x, vec.y, vec.z), (0.0, 0.0, 300.0)),
            other => panic!("expected Vector, got {}", other.type_name()),
        }
        assert_eq!(crate::serialize::to_bimr(&store), "v1 = Vector(0, 0, 300)");
    }

    #[test]
    fn vector_arity_and_keywords_are_rejected() {
        let err = eval_src("v1 = Vector(0, 0)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        let err = eval_src("v1 = Vector(x=0, y=0, z=1)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
    }

    // ── Cut: curve pieces — a closed loop on a circle ───────────────────────

    const CUT_SRC: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "c1 = Circle(p1, 100)\n",
        "ct1 = Cut(c1, 4)\n",
    );

    #[test]
    fn cut_builds_record_and_line_pieces() {
        let store = eval_src(CUT_SRC).expect("eval ok");
        // p1, c1, the record, and the 4 created pieces.
        assert_eq!(store.arena.len(), 7);
        let record = Guid::from_name("wall.bimr", "ct1");
        let ct = store.resolve(record).unwrap();
        assert_eq!(ct.refs, vec![Guid::from_name("wall.bimr", "c1")]);
        match &ct.entity {
            bimr::Entity::Cut(cut) => {
                assert_eq!(cut.source().type_name(), "Circle");
                assert_eq!(cut.n(), 4);
            }
            other => panic!("expected Cut, got {}", other.type_name()),
        }
        // The created pieces: named <binding>_<i>, edges to the record.
        let items = store.outputs_of(record);
        assert_eq!(items.len(), 4);
        for (i, &guid) in items.iter().enumerate() {
            let node = store.resolve(guid).unwrap();
            assert_eq!(store.name_of(guid), Some(format!("ct1_{i}").as_str()));
            assert_eq!(node.refs, vec![record]);
            assert!(matches!(node.entity, bimr::Entity::Line(_)));
        }
        // The record is a statement; its pieces are engine-owned.
        assert_eq!(store.statements.len(), 3);
        assert!(!store.statements.contains(&items[0]));
    }

    #[test]
    fn cut_pieces_form_a_closed_loop() {
        let store = eval_src(CUT_SRC).expect("eval ok");
        let record = Guid::from_name("wall.bimr", "ct1");
        let piece = |i: usize| match &store.resolve(store.outputs_of(record)[i]).unwrap().entity {
            bimr::Entity::Line(l) => *l,
            other => panic!("expected Line, got {}", other.type_name()),
        };
        // i = 0 starts on the positive x-axis: (100, 0) → (0, 100).
        let p0 = piece(0);
        assert_eq!((p0.start.x, p0.start.y), (100.0, 0.0));
        assert_eq!((p0.end.x, p0.end.y), (0.0, 100.0));
        // The last piece closes back to the first point.
        let p3 = piece(3);
        assert_eq!((p3.end.x, p3.end.y), (100.0, 0.0));
    }

    #[test]
    fn cut_compact_form_round_trips() {
        let store = eval_src(CUT_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\nc1 = Circle(p1, 100)\nct1 = Cut(c1, 4)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn cut_rejections() {
        // Wrong source.
        let err = eval_src("p1 = Point(0,0,0)\nct1 = Cut(p1, 4)\n").unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p1".to_string(),
                expected: "Circle or Curve",
                got: "Point",
            }
        );
        // Piece-name collision.
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "c1 = Circle(p1, 100)\n",
            "ct1_0 = Point(1,1,1)\n",
            "ct1 = Cut(c1, 4)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(err, Error::NameCollision("ct1_0".to_string()));
        // Count gate.
        let err =
            eval_src("p1 = Point(0,0,0)\nc1 = Circle(p1, 100)\nct1 = Cut(c1, 2.5)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        // Keywords.
        let err =
            eval_src("p1 = Point(0,0,0)\nc1 = Circle(p1, 100)\nct1 = Cut(c1, n=4)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
        // Unknown source.
        let err = eval_src("ct1 = Cut(nope, 4)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    // ── Extrusion: profile by value, swept by a Vector ──────────────────────

    const CYLINDER_SRC: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "c1 = Circle(p1, 100)\n",
        "ct1 = Cut(c1, 4)\n",
        "v1 = Vector(0, 0, 300)\n",
        "e1 = Extrusion(ct1, v1)\n",
    );

    #[test]
    fn extrusion_from_cut_holds_profile_by_value() {
        let store = eval_src(CYLINDER_SRC).expect("eval ok");
        // p1, c1, ct1, 4 pieces, v1, e1.
        assert_eq!(store.arena.len(), 9);
        let e = store.resolve(Guid::from_name("wall.bimr", "e1")).unwrap();
        assert_eq!(
            e.refs,
            vec![
                Guid::from_name("wall.bimr", "ct1"),
                Guid::from_name("wall.bimr", "v1"),
            ]
        );
        match &e.entity {
            bimr::Entity::Extrusion(ex) => {
                assert_eq!(ex.profile().len(), 4);
                assert_eq!((ex.vec().x, ex.vec().y, ex.vec().z), (0.0, 0.0, 300.0));
            }
            other => panic!("expected Extrusion, got {}", other.type_name()),
        }
    }

    #[test]
    fn extrusion_meshes_without_caps() {
        let store = eval_src(CYLINDER_SRC).expect("eval ok");
        // 4-piece closed loop → 4 quads → 16 points, 24 indices; no caps.
        match &store.arena[8].entity {
            bimr::Entity::Extrusion(ex) => {
                let m = ex.mesh().expect("extrusion meshes");
                assert_eq!(m.points.len(), 16);
                assert_eq!(m.indices.len(), 24);
            }
            other => panic!("expected Extrusion, got {}", other.type_name()),
        }
        // And it flows through the IFCX emitter as a mesh-bearing entity.
        let doc: serde_json::Value =
            serde_json::from_str(&crate::serialize::to_ifcx(&store)).unwrap();
        let data = doc["data"].as_array().unwrap();
        assert_eq!(data.len(), 1);
        assert_eq!(data[0]["path"], serde_json::json!("extrusion-001"));
        let mesh = &data[0]["attributes"]["usd::usdgeom::mesh"];
        assert_eq!(mesh["points"].as_array().unwrap().len(), 16);
        assert_eq!(mesh["faceVertexIndices"].as_array().unwrap().len(), 24);
    }

    #[test]
    fn extrusion_compact_form_round_trips() {
        let store = eval_src(CYLINDER_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            concat!(
                "p1 = Point(0, 0, 0)\n",
                "c1 = Circle(p1, 100)\n",
                "ct1 = Cut(c1, 4)\n",
                "v1 = Vector(0, 0, 300)\n",
                "e1 = Extrusion(ct1, v1)",
            )
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn extrusion_over_a_list_of_lines() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "v1 = Vector(0, 0, 10)\n",
            "e1 = Extrusion(lines, v1)\n",
        );
        let store = eval_src(src).expect("eval ok");
        match &store.arena[5].entity {
            bimr::Entity::Extrusion(ex) => {
                assert_eq!(ex.profile().len(), 1);
                let m = ex.mesh().expect("single piece meshes");
                assert_eq!(m.points.len(), 4);
            }
            other => panic!("expected Extrusion, got {}", other.type_name()),
        }
    }

    #[test]
    fn extrusion_rejections() {
        // Profile of the wrong kind.
        let err = eval_src(
            "p1 = Point(0,0,0)\nlst = List(p1)\nv1 = Vector(0,0,1)\ne1 = Extrusion(lst, v1)\n",
        )
        .unwrap_err();
        assert_eq!(
            err,
            Error::ListKind {
                name: "lst".to_string(),
                expected: "Line",
                got: "Point",
            }
        );
        // Profile of the wrong nature.
        let err = eval_src("p1 = Point(0,0,0)\nv1 = Vector(0,0,1)\ne1 = Extrusion(p1, v1)\n")
            .unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p1".to_string(),
                expected: "List",
                got: "Point",
            }
        );
        // Sweep must be a Vector.
        let err = eval_src("p1 = Point(0,0,0)\np2 = Point(1,0,0)\nl1 = Line(p1, p2)\nlst = List(l1)\ne1 = Extrusion(lst, p2)\n").unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p2".to_string(),
                expected: "Vector",
                got: "Point",
            }
        );
        // Arity.
        let err = eval_src("v1 = Vector(0,0,1)\ne1 = Extrusion(v1)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        // Keywords.
        let err = eval_src("v1 = Vector(0,0,1)\ne1 = Extrusion(src=v1, vec=v1)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
        // Unknown names.
        let err = eval_src("v1 = Vector(0,0,1)\ne1 = Extrusion(nope, v1)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    const COLUMN_SRC: &str = concat!("p1 = Point(0,0,0)\n", "c1 = Column(p1, 300, 30, 30)\n",);

    #[test]
    fn column_builds_from_resolved_base() {
        let store = eval_src(COLUMN_SRC).expect("eval ok");
        assert_eq!(store.arena.len(), 2);
        let c = store.resolve(Guid::from_name("wall.bimr", "c1")).unwrap();
        assert_eq!(c.refs, vec![Guid::from_name("wall.bimr", "p1")]);
        match &c.entity {
            bimr::Entity::Column(col) => {
                assert_eq!(col.base.x, 0.0);
                assert_eq!(col.height, 300.0);
                assert_eq!(col.section_width, 30.0);
                assert_eq!(col.section_height, 30.0);
            }
            other => panic!("expected Column, got {}", other.type_name()),
        }
    }

    #[test]
    fn column_compact_form_matches_reference_and_round_trips() {
        // The reference to_bimr() emits this exact keyword form — the eval must
        // accept what its own serializer produces, and the emission must be
        // the fixed point.
        let store = eval_src(COLUMN_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\nc1 = Column(p1, height=300, section_width=30, section_height=30)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn column_base_must_be_a_point() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "c1 = Column(l1, 300, 30, 30)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "l1".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
    }

    #[test]
    fn column_arity_is_rejected() {
        let err = eval_src("p1 = Point(0,0,0)\nc1 = Column(p1, 300, 30)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
    }

    #[test]
    fn column_unknown_keyword_is_rejected() {
        let err = eval_src(
            "p1 = Point(0,0,0)\nc1 = Column(p1, h=300, section_width=30, section_height=30)\n",
        )
        .unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
    }

    #[test]
    fn column_unknown_base_is_reported() {
        let err = eval_src("c1 = Column(nope, 300, 30, 30)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    #[test]
    fn column_ifcx_emits_column_mesh() {
        let store = eval_src(COLUMN_SRC).expect("eval ok");
        let doc: serde_json::Value =
            serde_json::from_str(&crate::serialize::to_ifcx(&store)).unwrap();
        let data = doc["data"].as_array().unwrap();
        assert_eq!(data.len(), 1);
        assert_eq!(data[0]["path"], serde_json::json!("column-001"));
        let mesh = &data[0]["attributes"]["usd::usdgeom::mesh"];
        assert_eq!(mesh["points"].as_array().unwrap().len(), 24);
        assert_eq!(mesh["faceVertexIndices"].as_array().unwrap().len(), 36);
    }

    // ── Lifting: a node over a List produces a List (replaces Each) ─────────

    /// 2x2 grid — the small stand-in for the 4x4 gate corpus.
    const LIFT_SRC: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "p2 = Point(1000,0,0)\n",
        "p3 = Point(0,1000,0)\n",
        "p4 = Point(1000,1000,0)\n",
        "pts = List(p1, p2, p3, p4)\n",
        "cols = Column(pts, 300, 30, 30)\n",
    );

    #[test]
    fn column_over_list_lifts_to_list_of_columns() {
        let store = eval_src(LIFT_SRC).expect("eval ok");
        assert_eq!(store.arena.len(), 6);
        let cols = store.resolve(Guid::from_name("wall.bimr", "cols")).unwrap();
        assert_eq!(cols.refs, vec![Guid::from_name("wall.bimr", "pts")]);
        match &cols.entity {
            bimr::Entity::List(list) => {
                assert_eq!(list.kind(), "Column");
                assert_eq!(list.length(), 4);
                assert!(matches!(list.get(2), Some(bimr::Entity::Column(c)) if c.base.y == 1000.0));
            }
            other => panic!("expected List, got {}", other.type_name()),
        }
    }

    #[test]
    fn lifted_compact_form_round_trips() {
        let store = eval_src(LIFT_SRC).expect("eval ok");
        let src2 = crate::serialize::to_bimr(&store);
        assert!(
            src2.contains("cols = Column(pts, height=300, section_width=30, section_height=30)")
        );
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
        // And the geometry survives: 4 columns in both stores.
        for store in [&store, &store2] {
            match &store.arena[5].entity {
                bimr::Entity::List(list) => assert_eq!(list.length(), 4),
                other => panic!("expected List, got {}", other.type_name()),
            }
        }
    }

    #[test]
    fn lifted_ifcx_emits_one_mesh_per_item() {
        let store = eval_src(LIFT_SRC).expect("eval ok");
        let doc: serde_json::Value =
            serde_json::from_str(&crate::serialize::to_ifcx(&store)).unwrap();
        let data = doc["data"].as_array().unwrap();
        assert_eq!(data.len(), 4);
        let paths: Vec<_> = data.iter().map(|d| d["path"].as_str().unwrap()).collect();
        assert_eq!(
            paths,
            ["column-001", "column-002", "column-003", "column-004"]
        );
    }

    #[test]
    fn lifting_rejects_wrong_kind_list() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "cols = Column(lines, 300, 30, 30)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::ListKind {
                name: "lines".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
    }

    #[test]
    fn single_column_over_non_point_is_still_wrong_nature() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "c1 = Column(l1, 300, 30, 30)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "l1".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
    }

    #[test]
    fn float_arguments_work() {
        let store = eval_src("p1 = Point(0.5, 1.25, -2.0)\n").expect("eval ok");
        match &store.arena[0].entity {
            bimr::Entity::Point(p) => assert_eq!((p.x, p.y, p.z), (0.5, 1.25, -2.0)),
            other => panic!("expected Point, got {}", other.type_name()),
        }
    }

    // ── Frame: a hollow rectangular solid between two named points ──────────

    const FRAME_SRC: &str = concat!(
        "p1 = Point(0,0,0)\n",
        "p2 = Point(100,0,0)\n",
        "fr1 = Frame(p1, p2, 100, 300, 20, 10)\n",
    );

    #[test]
    fn frame_builds_from_resolved_points() {
        let store = eval_src(FRAME_SRC).expect("eval ok");
        assert_eq!(store.arena.len(), 3);
        let f = store.resolve(Guid::from_name("wall.bimr", "fr1")).unwrap();
        assert_eq!(
            f.refs,
            vec![
                Guid::from_name("wall.bimr", "p1"),
                Guid::from_name("wall.bimr", "p2"),
            ]
        );
        match &f.entity {
            bimr::Entity::Frame(fr) => {
                assert_eq!((fr.origin.x, fr.origin.y, fr.origin.z), (0.0, 0.0, 0.0));
                assert_eq!((fr.end.x, fr.end.y, fr.end.z), (100.0, 0.0, 0.0));
                assert_eq!(
                    (fr.width, fr.height, fr.depth, fr.thickness),
                    (100.0, 300.0, 20.0, 10.0)
                );
            }
            other => panic!("expected Frame, got {}", other.type_name()),
        }
    }

    #[test]
    fn frame_compact_form_matches_reference_and_round_trips() {
        // The reference to_bimr() emits this exact keyword form — the eval must
        // accept what its own serializer produces, and the emission must be
        // the fixed point.
        let store = eval_src(FRAME_SRC).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\np2 = Point(100, 0, 0)\nfr1 = Frame(p1, p2, width=100, height=300, depth=20, thickness=10)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn frame_ifcx_emits_frame_mesh() {
        let store = eval_src(FRAME_SRC).expect("eval ok");
        let doc: serde_json::Value =
            serde_json::from_str(&crate::serialize::to_ifcx(&store)).unwrap();
        let data = doc["data"].as_array().unwrap();
        assert_eq!(data.len(), 1);
        assert_eq!(data[0]["path"], serde_json::json!("frame-001"));
        let mesh = &data[0]["attributes"]["usd::usdgeom::mesh"];
        assert_eq!(mesh["points"].as_array().unwrap().len(), 64);
        assert_eq!(mesh["faceVertexIndices"].as_array().unwrap().len(), 96);
    }

    #[test]
    fn frame_rejections() {
        // Origin must be a Point.
        let err = eval_src("p1 = Point(0,0,0)\np2 = Point(1,0,0)\nl1 = Line(p1, p2)\nfr1 = Frame(l1, p1, 1, 2, 3, 4)\n").unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "l1".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
        // Arity.
        let err = eval_src("p1 = Point(0,0,0)\nfr1 = Frame(p1, p1, 1, 2, 3)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        // Unknown keyword.
        let err =
            eval_src("p1 = Point(0,0,0)\nfr1 = Frame(p1, p1, w=1, h=2, d=3, t=4)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
        // Unknown name.
        let err = eval_src("fr1 = Frame(nope, p1, 1, 2, 3, 4)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    // ── Explode + Frame lift: the ring of frames, no generated names ────────

    #[test]
    fn explode_builds_record_and_pair_parts() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "ex1 = Explode(lines)\n",
        );
        let store = eval_src(src).expect("eval ok");
        // p1, p2, l1, lines, ex1, 1 pair part.
        assert_eq!(store.arena.len(), 6);
        let record = Guid::from_name("wall.bimr", "ex1");
        let ex = store.resolve(record).unwrap();
        assert_eq!(ex.refs, vec![Guid::from_name("wall.bimr", "lines")]);
        assert!(matches!(ex.entity, bimr::Entity::Explode(_)));
        // The created part: one pair (a List of two Points), edged to the
        // record, not a statement.
        let items = store.outputs_of(record);
        assert_eq!(items.len(), 1);
        let pair = store.resolve(items[0]).unwrap();
        assert_eq!(store.name_of(items[0]), Some("ex1_0"));
        assert_eq!(pair.refs, vec![record]);
        match &pair.entity {
            bimr::Entity::List(list) => {
                assert_eq!(list.kind(), "Point");
                assert_eq!(list.length(), 2);
            }
            other => panic!("expected a pair List, got {}", other.type_name()),
        }
        // The record IS a statement (p1, p2, l1, lines, ex1); its part is not.
        assert_eq!(store.statements.len(), 5);
        assert!(!store.statements.contains(&items[0]));
    }

    #[test]
    fn explode_compact_form_round_trips() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "ex1 = Explode(lines)\n",
        );
        let store = eval_src(src).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            "p1 = Point(0, 0, 0)\np2 = Point(1, 0, 0)\nl1 = Line(p1, p2)\nlines = List(l1)\nex1 = Explode(lines)"
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn explode_rejections() {
        // Exploding a Point is not supported.
        let err = eval_src("p1 = Point(0,0,0)\nex1 = Explode(p1)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("explode")));
        // Arity.
        let err = eval_src(
            "p1 = Point(0,0,0)\np2 = Point(1,0,0)\nl1 = Line(p1, p2)\nex1 = Explode(l1, l1)\n",
        )
        .unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        // Collision.
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "ex1_0 = Point(2,2,2)\n",
            "ex1 = Explode(l1)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(err, Error::NameCollision("ex1_0".to_string()));
        // Unknown name.
        let err = eval_src("ex1 = Explode(nope)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    #[test]
    fn frame_lifts_over_an_explode_record() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "ex1 = Explode(lines)\n",
            "frs = Frame(ex1, 100, 300, 20, 10)\n",
        );
        let store = eval_src(src).expect("eval ok");
        // p1, p2, l1, lines, ex1, 1 pair, frs.
        assert_eq!(store.arena.len(), 7);
        let frs = store.resolve(Guid::from_name("wall.bimr", "frs")).unwrap();
        assert_eq!(frs.refs, vec![Guid::from_name("wall.bimr", "ex1")]);
        match &frs.entity {
            bimr::Entity::List(list) => {
                assert_eq!(list.kind(), "Frame");
                assert_eq!(list.length(), 1);
                assert!(matches!(
                    list.get(0),
                    Some(bimr::Entity::Frame(f)) if f.origin.x == 0.0 && f.end.x == 1.0
                ));
            }
            other => panic!("expected List, got {}", other.type_name()),
        }
        // The lifted statement round-trips through the pair-source form.
        let src2 = crate::serialize::to_bimr(&store);
        assert!(src2.contains("frs = Frame(ex1, width=100, height=300, depth=20, thickness=10)"));
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn frame_lift_rejections() {
        // A flat List of Points is not pairs.
        let err = eval_src("p1 = Point(0,0,0)\nlst = List(p1)\nfrs = Frame(lst, 1, 2, 3, 4)\n")
            .unwrap_err();
        assert_eq!(
            err,
            Error::ListKind {
                name: "lst".to_string(),
                expected: "List",
                got: "Point",
            }
        );
        // A wrong-nature source.
        let err = eval_src("p1 = Point(0,0,0)\nfrs = Frame(p1, 1, 2, 3, 4)\n").unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p1".to_string(),
                expected: "List",
                got: "Point",
            }
        );
    }

    // ── Curve: a closed spline — Divide and Cut work like the Circle ────────

    /// Peanut control points: two lobes, a waisted middle.
    const PEANUT_CTRL: &str = "1600,0|600,500|0,250|-600,500|-1600,0|-600,-500|0,-250|600,-500";

    fn peanut_curve_src() -> String {
        let mut src = String::from("p1 = Point(0,0,0)\n");
        for (i, pair) in PEANUT_CTRL.split('|').enumerate() {
            let (x, y) = pair.split_once(',').unwrap();
            src.push_str(&format!("c{i} = Point({x}, {y}, 0)\n"));
        }
        src.push_str("ctrl = List(c0, c1, c2, c3, c4, c5, c6, c7)\ncrv = Curve(ctrl)\n");
        src
    }

    #[test]
    fn curve_builds_from_a_list_of_points() {
        let src = peanut_curve_src();
        let store = eval_src(&src).expect("eval ok");
        // p1 + 8 controls + ctrl + crv.
        assert_eq!(store.arena.len(), 11);
        let crv = store.resolve(Guid::from_name("wall.bimr", "crv")).unwrap();
        assert_eq!(crv.refs, vec![Guid::from_name("wall.bimr", "ctrl")]);
        match &crv.entity {
            bimr::Entity::Curve(curve) => {
                assert_eq!(curve.spline().control_points().len(), 8);
                // The spline keeps the control coordinates.
                assert_eq!(
                    (
                        curve.spline().control_points()[0].x,
                        curve.spline().control_points()[0].y
                    ),
                    (1600.0, 0.0)
                );
            }
            other => panic!("expected Curve, got {}", other.type_name()),
        }
    }

    #[test]
    fn divide_over_a_curve_creates_sampled_points() {
        let mut src = peanut_curve_src();
        src.push_str("d1 = Divide(crv, 8)\n");
        let store = eval_src(&src).expect("eval ok");
        // p1 + 8 controls + ctrl + crv + d1 + 8 items.
        assert_eq!(store.arena.len(), 20);
        // n == control count: the samples are the control points, so the
        // first created item sits at the first control.
        let first = store
            .resolve(store.outputs_of(Guid::from_name("wall.bimr", "d1"))[0])
            .unwrap();
        match &first.entity {
            bimr::Entity::Point(p) => assert_eq!((p.x, p.y), (1600.0, 0.0)),
            other => panic!("expected Point, got {}", other.type_name()),
        }
    }

    #[test]
    fn cut_over_a_curve_creates_a_closed_loop() {
        let mut src = peanut_curve_src();
        src.push_str("ct1 = Cut(crv, 8)\n");
        let store = eval_src(&src).expect("eval ok");
        let record = Guid::from_name("wall.bimr", "ct1");
        let items = store.outputs_of(record);
        assert_eq!(items.len(), 8);
        let piece = |i: usize| match &store.resolve(items[i]).unwrap().entity {
            bimr::Entity::Line(l) => *l,
            other => panic!("expected Line, got {}", other.type_name()),
        };
        for i in 0..7 {
            assert_eq!(
                (piece(i).end.x, piece(i).end.y),
                (piece(i + 1).start.x, piece(i + 1).start.y)
            );
        }
        // The last piece closes to the first sample.
        let first = piece(0).start;
        assert_eq!((piece(7).end.x, piece(7).end.y), (first.x, first.y));
    }

    #[test]
    fn the_peanut_pipeline_extrudes() {
        let mut src = peanut_curve_src();
        src.push_str("ct1 = Cut(crv, 24)\nv1 = Vector(0, 0, 3000)\npnt = Extrusion(ct1, v1)\n");
        let store = eval_src(&src).expect("eval ok");
        match &store.arena[store.arena.len() - 1].entity {
            bimr::Entity::Extrusion(ex) => {
                assert_eq!(ex.profile().len(), 24);
                let m = ex.mesh().expect("peanut meshes");
                // 24-piece closed loop → 24 quads.
                assert_eq!(m.points.len(), 96);
                assert_eq!(m.indices.len(), 144);
            }
            other => panic!("expected Extrusion, got {}", other.type_name()),
        }
        // The compact form keeps the parametric chain and round-trips.
        let src2 = crate::serialize::to_bimr(&store);
        assert!(src2.contains("crv = Curve(ctrl)"));
        assert!(src2.contains("pnt = Extrusion(ct1, v1)"));
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn curve_rejections() {
        // A List of Lines is not control points.
        let err = eval_src("p1 = Point(0,0,0)\np2 = Point(1,0,0)\nl1 = Line(p1, p2)\nlst = List(l1)\ncrv = Curve(lst)\n").unwrap_err();
        assert_eq!(
            err,
            Error::ListKind {
                name: "lst".to_string(),
                expected: "Point",
                got: "Line",
            }
        );
        // Fewer than three controls.
        let err = eval_src(
            "p1 = Point(0,0,0)\np2 = Point(1,0,0)\nlst = List(p1, p2)\ncrv = Curve(lst)\n",
        )
        .unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        // Keywords.
        let err = eval_src("p1 = Point(0,0,0)\np2 = Point(1,0,0)\np3 = Point(2,0,0)\nlst = List(p1, p2, p3)\ncrv = Curve(pts=lst)\n").unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
        // Unknown name.
        let err = eval_src("crv = Curve(nope)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    // ── Random: a seeded displacement — different level shapes ──────────────

    #[test]
    fn random_builds_record_and_displaced_points() {
        let src = concat!(
            "p1 = Point(0,0,500)\n",
            "p2 = Point(1,0,500)\n",
            "base = List(p1, p2)\n",
            "r1 = Random(base, seed=42, min=-150, max=150, dims=2)\n",
        );
        let store = eval_src(src).expect("eval ok");
        // p1, p2, base, r1, 2 displaced points.
        assert_eq!(store.arena.len(), 6);
        let record = Guid::from_name("wall.bimr", "r1");
        let r = store.resolve(record).unwrap();
        assert_eq!(r.refs, vec![Guid::from_name("wall.bimr", "base")]);
        assert!(matches!(r.entity, bimr::Entity::Random(_)));
        // The displaced points: named, edged to the record, z preserved.
        let items = store.outputs_of(record);
        assert_eq!(items.len(), 2);
        for (i, &guid) in items.iter().enumerate() {
            let node = store.resolve(guid).unwrap();
            assert_eq!(store.name_of(guid), Some(format!("r1_{i}").as_str()));
            assert_eq!(node.refs, vec![record]);
            match &node.entity {
                bimr::Entity::Point(p) => {
                    assert_eq!(p.z, 500.0);
                    assert!((-150.0..=150.0).contains(&p.x) || (p.x - 1.0).abs() <= 150.0);
                }
                other => panic!("expected Point, got {}", other.type_name()),
            }
        }
        assert_eq!(store.statements.len(), 4);
    }

    #[test]
    fn random_is_deterministic_and_seed_sensitive() {
        let src = |seed: u64| {
            format!(
                concat!(
                    "p1 = Point(0,0,0)\n",
                    "p2 = Point(1,0,0)\n",
                    "base = List(p1, p2)\n",
                    "r1 = Random(base, seed={seed}, min=-150, max=150, dims=2)\n",
                ),
                seed = seed
            )
        };
        let a = eval_src(&src(42)).expect("eval ok");
        let b = eval_src(&src(42)).expect("eval ok");
        let c = eval_src(&src(43)).expect("eval ok");
        let point = |store: &crate::store::Store, guid| match &store.resolve(guid).unwrap().entity {
            bimr::Entity::Point(p) => (p.x, p.y),
            other => panic!("expected Point, got {}", other.type_name()),
        };
        let a0 = point(&a, a.outputs_of(Guid::from_name("wall.bimr", "r1"))[0]);
        let b0 = point(&b, b.outputs_of(Guid::from_name("wall.bimr", "r1"))[0]);
        let c0 = point(&c, c.outputs_of(Guid::from_name("wall.bimr", "r1"))[0]);
        assert_eq!(a0, b0, "same seed must rebuild the same shape");
        assert_ne!(a0, c0, "different seeds must differ");
    }

    #[test]
    fn random_compact_form_round_trips() {
        let src = concat!(
            "p1 = Point(0,0,500)\n",
            "p2 = Point(1,0,500)\n",
            "base = List(p1, p2)\n",
            "r1 = Random(base, seed=42, min=-150, max=150, dims=2)\n",
        );
        let store = eval_src(src).expect("eval ok");
        assert_eq!(
            crate::serialize::to_bimr(&store),
            concat!(
                "p1 = Point(0, 0, 500)\n",
                "p2 = Point(1, 0, 500)\n",
                "base = List(p1, p2)\n",
                "r1 = Random(base, seed=42, min=-150, max=150, dims=2)",
            )
        );
        let src2 = crate::serialize::to_bimr(&store);
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn curve_over_random_takes_the_displaced_points() {
        let src = concat!(
            "p1 = Point(1500,0,0)\n",
            "p2 = Point(0,1000,0)\n",
            "p3 = Point(-1500,0,0)\n",
            "p4 = Point(0,-1000,0)\n",
            "base = List(p1, p2, p3, p4)\n",
            "r1 = Random(base, seed=7, min=-50, max=50, dims=2)\n",
            "crv = Curve(r1)\n",
        );
        let store = eval_src(src).expect("eval ok");
        match &store.arena[store.arena.len() - 1].entity {
            bimr::Entity::Curve(curve) => {
                assert_eq!(curve.spline().control_points().len(), 4);
            }
            other => panic!("expected Curve, got {}", other.type_name()),
        }
    }

    #[test]
    fn random_rejections() {
        // Source must be a List of Points.
        let err =
            eval_src("p1 = Point(0,0,0)\nr1 = Random(p1, seed=1, min=0, max=1)\n").unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p1".to_string(),
                expected: "List",
                got: "Point",
            }
        );
        // Missing keywords.
        let err = eval_src("p1 = Point(0,0,0)\nlst = List(p1)\nr1 = Random(lst, seed=1, min=0)\n")
            .unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
        // Unknown keyword.
        let err = eval_src(
            "p1 = Point(0,0,0)\nlst = List(p1)\nr1 = Random(lst, seed=1, min=0, max=1, count=2)\n",
        )
        .unwrap_err();
        assert!(matches!(err, Error::Unsupported("keyword argument")));
        // Collision.
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "base = List(p1, p2)\n",
            "r1_0 = Point(2,2,2)\n",
            "r1 = Random(base, seed=1, min=0, max=1)\n",
        );
        let err = eval_src(src).unwrap_err();
        assert_eq!(err, Error::NameCollision("r1_0".to_string()));
        // Unknown name.
        let err = eval_src("r1 = Random(nope, seed=1, min=0, max=1)\n").unwrap_err();
        assert_eq!(err, Error::UnknownName("nope".to_string()));
    }

    // ── Slab, Storey, Building — the building containers ─────────────────────

    fn building_ctrl_src() -> String {
        let base = [
            (-1500.0, -300.0),
            (0.0, 1000.0),
            (850.0, 800.0),
            (300.0, 0.0),
            (500.0, -800.0),
            (0.0, -1000.0),
            (-500.0, -800.0),
            (-300.0, 0.0),
        ];
        let mut src = String::new();
        for (i, (x, y)) in base.iter().enumerate() {
            src.push_str(&format!("c{i} = Point({x}, {y}, 0)\n"));
        }
        src.push_str("ctrl = List(c0, c1, c2, c3, c4, c5, c6, c7)\ncrv = Curve(ctrl)\n");
        src
    }

    #[test]
    fn slab_builds_from_a_curve_profile() {
        let src = building_ctrl_src() + "s1 = Slab(crv, 150, 0)\n";
        let store = eval_src(&src).expect("eval ok");
        // p-less: 8 controls + ctrl + crv + s1.
        assert_eq!(store.arena.len(), 11);
        let s = store.resolve(Guid::from_name("wall.bimr", "s1")).unwrap();
        assert_eq!(s.refs, vec![Guid::from_name("wall.bimr", "crv")]);
        match &s.entity {
            bimr::Entity::Slab(slab) => {
                assert_eq!(slab.thickness, 150.0);
                assert_eq!(slab.elevation, 0.0);
                // The curve sampled at 8 points per span (8 controls).
                assert_eq!(slab.profile.points.len(), 64);
            }
            other => panic!("expected Slab, got {}", other.type_name()),
        }
        // The slab is mesh-bearing — a prism with caps.
        assert!(s.entity.mesh().is_some());
    }

    #[test]
    fn slab_compact_form_round_trips() {
        let src = building_ctrl_src() + "s1 = Slab(crv, 150, 0)\n";
        let store = eval_src(&src).expect("eval ok");
        let src2 = crate::serialize::to_bimr(&store);
        assert!(src2.contains("s1 = Slab(crv, 150, 0)"));
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn storey_gathers_a_lifted_result() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "ex1 = Explode(lines)\n",
            "frs = Frame(ex1, 100, 300, 20, 10)\n",
            "st = Storey(3000, frs)\n",
        );
        let store = eval_src(src).expect("eval ok");
        let st = store.resolve(Guid::from_name("wall.bimr", "st")).unwrap();
        assert_eq!(st.refs, vec![Guid::from_name("wall.bimr", "frs")]);
        match &st.entity {
            bimr::Entity::Storey(storey) => {
                assert_eq!(storey.elevation(), 3000.0);
                assert_eq!(storey.entities().len(), 1);
                assert!(matches!(storey.entities()[0], bimr::Entity::Frame(_)));
            }
            other => panic!("expected Storey, got {}", other.type_name()),
        }
        // Containers are not mesh-bearing — no IFCX duplication.
        assert!(st.entity.mesh().is_none());
        // The compact form keeps the container statement.
        assert!(crate::serialize::to_bimr(&store).contains("st = Storey(3000, frs)"));
    }

    #[test]
    fn building_gathers_storeys() {
        let src = concat!(
            "p1 = Point(0,0,0)\n",
            "p2 = Point(1,0,0)\n",
            "l1 = Line(p1, p2)\n",
            "lines = List(l1)\n",
            "ex1 = Explode(lines)\n",
            "frs = Frame(ex1, 100, 300, 20, 10)\n",
            "st0 = Storey(0, frs)\n",
            "st1 = Storey(3000, frs)\n",
            "sts = List(st0, st1)\n",
            "bld = Building(\"b03\", sts)\n",
        );
        let store = eval_src(src).expect("eval ok");
        let bld = store.resolve(Guid::from_name("wall.bimr", "bld")).unwrap();
        assert_eq!(bld.refs, vec![Guid::from_name("wall.bimr", "sts")]);
        match &bld.entity {
            bimr::Entity::Building(b) => {
                assert_eq!(b.name(), "b03");
                assert_eq!(b.storeys().len(), 2);
                assert!(matches!(b.storeys()[0], bimr::Entity::Storey(_)));
            }
            other => panic!("expected Building, got {}", other.type_name()),
        }
        let src2 = crate::serialize::to_bimr(&store);
        assert!(src2.contains("bld = Building(\"b03\", sts)"));
        let program2 = parser::parse(&src2).expect("round-trip parses");
        let store2 = eval_program(&program2, "wall.bimr").expect("round-trip evals");
        assert_eq!(crate::serialize::to_bimr(&store2), src2);
    }

    #[test]
    fn container_rejections() {
        // Storey needs a List.
        let err = eval_src("p1 = Point(0,0,0)\nst = Storey(0, p1)\n").unwrap_err();
        assert_eq!(
            err,
            Error::WrongNature {
                name: "p1".to_string(),
                expected: "List",
                got: "Point",
            }
        );
        // Building needs a List of Storeys.
        let err = eval_src("p1 = Point(0,0,0)\nlst = List(p1)\nbld = Building(\"b\", lst)\n")
            .unwrap_err();
        assert_eq!(
            err,
            Error::ListKind {
                name: "lst".to_string(),
                expected: "Storey",
                got: "Point",
            }
        );
        // Slab arity.
        let err = eval_src(
            "p1 = Point(0,0,0)\np2 = Point(1,0,0)\nlst = List(p1, p2)\ns1 = Slab(lst, 150)\n",
        )
        .unwrap_err();
        assert!(matches!(err, Error::Unsupported("arity")));
    }
}