alice-lol 0.4.2

//! ランタイム LOL パーサー
//!
//! LLM が生成した LOL テキストを `&str` → [`SdfNode`] に変換する。
//! `proc_macro` 版と同等の 76 構文をサポートするが、値は `f32` リテラルのみ
//! （Rust 式キャプチャは不要 — LLM 出力は数値定数のみ）。
//!
//! ```
//! use alice_lol::runtime_parser::parse_lol;
//!
//! let node = parse_lol("smooth_union(0.3, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
//! let dist = alice_lol::eval(&node, glam::Vec3::ZERO);
//! ```
#![allow(
    clippy::disallowed_macros,
    reason = "raw-helper: this module calls the platform f32/f64 max/min via crate::raw_minmax::raw_minmax_here!() at sites proven safe by nonzero-const:/both-abs:/int-cast: reasoning, see scripts/raw_minmax_manifest.toml"
)]

crate::raw_minmax::raw_minmax_here!(max_f32);

use crate::audit_law::{sorted_values, AuditLaw, Clause};
use crate::intent::{HandSide, IntentNode, NodeId, Program, ProgramBuilder};
use crate::SdfNode;
use glam::{Vec2, Vec3};
use std::sync::Arc;

/// LOL 数値引数 (`f32`) → 個数 / index / seed 用 `u32`
///
/// Lexer は数値を `f32` で保持する Rust `as` の saturating 挙動をそのまま採用
/// (小数部切捨て、負 → 0、NaN → 0、2^32 超 → `u32::MAX`) 呼出側で `round()` /
/// `max(n)` を済ませてから渡す 範囲外を parse error にしたい用途は
/// `Parser::expect_uint` を使う 56 箇所に散っていた `as u32` の単一 audit 点
#[inline]
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
const fn lol_u32(v: f32) -> u32 {
    v as u32
}

/// stdlib 生成器に渡す個数 (rows / cols / count) の上限
///
/// 生成器の線形 fold は balanced fold に直してあり、この個数でも木の深さは log2 で済む
/// 既存の実用範囲 (Gridfinity の数 unit、整理トレイの数十穴、綿棒の本数 80) を大きく超える
pub const MAX_STDLIB_COUNT: f32 = 1024.0;

/// SKADIS 板の一辺の上限 \[mm\] (標準は 300、穴は (size / 40)² 個)
pub const MAX_SKADIS_PANEL_MM: f32 = 2000.0;

/// `smooth_union` を 1 個ずつ重ねる生成器 (`clamp_rack`) の個数の上限
///
/// smooth union は結合則が成り立たず balanced fold にできないので、木の深さ (個数の 2 倍) を
/// debug build のテスト thread (2 MiB) でも安全な範囲に収める
pub const MAX_STDLIB_SMOOTH_FOLD_COUNT: f32 = 24.0;

/// rows × cols の格子に置ける要素数の上限
pub const MAX_STDLIB_GRID_CELLS: f32 = 4096.0;

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// エラー型
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

/// LOL パースエラー
#[derive(Debug, Clone)]
pub struct ParseError {
    pub message: String,
    pub position: usize,
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "LOL parse error at pos {}: {}",
            self.position, self.message
        )
    }
}

/// `parse_6f_child` の戻り値型エイリアス
type SixFloatsChild = (f32, f32, f32, f32, f32, f32, SdfNode);

impl std::error::Error for ParseError {}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// トークナイザー
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

#[derive(Debug, Clone, PartialEq)]
enum Token {
    Ident(String),
    Number(f32),
    LParen,
    RParen,
    Comma,
}

struct Lexer<'a> {
    input: &'a [u8],
    pos: usize,
}

impl<'a> Lexer<'a> {
    const fn new(input: &'a str) -> Self {
        Self {
            input: input.as_bytes(),
            pos: 0,
        }
    }

    const fn skip_whitespace(&mut self) {
        while self.pos < self.input.len() {
            if self.input[self.pos].is_ascii_whitespace() {
                self.pos += 1;
            } else if self.pos + 1 < self.input.len()
                && self.input[self.pos] == b'/'
                && self.input[self.pos + 1] == b'/'
            {
                // 行コメント: 行末までスキップ
                while self.pos < self.input.len() && self.input[self.pos] != b'\n' {
                    self.pos += 1;
                }
            } else {
                break;
            }
        }
    }

    fn next_token(&mut self) -> Result<Option<Token>, ParseError> {
        self.skip_whitespace();
        if self.pos >= self.input.len() {
            return Ok(None);
        }
        let ch = self.input[self.pos];
        match ch {
            b'(' => {
                self.pos += 1;
                Ok(Some(Token::LParen))
            }
            b')' => {
                self.pos += 1;
                Ok(Some(Token::RParen))
            }
            b',' => {
                self.pos += 1;
                Ok(Some(Token::Comma))
            }
            b'-' | b'0'..=b'9' => self.read_number(),
            b'a'..=b'z' | b'A'..=b'Z' | b'_' => self.read_ident(),
            _ => Err(ParseError {
                message: format!("unexpected character: '{}'", ch as char),
                position: self.pos,
            }),
        }
    }

    fn read_number(&mut self) -> Result<Option<Token>, ParseError> {
        let start = self.pos;
        if self.pos < self.input.len() && self.input[self.pos] == b'-' {
            self.pos += 1;
        }
        while self.pos < self.input.len() && self.input[self.pos].is_ascii_digit() {
            self.pos += 1;
        }
        if self.pos < self.input.len() && self.input[self.pos] == b'.' {
            self.pos += 1;
            while self.pos < self.input.len() && self.input[self.pos].is_ascii_digit() {
                self.pos += 1;
            }
        }
        // 科学的記数法 (e.g. 1e-3)
        if self.pos < self.input.len()
            && (self.input[self.pos] == b'e' || self.input[self.pos] == b'E')
        {
            self.pos += 1;
            if self.pos < self.input.len()
                && (self.input[self.pos] == b'+' || self.input[self.pos] == b'-')
            {
                self.pos += 1;
            }
            while self.pos < self.input.len() && self.input[self.pos].is_ascii_digit() {
                self.pos += 1;
            }
        }
        let s = std::str::from_utf8(&self.input[start..self.pos]).map_err(|_| ParseError {
            message: "invalid UTF-8 in number".into(),
            position: start,
        })?;
        let v: f32 = s.parse().map_err(|_| ParseError {
            message: format!("invalid number: '{s}'"),
            position: start,
        })?;
        // a literal past the f32 range reads as ±inf: refuse it, as `law_number` does
        // (emit never writes inf, so an accepted inf could not be written back)
        if !v.is_finite() {
            return Err(ParseError {
                message: format!("number out of range: '{s}'"),
                position: start,
            });
        }
        Ok(Some(Token::Number(v)))
    }

    fn read_ident(&mut self) -> Result<Option<Token>, ParseError> {
        let start = self.pos;
        while self.pos < self.input.len()
            && (self.input[self.pos].is_ascii_alphanumeric() || self.input[self.pos] == b'_')
        {
            self.pos += 1;
        }
        let s = std::str::from_utf8(&self.input[start..self.pos]).map_err(|_| ParseError {
            message: "invalid UTF-8 in identifier".into(),
            position: start,
        })?;
        Ok(Some(Token::Ident(s.to_owned())))
    }

    const fn position(&self) -> usize {
        self.pos
    }
}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// パーサー
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

struct Parser<'a> {
    lexer: Lexer<'a>,
    peeked: Option<Token>,
}

impl<'a> Parser<'a> {
    const fn new(input: &'a str) -> Self {
        Self {
            lexer: Lexer::new(input),
            peeked: None,
        }
    }

    fn peek(&mut self) -> Result<Option<&Token>, ParseError> {
        if self.peeked.is_none() {
            self.peeked = self.lexer.next_token()?;
        }
        Ok(self.peeked.as_ref())
    }

    fn next(&mut self) -> Result<Option<Token>, ParseError> {
        if let Some(t) = self.peeked.take() {
            Ok(Some(t))
        } else {
            self.lexer.next_token()
        }
    }

    fn expect_number(&mut self) -> Result<f32, ParseError> {
        match self.next()? {
            Some(Token::Number(v)) => Ok(v),
            other => Err(ParseError {
                message: format!("expected number, got {other:?}"),
                position: self.lexer.position(),
            }),
        }
    }

    fn expect_comma(&mut self) -> Result<(), ParseError> {
        match self.next()? {
            Some(Token::Comma) => Ok(()),
            other => Err(ParseError {
                message: format!("expected comma, got {other:?}"),
                position: self.lexer.position(),
            }),
        }
    }

    fn expect_rparen(&mut self) -> Result<(), ParseError> {
        match self.next()? {
            Some(Token::RParen) => Ok(()),
            other => Err(ParseError {
                message: format!("expected ')', got {other:?}"),
                position: self.lexer.position(),
            }),
        }
    }

    fn at_rparen(&mut self) -> Result<bool, ParseError> {
        Ok(matches!(self.peek()?, Some(Token::RParen)))
    }

    /// f32 値 1 個
    fn parse_1f(&mut self) -> Result<f32, ParseError> {
        let v = self.expect_number()?;
        self.expect_rparen()?;
        Ok(v)
    }

    /// f32 値 2 個
    fn parse_2f(&mut self) -> Result<(f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b))
    }

    /// `alice_sdf` の TPMS 9 primitive の `(scale, thickness)` 引数、この
    /// crate が TPMS node を組み立てる**どの入口からでも**共通に適用する
    /// 契約は [`crate::limits::checked_tpms_fields`] (その doc comment に
    /// 理由を集約、`lattice_infill`/`diamond_infill`/`schwarz_infill` も
    /// 同じ関数を呼ぶ、別構文でも同じ node 型である以上同じ制約が要る)
    fn parse_tpms_fields(&mut self) -> Result<(f32, f32), ParseError> {
        let (scale, thickness) = self.parse_2f()?;
        self.validate_tpms_fields(scale, thickness)?;
        Ok((scale, thickness))
    }

    /// [`Self::parse_tpms_fields`] の検証部分だけ ([`crate::limits::checked_tpms_fields`]
    /// を呼んで [`crate::limits::SpecError`] を [`Self::spec_error`] で `ParseError` に写すだけ)
    fn validate_tpms_fields(&self, scale: f32, thickness: f32) -> Result<(), ParseError> {
        crate::limits::checked_tpms_fields(scale, thickness)
            .map(|_| ())
            .map_err(|e| self.spec_error(e))
    }

    /// SKADIS panel の variadic arg 解析 0/1/2/3-arg を許容し不足分は
    /// SKADIS canonical default (300mm 板 / 5mm 厚 / 5mm `corner_r`) で補完
    /// LLM 出力の arity ズレ (「SKADISパネル 10✖10」→ `skadis_panel(10, 10)` 等)
    /// を parse fail させないための forgiving 動作 (2026-09-04 追加)
    fn parse_skadis_panel_args(&mut self) -> Result<(f32, f32, f32), ParseError> {
        const DEFAULT_SIZE: f32 = 300.0;
        const DEFAULT_THICKNESS: f32 = 5.0;
        const DEFAULT_CORNER_R: f32 = 5.0;

        if self.at_rparen()? {
            self.expect_rparen()?;
            return Ok((DEFAULT_SIZE, DEFAULT_THICKNESS, DEFAULT_CORNER_R));
        }
        let size = self.expect_number()?;
        if self.at_rparen()? {
            self.expect_rparen()?;
            return Ok((size, DEFAULT_THICKNESS, DEFAULT_CORNER_R));
        }
        self.expect_comma()?;
        let thickness = self.expect_number()?;
        if self.at_rparen()? {
            self.expect_rparen()?;
            return Ok((size, thickness, DEFAULT_CORNER_R));
        }
        self.expect_comma()?;
        let corner_r = self.expect_number()?;
        self.expect_rparen()?;
        Ok((size, thickness, corner_r))
    }

    /// f32 値 3 個
    /// 呼び径 \[mm\] → 規格サイズ (⚠️ 境界で弾く)
    ///
    /// `MetricSize::from_f32_snap` は `Self` を返すので**判定できない入力でも
    /// 何かを返すしかない** LLM が生成した LOL テキストの値がそのまま入る経路
    /// なので、ここで `NaN` / `±Inf` を parse error にする
    /// (旧実装は非有限で既定の M4 を silent に返しており、⚠️ **不正な入力から
    /// 黙って M4 のねじ穴が出力される**状態だった、2026-09-30 実測)
    fn metric_size(
        &self,
        m_size: f32,
    ) -> Result<crate::stdlib::hardsurface::fastener::MetricSize, ParseError> {
        crate::stdlib::hardsurface::fastener::MetricSize::try_from_f32(m_size).ok_or_else(|| {
            ParseError {
                message: format!("ねじ呼び径が有限の数値でない: {m_size}"),
                position: self.lexer.pos,
            }
        })
    }

    fn parse_3f(&mut self) -> Result<(f32, f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b, c))
    }

    /// f32 値 4 個
    fn parse_4f(&mut self) -> Result<(f32, f32, f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b, c, d))
    }

    /// f32 値 7 個 (Phase B.1.b `gridfinity_bin_ex` 用)
    #[allow(clippy::type_complexity)]
    fn parse_7f(&mut self) -> Result<(f32, f32, f32, f32, f32, f32, f32), ParseError> {
        let v0 = self.expect_number()?;
        self.expect_comma()?;
        let v1 = self.expect_number()?;
        self.expect_comma()?;
        let v2 = self.expect_number()?;
        self.expect_comma()?;
        let v3 = self.expect_number()?;
        self.expect_comma()?;
        let v4 = self.expect_number()?;
        self.expect_comma()?;
        let v5 = self.expect_number()?;
        self.expect_comma()?;
        let v6 = self.expect_number()?;
        self.expect_rparen()?;
        Ok((v0, v1, v2, v3, v4, v5, v6))
    }

    /// f32 + 子ノード 1 個
    fn parse_1f_child(&mut self) -> Result<(f32, SdfNode), ParseError> {
        let v = self.expect_number()?;
        self.expect_comma()?;
        let child = self.parse_expr()?;
        self.expect_rparen()?;
        Ok((v, child))
    }

    /// f32 3 個 + 子ノード 1 個
    fn parse_3f_child(&mut self) -> Result<(f32, f32, f32, SdfNode), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let child = self.parse_expr()?;
        self.expect_rparen()?;
        Ok((a, b, c, child))
    }

    /// f32 4 個 + 子ノード 1 個 (`rotate_q`)
    #[allow(clippy::type_complexity)]
    fn parse_4f_child(&mut self) -> Result<(f32, f32, f32, f32, SdfNode), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_comma()?;
        let child = self.parse_expr()?;
        self.expect_rparen()?;
        Ok((a, b, c, d, child))
    }

    /// 子ノードのみ
    fn parse_child_only(&mut self) -> Result<SdfNode, ParseError> {
        let child = self.parse_expr()?;
        self.expect_rparen()?;
        Ok(child)
    }

    /// k + 2個以上の子ノード
    fn parse_k_children(&mut self) -> Result<(f32, Vec<SdfNode>), ParseError> {
        let k = self.expect_number()?;
        self.expect_comma()?;
        let children = self.parse_children()?;
        Ok((k, children))
    }

    /// f32 2 個 + 2 個以上の子ノード
    fn parse_2f_children(&mut self) -> Result<(f32, f32, Vec<SdfNode>), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let children = self.parse_children()?;
        Ok((a, b, children))
    }

    /// k + 2 子ノード（subtract 系）
    fn parse_1f_ab(&mut self) -> Result<(f32, SdfNode, SdfNode), ParseError> {
        let k = self.expect_number()?;
        self.expect_comma()?;
        let a = self.parse_expr()?;
        self.expect_comma()?;
        let b = self.parse_expr()?;
        self.expect_rparen()?;
        Ok((k, a, b))
    }

    /// f32 2 個 + 2 子ノード
    fn parse_2f_ab(&mut self) -> Result<(f32, f32, SdfNode, SdfNode), ParseError> {
        let v1 = self.expect_number()?;
        self.expect_comma()?;
        let v2 = self.expect_number()?;
        self.expect_comma()?;
        let a = self.parse_expr()?;
        self.expect_comma()?;
        let b = self.parse_expr()?;
        self.expect_rparen()?;
        Ok((v1, v2, a, b))
    }

    /// `f32` 6 個 + 子ノード 1 個 (`repeat_finite`)
    #[allow(clippy::many_single_char_names)]
    fn parse_6f_child(&mut self) -> Result<SixFloatsChild, ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_comma()?;
        let e = self.expect_number()?;
        self.expect_comma()?;
        let f = self.expect_number()?;
        self.expect_comma()?;
        let child = self.parse_expr()?;
        self.expect_rparen()?;
        Ok((a, b, c, d, e, f, child))
    }

    /// 5 floats
    #[allow(clippy::many_single_char_names)]
    fn parse_5f(&mut self) -> Result<(f32, f32, f32, f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_comma()?;
        let e = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b, c, d, e))
    }

    /// 6 floats (no child)
    #[allow(clippy::many_single_char_names)]
    fn parse_6f(&mut self) -> Result<(f32, f32, f32, f32, f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_comma()?;
        let e = self.expect_number()?;
        self.expect_comma()?;
        let f = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b, c, d, e, f))
    }

    /// 9 floats
    #[allow(clippy::many_single_char_names, clippy::type_complexity)]
    fn parse_9f(&mut self) -> Result<(f32, f32, f32, f32, f32, f32, f32, f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_comma()?;
        let e = self.expect_number()?;
        self.expect_comma()?;
        let f = self.expect_number()?;
        self.expect_comma()?;
        let g = self.expect_number()?;
        self.expect_comma()?;
        let h = self.expect_number()?;
        self.expect_comma()?;
        let i = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b, c, d, e, f, g, h, i))
    }

    /// 10 floats
    #[allow(clippy::many_single_char_names, clippy::type_complexity)]
    fn parse_10f(
        &mut self,
    ) -> Result<(f32, f32, f32, f32, f32, f32, f32, f32, f32, f32), ParseError> {
        let a = self.expect_number()?;
        self.expect_comma()?;
        let b = self.expect_number()?;
        self.expect_comma()?;
        let c = self.expect_number()?;
        self.expect_comma()?;
        let d = self.expect_number()?;
        self.expect_comma()?;
        let e = self.expect_number()?;
        self.expect_comma()?;
        let f = self.expect_number()?;
        self.expect_comma()?;
        let g = self.expect_number()?;
        self.expect_comma()?;
        let h = self.expect_number()?;
        self.expect_comma()?;
        let i = self.expect_number()?;
        self.expect_comma()?;
        let j = self.expect_number()?;
        self.expect_rparen()?;
        Ok((a, b, c, d, e, f, g, h, i, j))
    }

    /// 2 個以上の子ノード（カンマ区切り、`)` まで）
    fn parse_children(&mut self) -> Result<Vec<SdfNode>, ParseError> {
        let mut children = vec![self.parse_expr()?];
        while !self.at_rparen()? {
            self.expect_comma()?;
            if self.at_rparen()? {
                break;
            }
            children.push(self.parse_expr()?);
        }
        self.expect_rparen()?;
        if children.len() < 2 {
            return Err(ParseError {
                message: "operations require at least 2 children".into(),
                position: self.lexer.position(),
            });
        }
        Ok(children)
    }

    /// N-ary 子ノードを左畳み込みで binary [`SdfNode`] に変換
    fn fold_left<F>(children: Vec<SdfNode>, f: F) -> SdfNode
    where
        F: Fn(SdfNode, SdfNode) -> SdfNode,
    {
        let mut iter = children.into_iter();
        let first = iter.next().expect("at least 2 children");
        iter.fold(first, &f)
    }

    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    // メイン式パーサー
    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

    fn parse_expr(&mut self) -> Result<SdfNode, ParseError> {
        // 本体 (`parse_expr_inner`) は 250+ arm の match で frame が大きく、深い
        // tree (stdlib product の subtract 2,400 連鎖 = 正当な LOL) で再帰が
        // 8 MB stack を使い切る 残りが red zone (4 MB、debug build の
        // parse_expr_inner の frame より十分大きい値) を切ったら 32 MB 単位で
        // heap 上に stack を伸ばして続行する (stacker、rustc と同じ手法)
        stacker::maybe_grow(4 * 1024 * 1024, 32 * 1024 * 1024, || {
            self.parse_expr_inner()
        })
    }

    #[allow(clippy::too_many_lines)]
    fn parse_expr_inner(&mut self) -> Result<SdfNode, ParseError> {
        // `field Name { ... }` ラッパーをスキップ
        let name = match self.next()? {
            Some(Token::Ident(s)) => s,
            other => {
                return Err(ParseError {
                    message: format!("expected function name, got {other:?}"),
                    position: self.lexer.position(),
                })
            }
        };

        if name == "field" {
            // field Name { body } — 名前を読み飛ばして中身をパース
            // ランタイムでは field ラッパーは不要だが互換性のため受け付ける
            let _field_name = match self.next()? {
                Some(Token::Ident(s)) => s,
                other => {
                    return Err(ParseError {
                        message: format!("expected field name, got {other:?}"),
                        position: self.lexer.position(),
                    })
                }
            };
            // '{' は Ident/Number 扱いされないので特殊処理不要
            // field は proc_macro 専用。ランタイムではスキップして中身を直接パース
            return self.parse_expr();
        }

        // '(' を期待
        match self.next()? {
            Some(Token::LParen) => {}
            other => {
                return Err(ParseError {
                    message: format!("expected '(' after '{name}', got {other:?}"),
                    position: self.lexer.position(),
                })
            }
        }

        match name.as_str() {
            // ── プリミティブ (27) ──
            "sphere" => {
                let r = self.parse_1f()?;
                Ok(SdfNode::Sphere { radius: r })
            }
            "box3d" => {
                let (hx, hy, hz) = self.parse_3f()?;
                Ok(SdfNode::Box3d {
                    half_extents: Vec3::new(hx, hy, hz),
                })
            }
            "rounded_box" => {
                let (hx, hy, hz, r) = self.parse_4f()?;
                Ok(SdfNode::RoundedBox {
                    half_extents: Vec3::new(hx, hy, hz),
                    round_radius: r,
                })
            }
            "cylinder" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::Cylinder {
                    radius: r,
                    half_height: h,
                })
            }
            "torus" => {
                let (major, minor) = self.parse_2f()?;
                Ok(SdfNode::Torus {
                    major_radius: major,
                    minor_radius: minor,
                })
            }
            "cone" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::Cone {
                    radius: r,
                    half_height: h,
                })
            }
            "capsule" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::Capsule {
                    point_a: Vec3::new(0.0, -h, 0.0),
                    point_b: Vec3::new(0.0, h, 0.0),
                    radius: r,
                })
            }
            // capsule_ab(ax, ay, az, bx, by, bz, r) — 任意 2 点 capsule (2026-09-14 追加)
            // stdlib (SKADIS hook 等) が生成する非 Y 対称 Capsule を `emit::to_lol` で
            // 書き戻すための text 構文 `capsule(r, h)` は Y 対称の短縮形のまま
            "capsule_ab" => {
                let (ax, ay, az, bx, by, bz, r) = self.parse_7f()?;
                Ok(SdfNode::Capsule {
                    point_a: Vec3::new(ax, ay, az),
                    point_b: Vec3::new(bx, by, bz),
                    radius: r,
                })
            }
            "ellipsoid" => {
                let (rx, ry, rz) = self.parse_3f()?;
                Ok(SdfNode::Ellipsoid {
                    radii: Vec3::new(rx, ry, rz),
                })
            }
            "plane" => {
                let (nx, ny, nz, d) = self.parse_4f()?;
                Ok(SdfNode::Plane {
                    normal: Vec3::new(nx, ny, nz),
                    distance: d,
                })
            }
            "octahedron" => {
                let s = self.parse_1f()?;
                Ok(SdfNode::Octahedron { size: s })
            }
            "rounded_cone" => {
                let (r1, r2, h) = self.parse_3f()?;
                Ok(SdfNode::RoundedCone {
                    r1,
                    r2,
                    half_height: h,
                })
            }
            "pyramid" => {
                let h = self.parse_1f()?;
                Ok(SdfNode::Pyramid { half_height: h })
            }
            "hex_prism" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::HexPrism {
                    hex_radius: r,
                    half_height: h,
                })
            }
            "link" => {
                let (l, r1, r2) = self.parse_3f()?;
                Ok(SdfNode::Link {
                    half_length: l,
                    r1,
                    r2,
                })
            }
            "capped_cone" => {
                let (h, r1, r2) = self.parse_3f()?;
                Ok(SdfNode::CappedCone {
                    half_height: h,
                    r1,
                    r2,
                })
            }
            "capped_torus" => {
                let (maj, min, ang) = self.parse_3f()?;
                Ok(SdfNode::CappedTorus {
                    major_radius: maj,
                    minor_radius: min,
                    cap_angle: ang,
                })
            }
            "rounded_cylinder" => {
                let (r, rr, h) = self.parse_3f()?;
                Ok(SdfNode::RoundedCylinder {
                    radius: r,
                    round_radius: rr,
                    half_height: h,
                })
            }
            "tube" => {
                let (or, t, h) = self.parse_3f()?;
                Ok(SdfNode::Tube {
                    outer_radius: or,
                    thickness: t,
                    half_height: h,
                })
            }
            "barrel" => {
                let (r, h, b) = self.parse_3f()?;
                Ok(SdfNode::Barrel {
                    radius: r,
                    half_height: h,
                    bulge: b,
                })
            }
            "heart" => {
                let s = self.parse_1f()?;
                Ok(SdfNode::Heart { size: s })
            }
            "egg" => {
                let (ra, rb) = self.parse_2f()?;
                Ok(SdfNode::Egg { ra, rb })
            }
            "helix" => {
                let (mr, mi, p, h) = self.parse_4f()?;
                Ok(SdfNode::Helix {
                    major_r: mr,
                    minor_r: mi,
                    pitch: p,
                    half_height: h,
                })
            }
            "tetrahedron" => {
                let s = self.parse_1f()?;
                Ok(SdfNode::Tetrahedron { size: s })
            }
            "box_frame" => {
                let (hx, hy, hz, e) = self.parse_4f()?;
                Ok(SdfNode::BoxFrame {
                    half_extents: Vec3::new(hx, hy, hz),
                    edge: e,
                })
            }
            "diamond" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::Diamond {
                    radius: r,
                    half_height: h,
                })
            }
            "star_polygon" => {
                let (r, n, m, h) = self.parse_4f()?;
                Ok(SdfNode::StarPolygon {
                    radius: r,
                    n_points: n,
                    m,
                    half_height: h,
                })
            }
            "cross_shape" => {
                let (l, t, r, h) = self.parse_4f()?;
                Ok(SdfNode::CrossShape {
                    length: l,
                    thickness: t,
                    round_radius: r,
                    half_height: h,
                })
            }

            // ── オペレーション (23) ──
            "union" => {
                let children = self.parse_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::Union {
                    a: Arc::new(a),
                    b: Arc::new(b),
                }))
            }
            "smooth_union" => {
                let (k, children) = self.parse_k_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::SmoothUnion {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    k,
                }))
            }
            "intersection" => {
                let children = self.parse_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::Intersection {
                    a: Arc::new(a),
                    b: Arc::new(b),
                }))
            }
            "smooth_intersection" => {
                let (k, children) = self.parse_k_children()?;
                Ok(Self::fold_left(children, |a, b| {
                    SdfNode::SmoothIntersection {
                        a: Arc::new(a),
                        b: Arc::new(b),
                        k,
                    }
                }))
            }
            "subtract" => {
                let a = self.parse_expr()?;
                self.expect_comma()?;
                let b = self.parse_expr()?;
                self.expect_rparen()?;
                Ok(SdfNode::Subtraction {
                    a: Arc::new(a),
                    b: Arc::new(b),
                })
            }
            "smooth_subtract" => {
                let (k, a, b) = self.parse_1f_ab()?;
                Ok(SdfNode::SmoothSubtraction {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    k,
                })
            }
            "chamfer_union" => {
                let (r, children) = self.parse_k_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::ChamferUnion {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                }))
            }
            "chamfer_intersection" => {
                let (r, children) = self.parse_k_children()?;
                Ok(Self::fold_left(children, |a, b| {
                    SdfNode::ChamferIntersection {
                        a: Arc::new(a),
                        b: Arc::new(b),
                        r,
                    }
                }))
            }
            "chamfer_subtraction" => {
                let (r, a, b) = self.parse_1f_ab()?;
                Ok(SdfNode::ChamferSubtraction {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                })
            }
            "stairs_union" => {
                let (r, n, children) = self.parse_2f_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::StairsUnion {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                    n,
                }))
            }
            "stairs_intersection" => {
                let (r, n, children) = self.parse_2f_children()?;
                Ok(Self::fold_left(children, |a, b| {
                    SdfNode::StairsIntersection {
                        a: Arc::new(a),
                        b: Arc::new(b),
                        r,
                        n,
                    }
                }))
            }
            "stairs_subtraction" => {
                let (r, n, a, b) = self.parse_2f_ab()?;
                Ok(SdfNode::StairsSubtraction {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                    n,
                })
            }
            "xor" => {
                let a = self.parse_expr()?;
                self.expect_comma()?;
                let b = self.parse_expr()?;
                self.expect_rparen()?;
                Ok(SdfNode::XOR {
                    a: Arc::new(a),
                    b: Arc::new(b),
                })
            }
            "pipe" => {
                let (r, a, b) = self.parse_1f_ab()?;
                Ok(SdfNode::Pipe {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                })
            }
            "engrave" => {
                let (r, a, b) = self.parse_1f_ab()?;
                Ok(SdfNode::Engrave {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                })
            }
            "groove" => {
                let (ra, rb, a, b) = self.parse_2f_ab()?;
                Ok(SdfNode::Groove {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    ra,
                    rb,
                })
            }
            "tongue" => {
                let (ra, rb, a, b) = self.parse_2f_ab()?;
                Ok(SdfNode::Tongue {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    ra,
                    rb,
                })
            }
            "columns_union" => {
                let (r, n, children) = self.parse_2f_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::ColumnsUnion {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                    n,
                }))
            }
            "columns_intersection" => {
                let (r, n, children) = self.parse_2f_children()?;
                Ok(Self::fold_left(children, |a, b| {
                    SdfNode::ColumnsIntersection {
                        a: Arc::new(a),
                        b: Arc::new(b),
                        r,
                        n,
                    }
                }))
            }
            "columns_subtraction" => {
                let (r, n, a, b) = self.parse_2f_ab()?;
                Ok(SdfNode::ColumnsSubtraction {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    r,
                    n,
                })
            }
            "exp_smooth_union" => {
                let (k, children) = self.parse_k_children()?;
                Ok(Self::fold_left(children, |a, b| SdfNode::ExpSmoothUnion {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    k,
                }))
            }
            "exp_smooth_intersection" => {
                let (k, children) = self.parse_k_children()?;
                Ok(Self::fold_left(children, |a, b| {
                    SdfNode::ExpSmoothIntersection {
                        a: Arc::new(a),
                        b: Arc::new(b),
                        k,
                    }
                }))
            }
            "exp_smooth_subtraction" => {
                let (k, a, b) = self.parse_1f_ab()?;
                Ok(SdfNode::ExpSmoothSubtraction {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    k,
                })
            }

            // ── トランスフォーム (4) ──
            "translate" => {
                let (x, y, z, child) = self.parse_3f_child()?;
                Ok(SdfNode::Translate {
                    child: Arc::new(child),
                    offset: Vec3::new(x, y, z),
                })
            }
            "rotate" => {
                let (rx, ry, rz, child) = self.parse_3f_child()?;
                // huge degree literals reduced before to_radians(): sin/cos has no
                // accuracy guarantee at that magnitude (crate::angle module doc).
                // quat_from_euler_xyz (not Quat::from_euler): deterministic across
                // architectures, see its own doc comment.
                Ok(SdfNode::Rotate {
                    child: Arc::new(child),
                    rotation: crate::angle::quat_from_euler_xyz(
                        crate::angle::canon_angle_deg(rx).to_radians(),
                        crate::angle::canon_angle_deg(ry).to_radians(),
                        crate::angle::canon_angle_deg(rz).to_radians(),
                    ),
                })
            }
            "rotate_q" => {
                let (x, y, z, w, child) = self.parse_4f_child()?;
                let rotation = crate::limits::checked_rotation_quat(x, y, z, w)
                    .map_err(|e| self.spec_error(e))?;
                Ok(SdfNode::Rotate {
                    child: Arc::new(child),
                    rotation,
                })
            }
            "scale" => {
                let (f, child) = self.parse_1f_child()?;
                Ok(SdfNode::Scale {
                    child: Arc::new(child),
                    factor: f,
                })
            }
            "scale_non_uniform" => {
                let (sx, sy, sz, child) = self.parse_3f_child()?;
                Ok(SdfNode::ScaleNonUniform {
                    child: Arc::new(child),
                    factors: Vec3::new(sx, sy, sz),
                })
            }

            // ── モディファイア (19) ──
            "round" => {
                let (r, child) = self.parse_1f_child()?;
                Ok(SdfNode::Round {
                    child: Arc::new(child),
                    radius: r,
                })
            }
            "onion" => {
                let (t, child) = self.parse_1f_child()?;
                Ok(SdfNode::Onion {
                    child: Arc::new(child),
                    thickness: t,
                })
            }
            "twist" => {
                let (s, child) = self.parse_1f_child()?;
                Ok(SdfNode::Twist {
                    child: Arc::new(child),
                    strength: s,
                })
            }
            "bend" => {
                let (c, child) = self.parse_1f_child()?;
                Ok(SdfNode::Bend {
                    child: Arc::new(child),
                    curvature: c,
                })
            }
            "mirror" => {
                let (ax, ay, az, child) = self.parse_3f_child()?;
                Ok(SdfNode::Mirror {
                    child: Arc::new(child),
                    axes: Vec3::new(ax, ay, az),
                })
            }
            "repeat" => {
                let (sx, sy, sz, child) = self.parse_3f_child()?;
                Ok(SdfNode::RepeatInfinite {
                    child: Arc::new(child),
                    spacing: Vec3::new(sx, sy, sz),
                })
            }
            "elongate" => {
                let (ax, ay, az, child) = self.parse_3f_child()?;
                Ok(SdfNode::Elongate {
                    child: Arc::new(child),
                    amount: Vec3::new(ax, ay, az),
                })
            }
            "revolution" => {
                let (off, child) = self.parse_1f_child()?;
                Ok(SdfNode::Revolution {
                    child: Arc::new(child),
                    offset: off,
                })
            }
            "extrude" => {
                let (h, child) = self.parse_1f_child()?;
                Ok(SdfNode::Extrude {
                    child: Arc::new(child),
                    half_height: h,
                })
            }
            "taper" => {
                let (f, child) = self.parse_1f_child()?;
                // `SdfNode::taper` computes the child's reach (alice-sdf 2.0 cone bound)
                Ok(child.taper(f))
            }
            "displacement" => {
                let (s, child) = self.parse_1f_child()?;
                Ok(SdfNode::Displacement {
                    child: Arc::new(child),
                    strength: s,
                })
            }
            "polar_repeat" => {
                let (c, child) = self.parse_1f_child()?;
                Ok(SdfNode::PolarRepeat {
                    child: Arc::new(child),
                    count: lol_u32(c),
                })
            }
            "shear" => {
                let (xy, xz, yz, child) = self.parse_3f_child()?;
                Ok(SdfNode::Shear {
                    child: Arc::new(child),
                    shear: Vec3::new(xy, xz, yz),
                })
            }
            "noise" => {
                let (amp, freq, seed, child) = self.parse_3f_child()?;
                Ok(SdfNode::Noise {
                    child: Arc::new(child),
                    amplitude: amp,
                    frequency: freq,
                    seed: lol_u32(seed),
                })
            }
            "repeat_finite" => {
                let (cx, cy, cz, sx, sy, sz, child) = self.parse_6f_child()?;
                Ok(SdfNode::RepeatFinite {
                    child: Arc::new(child),
                    count: [lol_u32(cx), lol_u32(cy), lol_u32(cz)],
                    spacing: Vec3::new(sx, sy, sz),
                })
            }
            "octant_mirror" => {
                let child = self.parse_child_only()?;
                Ok(SdfNode::OctantMirror {
                    child: Arc::new(child),
                })
            }
            "icosahedral_symmetry" => {
                let child = self.parse_child_only()?;
                Ok(SdfNode::IcosahedralSymmetry {
                    child: Arc::new(child),
                })
            }
            "with_material" => {
                let (id, child) = self.parse_1f_child()?;
                Ok(SdfNode::WithMaterial {
                    child: Arc::new(child),
                    material_id: lol_u32(id),
                })
            }
            "surface_roughness" => {
                let (freq, amp, oct, child) = self.parse_3f_child()?;
                Ok(SdfNode::SurfaceRoughness {
                    child: Arc::new(child),
                    frequency: freq,
                    amplitude: amp,
                    octaves: lol_u32(oct),
                })
            }

            // ── 3D Print Structural Intent (3) ──
            "lattice_infill" => {
                let (shell_t, scale, lattice_t, child) = self.parse_3f_child()?;
                self.validate_tpms_fields(scale, lattice_t)?;
                Ok(SdfNode::Union {
                    a: Arc::new(SdfNode::Onion {
                        child: Arc::new(child.clone()),
                        thickness: shell_t,
                    }),
                    b: Arc::new(SdfNode::Intersection {
                        a: Arc::new(child),
                        b: Arc::new(SdfNode::Gyroid {
                            scale,
                            thickness: lattice_t,
                        }),
                    }),
                })
            }
            "diamond_infill" => {
                let (shell_t, scale, lattice_t, child) = self.parse_3f_child()?;
                self.validate_tpms_fields(scale, lattice_t)?;
                Ok(SdfNode::Union {
                    a: Arc::new(SdfNode::Onion {
                        child: Arc::new(child.clone()),
                        thickness: shell_t,
                    }),
                    b: Arc::new(SdfNode::Intersection {
                        a: Arc::new(child),
                        b: Arc::new(SdfNode::DiamondSurface {
                            scale,
                            thickness: lattice_t,
                        }),
                    }),
                })
            }
            "schwarz_infill" => {
                let (shell_t, scale, lattice_t, child) = self.parse_3f_child()?;
                self.validate_tpms_fields(scale, lattice_t)?;
                Ok(SdfNode::Union {
                    a: Arc::new(SdfNode::Onion {
                        child: Arc::new(child.clone()),
                        thickness: shell_t,
                    }),
                    b: Arc::new(SdfNode::Intersection {
                        a: Arc::new(child),
                        b: Arc::new(SdfNode::SchwarzP {
                            scale,
                            thickness: lattice_t,
                        }),
                    }),
                })
            }

            // ── 時間制御 (2) ──
            "animate" => {
                let speed = self.expect_number()?;
                self.expect_comma()?;
                let amplitude = self.expect_number()?;
                self.expect_comma()?;
                let child = self.parse_expr()?;
                self.expect_rparen()?;
                Ok(SdfNode::Animated {
                    child: Arc::new(child),
                    speed,
                    amplitude,
                })
            }
            "morph" => {
                let t = self.expect_number()?;
                self.expect_comma()?;
                let a = self.parse_expr()?;
                self.expect_comma()?;
                let b = self.parse_expr()?;
                self.expect_rparen()?;
                Ok(SdfNode::Morph {
                    a: Arc::new(a),
                    b: Arc::new(b),
                    t,
                })
            }

            // ── v1.0 プリミティブ (44) ──
            "triangle" => {
                let (ax, ay, az, bx, by, bz, cx, cy, cz) = self.parse_9f()?;
                Ok(SdfNode::Triangle {
                    point_a: Vec3::new(ax, ay, az),
                    point_b: Vec3::new(bx, by, bz),
                    point_c: Vec3::new(cx, cy, cz),
                })
            }
            "bezier" => {
                let (ax, ay, az, bx, by, bz, cx, cy, cz, r) = self.parse_10f()?;
                Ok(SdfNode::Bezier {
                    point_a: Vec3::new(ax, ay, az),
                    point_b: Vec3::new(bx, by, bz),
                    point_c: Vec3::new(cx, cy, cz),
                    radius: r,
                })
            }
            "triangular_prism" => {
                let (w, d) = self.parse_2f()?;
                Ok(SdfNode::TriangularPrism {
                    width: w,
                    half_depth: d,
                })
            }
            "cut_sphere" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::CutSphere {
                    radius: r,
                    cut_height: h,
                })
            }
            "cut_hollow_sphere" => {
                let (r, h, t) = self.parse_3f()?;
                Ok(SdfNode::CutHollowSphere {
                    radius: r,
                    cut_height: h,
                    thickness: t,
                })
            }
            "death_star" => {
                let (ra, rb, d) = self.parse_3f()?;
                Ok(SdfNode::DeathStar { ra, rb, d })
            }
            "solid_angle" => {
                let (a, r) = self.parse_2f()?;
                Ok(SdfNode::SolidAngle {
                    angle: a,
                    radius: r,
                })
            }
            "rhombus" => {
                let (la, lb, h, r) = self.parse_4f()?;
                Ok(SdfNode::Rhombus {
                    la,
                    lb,
                    half_height: h,
                    round_radius: r,
                })
            }
            "horseshoe" => {
                let (angle, radius, half_length, width, thickness) = self.parse_5f()?;
                Ok(SdfNode::Horseshoe {
                    angle,
                    radius,
                    half_length,
                    width,
                    thickness,
                })
            }
            "vesica" => {
                let (r, d) = self.parse_2f()?;
                Ok(SdfNode::Vesica {
                    radius: r,
                    half_dist: d,
                })
            }
            "infinite_cylinder" => {
                let r = self.parse_1f()?;
                Ok(SdfNode::InfiniteCylinder { radius: r })
            }
            "infinite_cone" => {
                let a = self.parse_1f()?;
                Ok(SdfNode::InfiniteCone { angle: a })
            }
            "gyroid" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::Gyroid {
                    scale: s,
                    thickness: t,
                })
            }
            "chamfered_cube" => {
                let (hx, hy, hz, c) = self.parse_4f()?;
                Ok(SdfNode::ChamferedCube {
                    half_extents: Vec3::new(hx, hy, hz),
                    chamfer: c,
                })
            }
            "schwarz_p" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::SchwarzP {
                    scale: s,
                    thickness: t,
                })
            }
            "superellipsoid" => {
                let (hx, hy, hz, e1, e2) = self.parse_5f()?;
                Ok(SdfNode::Superellipsoid {
                    half_extents: Vec3::new(hx, hy, hz),
                    e1,
                    e2,
                })
            }
            "rounded_x" => {
                let (w, r, h) = self.parse_3f()?;
                Ok(SdfNode::RoundedX {
                    width: w,
                    round_radius: r,
                    half_height: h,
                })
            }
            "pie" => {
                let (a, r, h) = self.parse_3f()?;
                Ok(SdfNode::Pie {
                    angle: a,
                    radius: r,
                    half_height: h,
                })
            }
            "trapezoid" => {
                let (r1, r2, th, d) = self.parse_4f()?;
                Ok(SdfNode::Trapezoid {
                    r1,
                    r2,
                    trap_height: th,
                    half_depth: d,
                })
            }
            "parallelogram" => {
                let (w, h, s, d) = self.parse_4f()?;
                Ok(SdfNode::Parallelogram {
                    width: w,
                    para_height: h,
                    skew: s,
                    half_depth: d,
                })
            }
            "tunnel" => {
                let (w, h, d) = self.parse_3f()?;
                Ok(SdfNode::Tunnel {
                    width: w,
                    height_2d: h,
                    half_depth: d,
                })
            }
            "uneven_capsule" => {
                let (r1, r2, h, d) = self.parse_4f()?;
                Ok(SdfNode::UnevenCapsule {
                    r1,
                    r2,
                    cap_height: h,
                    half_depth: d,
                })
            }
            "arc_shape" => {
                let (a, r, t, h) = self.parse_4f()?;
                Ok(SdfNode::ArcShape {
                    aperture: a,
                    radius: r,
                    thickness: t,
                    half_height: h,
                })
            }
            "moon" => {
                let (d, ra, rb, h) = self.parse_4f()?;
                Ok(SdfNode::Moon {
                    d,
                    ra,
                    rb,
                    half_height: h,
                })
            }
            "blobby_cross" => {
                let (s, h) = self.parse_2f()?;
                Ok(SdfNode::BlobbyCross {
                    size: s,
                    half_height: h,
                })
            }
            "parabola_segment" => {
                let (w, h, d) = self.parse_3f()?;
                Ok(SdfNode::ParabolaSegment {
                    width: w,
                    para_height: h,
                    half_depth: d,
                })
            }
            "regular_polygon" => {
                let (r, n, h) = self.parse_3f()?;
                Ok(SdfNode::RegularPolygon {
                    radius: r,
                    n_sides: n,
                    half_height: h,
                })
            }
            "stairs_prim" => {
                let (sw, sh, n, d) = self.parse_4f()?;
                // 評価器は段数だけ箱を走査する (O(n)) ので、段数も個数の上限を掛ける
                let n = self.bounded_count(n)?;
                Ok(SdfNode::Stairs {
                    step_width: sw,
                    step_height: sh,
                    n_steps: n,
                    half_depth: d,
                })
            }
            "dodecahedron" => {
                let r = self.parse_1f()?;
                Ok(SdfNode::Dodecahedron { radius: r })
            }
            "icosahedron" => {
                let r = self.parse_1f()?;
                Ok(SdfNode::Icosahedron { radius: r })
            }
            "truncated_octahedron" => {
                let r = self.parse_1f()?;
                Ok(SdfNode::TruncatedOctahedron { radius: r })
            }
            "truncated_icosahedron" => {
                let r = self.parse_1f()?;
                Ok(SdfNode::TruncatedIcosahedron { radius: r })
            }
            "diamond_surface" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::DiamondSurface {
                    scale: s,
                    thickness: t,
                })
            }
            "neovius" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::Neovius {
                    scale: s,
                    thickness: t,
                })
            }
            "lidinoid" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::Lidinoid {
                    scale: s,
                    thickness: t,
                })
            }
            "iwp" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::IWP {
                    scale: s,
                    thickness: t,
                })
            }
            "frd" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::FRD {
                    scale: s,
                    thickness: t,
                })
            }
            "fischer_koch_s" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::FischerKochS {
                    scale: s,
                    thickness: t,
                })
            }
            "pmy" => {
                let (s, t) = self.parse_tpms_fields()?;
                Ok(SdfNode::PMY {
                    scale: s,
                    thickness: t,
                })
            }
            "circle_2d" => {
                let (r, h) = self.parse_2f()?;
                Ok(SdfNode::Circle2D {
                    radius: r,
                    half_height: h,
                })
            }
            "rect_2d" => {
                let (hx, hy, h) = self.parse_3f()?;
                Ok(SdfNode::Rect2D {
                    half_extents: Vec2::new(hx, hy),
                    half_height: h,
                })
            }
            "segment_2d" => {
                let (ax, ay, bx, by, t, h) = self.parse_6f()?;
                Ok(SdfNode::Segment2D {
                    a: Vec2::new(ax, ay),
                    b: Vec2::new(bx, by),
                    thickness: t,
                    half_height: h,
                })
            }
            "rounded_rect_2d" => {
                let (hx, hy, r, h) = self.parse_4f()?;
                Ok(SdfNode::RoundedRect2D {
                    half_extents: Vec2::new(hx, hy),
                    round_radius: r,
                    half_height: h,
                })
            }
            "annular_2d" => {
                let (r, t, h) = self.parse_3f()?;
                Ok(SdfNode::Annular2D {
                    outer_radius: r,
                    thickness: t,
                    half_height: h,
                })
            }
            "terrain" => {
                let (s, a) = self.parse_2f()?;
                Ok(SdfNode::Terrain {
                    scale: s,
                    amplitude: a,
                })
            }
            // ── v1.0 モディファイア ──
            "sweep_bezier" => {
                let (p0x, p0y, p1x, p1y, p2x, p2y, child) = self.parse_6f_child()?;
                Ok(SdfNode::SweepBezier {
                    child: Arc::new(child),
                    p0: Vec2::new(p0x, p0y),
                    p1: Vec2::new(p1x, p1y),
                    p2: Vec2::new(p2x, p2y),
                })
            }

            // ── Phase 5.1 高階 primitive (stdlib::hardsurface 完成 pattern) ──
            // ALICE 三相原理 Phase 2 Law 経路 (SDF+DC)、pipeline: LOL DSL → SdfNode → DC → 3MF
            // 詳細: docs/PIPELINE_COMPLETE.md
            "shopping_cart_coin" => {
                let (dia, thickness) = self.parse_2f()?;
                Ok(crate::stdlib::hardsurface::thin_sdf::shopping_cart_coin_sdf(dia, thickness))
            }
            "skadis_panel" => {
                // Variadic 0/1/2/3-arg 対応 defaults は SKADIS canonical
                // (300×5×5、pipeline 側の `python generator`)
                // LLM 側で「SKADISパネル 10✖10」等の曖昧入力を parse fail させず
                // canonical に丸める β UX 用の forgiving 動作 (2026-09-04 追加)
                let (size, thickness, corner_r) = self.parse_skadis_panel_args()?;
                crate::stdlib::hardsurface::skadis_sdf::try_skadis_panel_sdf(
                    size, thickness, corner_r,
                )
                .map_err(|e| self.spec_error(e))
            }
            "skadis_hook_l" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_hook_l_sdf())
            }
            "skadis_hook_j" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_hook_j_sdf())
            }
            "skadis_hook_s" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_hook_s_sdf())
            }
            "skadis_container" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_container_sdf())
            }
            "skadis_clip" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_clip_sdf())
            }
            "skadis_shelf" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_shelf_sdf())
            }
            "skadis_elastic_cord" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::skadis_sdf::skadis_elastic_cord_sdf())
            }

            // ── Phase P.1 products primitive (stdlib::products) ──
            // 生活雑貨 canonical primitive text-to-print β の 3B LLM 複合形状
            // hallucination への対応
            "mug" => {
                let (dia, height) = self.parse_2f()?;
                Ok(crate::stdlib::products::mug_sdf(dia, height))
            }

            // ── Phase B.1.b 高階 primitive (stdlib::hardsurface::pattern_sdf) ──
            // pipeline Rust generator 由来の 4 pattern (wall_hook / gridfinity_bin /
            // drawer_organizer / shelf_divider) を DSL syntax に expose
            // wall_hook / drawer_organizer / shelf_divider は param なし = spec default
            // gridfinity_bin は 3 param (units_x, units_y, height_u) basic 版
            "gridfinity_bin" => {
                let (ux, uy, hu) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::GridfinitySpec {
                    units_x: self.count_trunc(ux)?,
                    units_y: self.count_trunc(uy)?,
                    height_u: self.count_trunc(hu)?,
                    dividers: None,
                    wall_thickness: 1.2,
                    floor_thickness: 1.5,
                };
                crate::stdlib::hardsurface::pattern_sdf::try_gridfinity_bin(&spec)
                    .map_err(|e| self.spec_error(e))
            }
            "gridfinity_bin_ex" => {
                // gridfinity_bin_ex(ux, uy, hu, divx, divy, wall, floor) 7 param full spec
                // divx>=1 && divy>=1 → dividers=Some((divx, divy))、それ以外 → None
                // wall <= 0 → default 1.2、floor <= 0 → default 1.5
                let (ux, uy, hu, div_x, div_y, wall, floor) = self.parse_7f()?;
                let dividers = if div_x >= 1.0 && div_y >= 1.0 {
                    Some((self.count_trunc(div_x)?, self.count_trunc(div_y)?))
                } else {
                    None
                };
                let wall_thickness = if wall > 0.0 { wall } else { 1.2 };
                let floor_thickness = if floor > 0.0 { floor } else { 1.5 };
                let spec = crate::stdlib::hardsurface::pattern_sdf::GridfinitySpec {
                    units_x: self.count_trunc(ux)?,
                    units_y: self.count_trunc(uy)?,
                    height_u: self.count_trunc(hu)?,
                    dividers,
                    wall_thickness,
                    floor_thickness,
                };
                crate::stdlib::hardsurface::pattern_sdf::try_gridfinity_bin(&spec)
                    .map_err(|e| self.spec_error(e))
            }
            "wall_hook" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::pattern_sdf::wall_hook(
                    &crate::stdlib::hardsurface::pattern_sdf::WallHookSpec::pla_1kgf(),
                ))
            }
            "drawer_organizer" => {
                self.expect_rparen()?;
                Ok(crate::stdlib::hardsurface::pattern_sdf::drawer_organizer(
                    &crate::stdlib::hardsurface::pattern_sdf::DrawerSpec::default_chopsticks_set(),
                ))
            }
            "shelf_divider" => {
                self.expect_rparen()?;
                crate::stdlib::hardsurface::pattern_sdf::try_shelf_divider(
                    &crate::stdlib::hardsurface::pattern_sdf::ShelfDividerSpec::field_tested_560x250x120(),
                )
                .map_err(|e| self.spec_error(e))
            }

            // ── organizer-gridfinity-desk PART 2 archetypes (Phase B、2026-08-19) ──
            "sticky_note_holder" => {
                // sticky_note_holder(pad_w, pad_d, height) 3 param、wall/floor は default 1.5
                let (pw, pd, h) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::StickyNoteHolderSpec {
                    pad_width: pw,
                    pad_depth: pd,
                    height: h,
                    wall_thickness: 1.5,
                    floor_thickness: 1.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::sticky_note_holder(
                    &spec,
                ))
            }
            "business_card_holder" => {
                // business_card_holder(card_w, card_h, slot_thickness) 3 param
                let (cw, ch, st) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::BusinessCardHolderSpec {
                    card_width: cw,
                    card_height: ch,
                    slot_thickness: st,
                    slot_depth: ch * 0.6,
                    wall_thickness: 1.5,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::business_card_holder(&spec))
            }
            "pen_cup" => {
                // pen_cup(inner_dia, height) 2 param、wall=2.0、floor=2.0 default
                let (dia, h) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::PenCupSpec {
                    inner_diameter: dia,
                    height: h,
                    wall_thickness: 2.0,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::pen_cup(&spec))
            }
            "phone_stand" => {
                // phone_stand(slot_width, back_height, cable_hole_dia) 3 param
                // cable_hole_dia <= 0 → None (穴なし)、それ以外 → Some(dia)
                let (sw, bh, chd) = self.parse_3f()?;
                let cable_hole_dia = if chd > 0.0 { Some(chd) } else { None };
                let spec = crate::stdlib::hardsurface::pattern_sdf::PhoneStandSpec {
                    slot_width: sw,
                    slot_depth: 6.0,
                    base_width: 90.0,
                    base_depth: 90.0,
                    base_thickness: 6.0,
                    back_height: bh,
                    back_thickness: 5.0,
                    cable_hole_dia,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::phone_stand(&spec))
            }

            // ── organizer-gridfinity-desk PART 2 B2 archetypes (2026-08-19) ──
            "headphone_holder" => {
                // headphone_holder(arm_length, headband_width, mount_width) 3 param
                // mount_hole_dia は default M4 (4.5mm) 固定、他は spec default
                let (al, hw, mw) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::HeadphoneHolderSpec {
                    arm_length: al,
                    arm_thickness: 6.0,
                    arm_width: hw,
                    mount_width: mw,
                    mount_height: 68.0,
                    mount_thickness: 6.0,
                    hook_tip_up: 18.0,
                    mount_hole_dia: Some(4.5),
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::headphone_holder(
                    &spec,
                ))
            }
            "under_desk_mount" => {
                // under_desk_mount(desk_thickness, clamp_width, screw_dia) 3 param
                // screw_dia <= 0 → None (両面テープ想定)、それ以外 → Some(dia)
                let (dt, cw, sd) = self.parse_3f()?;
                let screw_hole_dia = if sd > 0.0 { Some(sd) } else { None };
                let spec = crate::stdlib::hardsurface::pattern_sdf::UnderDeskMountSpec {
                    desk_thickness: dt,
                    clamp_width: cw,
                    clamp_depth: 50.0,
                    clamp_wall_thickness: 4.0,
                    screw_hole_dia,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::under_desk_mount(
                    &spec,
                ))
            }
            "desk_shelf" => {
                // desk_shelf(shelf_width, shelf_depth, leg_height) 3 param
                let (sw, sd, lh) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::DeskShelfSpec {
                    shelf_width: sw,
                    shelf_depth: sd,
                    shelf_thickness: 5.0,
                    leg_height: lh,
                    leg_thickness: 20.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::desk_shelf(&spec))
            }
            "monitor_riser" => {
                // monitor_riser(width, depth, height) 3 param、cable_hole default Some(40)
                let (w, d, h) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::MonitorRiserSpec {
                    width: w,
                    depth: d,
                    height: h,
                    platform_thickness: 8.0,
                    leg_thickness: 25.0,
                    cable_hole_dia: Some(40.0),
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::monitor_riser(
                    &spec,
                ))
            }

            // ── household.md archetypes (Sprint 4、2026-08-19) ──
            "coaster" => {
                // coaster(diameter, thickness) 2 param、lip は default (2.5mm 幅 / 1.5mm 高)
                let (dia, t) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CoasterSpec {
                    diameter: dia,
                    thickness: t,
                    lip_width: 2.5,
                    lip_height: 1.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::coaster(&spec))
            }
            "tissue_box_cover" => {
                // tissue_box_cover(internal_l, internal_w, internal_h) 3 param
                // wall + slot は default (1.6mm 壁 / 80×30mm slot)
                let (il, iw, ih) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::TissueBoxCoverSpec {
                    internal_length: il,
                    internal_width: iw,
                    internal_height: ih,
                    wall_thickness: 1.6,
                    slot_length: 80.0,
                    slot_width: 30.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::tissue_box_cover(
                    &spec,
                ))
            }
            "storage_box" => {
                // storage_box(internal_l, internal_w, internal_h) 3 param
                // wall + floor は default (2.0mm 各)、lid + hinge なし (future sprint)
                let (il, iw, ih) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::StorageBoxSpec {
                    internal_length: il,
                    internal_width: iw,
                    internal_height: ih,
                    wall_thickness: 2.0,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::storage_box(&spec))
            }

            // ── hobby-diy.md archetypes (Sprint 5、2026-08-23) ──
            "cable_clip" => {
                // cable_clip(cable_dia, length) 2 param、wall + opening_ratio は default
                let (dia, len) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CableClipSpec {
                    cable_diameter: dia,
                    clip_length: len,
                    wall_thickness: 2.0,
                    opening_ratio: 0.7,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::cable_clip(&spec))
            }
            "led_channel" => {
                // led_channel(strip_width, length) 2 param、depth 2.5 + wall 2.0 default
                let (sw, len) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::LedChannelSpec {
                    strip_width: sw,
                    channel_length: len,
                    channel_depth: 2.5,
                    wall_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::led_channel(&spec))
            }
            "card_tray" => {
                // card_tray(card_w, card_h, depth) 3 param、他は default (clearance 1 / wall 2 / floor 1.5 / notch 9)
                let (cw, ch, d) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CardTraySpec {
                    card_width: cw,
                    card_height: ch,
                    tray_depth: d,
                    card_clearance: 1.0,
                    wall_thickness: 2.0,
                    floor_thickness: 1.5,
                    finger_notch_radius: 9.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::card_tray(&spec))
            }
            "token_well" => {
                // token_well(dia, depth, count) 3 param、count は f32→u32 cast
                // 他は default (clearance 1 / wall 2 / floor 1.5)
                let (dia, depth, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::TokenWellSpec {
                    well_diameter: dia,
                    well_depth: depth,
                    well_count: self.count(count, 1.0)?,
                    well_clearance: 1.0,
                    wall_thickness: 2.0,
                    floor_thickness: 1.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::token_well(&spec))
            }

            // ── tools.md archetypes (Sprint 6、2026-08-23) ──
            "wrench_holder" => {
                // wrench_holder(min_mm, max_mm, count) 3 param、他は default
                let (min_mm, max_mm, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::WrenchHolderSpec {
                    min_size_mm: min_mm,
                    max_size_mm: max_mm,
                    count: self.count(count, 1.0)?,
                    slot_depth: 22.0,
                    slot_clearance: 0.6,
                    thickness_ratio: 0.5,
                    wall_thickness: 3.0,
                    floor_thickness: 4.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::wrench_holder(
                    &spec,
                ))
            }
            "socket_rail" => {
                // socket_rail(post_dia, post_height, count) 3 param、他は default
                let (dia, height, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SocketRailSpec {
                    post_diameter: dia,
                    post_height: height,
                    post_count: self.count(count, 1.0)?,
                    post_spacing: 6.0,
                    base_thickness: 4.0,
                    base_margin: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::socket_rail(&spec))
            }
            "hex_bit_holder" => {
                // hex_bit_holder(rows, cols, spacing) 3 param、hex size + depth は default 固定
                let (rows, cols, spacing) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::HexBitHolderSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    spacing,
                    wall_thickness: 2.0,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::hex_bit_holder(
                    &spec,
                ))
            }

            // ── electronics-enclosure.md archetypes (Sprint 7、2026-08-23) ──
            "raspi_case" => {
                // raspi_case(pcb_w, pcb_d, internal_h) 3 param、他 default
                let (pcb_w, pcb_d, int_h) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::RaspiCaseSpec {
                    pcb_width: pcb_w,
                    pcb_depth: pcb_d,
                    internal_height: int_h,
                    wall_thickness: 2.0,
                    floor_thickness: 3.0,
                    pcb_clearance: 1.0,
                    standoff_diameter: 6.0,
                    standoff_height: 5.0,
                    standoff_pilot_diameter: 2.2,
                    standoff_inset: 3.5,
                    port_opening_width: 60.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::raspi_case(&spec))
            }
            "esp32_enclosure" => {
                // esp32_enclosure(pcb_w, pcb_d, internal_h) 3 param、他 default (USB-C 想定)
                let (pcb_w, pcb_d, int_h) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::Esp32EnclosureSpec {
                    pcb_width: pcb_w,
                    pcb_depth: pcb_d,
                    internal_height: int_h,
                    wall_thickness: 1.6,
                    floor_thickness: 2.0,
                    pcb_clearance: 0.5,
                    usb_opening_width: 9.0,
                    usb_opening_height: 5.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::esp32_enclosure(
                    &spec,
                ))
            }
            "battery_18650_holder" => {
                // battery_18650_holder(count, wall_thickness, floor_thickness) 3 param
                let (count, wall, floor) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::Battery18650HolderSpec {
                    cell_count: self.count(count, 1.0)?,
                    wall_thickness: wall,
                    floor_thickness: floor,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::battery_18650_holder(&spec))
            }

            // ── organizer-bathroom-garage.md archetypes (Sprint 8、2026-08-23) ──
            "toothbrush_holder" => {
                // toothbrush_holder(count, hole_diameter, height) 3 param、他 default
                let (count, dia, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::ToothbrushHolderSpec {
                    count: self.count(count, 1.0)?,
                    hole_diameter: dia,
                    hole_depth: height,
                    wall_thickness: 6.0,
                    floor_thickness: 4.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::toothbrush_holder(
                    &spec,
                ))
            }
            "drill_bit_holder" => {
                // drill_bit_holder(min_mm, max_mm, count) 3 param、他 default
                let (min_mm, max_mm, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::DrillBitHolderSpec {
                    min_size_mm: min_mm,
                    max_size_mm: max_mm,
                    count: self.count(count, 1.0)?,
                    hole_depth: 22.0,
                    hole_clearance: 0.25,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::drill_bit_holder(
                    &spec,
                ))
            }
            "pliers_rack" => {
                // pliers_rack(slot_count, slot_width, slot_depth) 3 param、他 default
                let (count, width, depth) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::PliersRackSpec {
                    slot_count: self.count(count, 1.0)?,
                    slot_width: width,
                    slot_depth: depth,
                    slot_height: 35.0,
                    wall_thickness: 5.0,
                    floor_thickness: 5.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::pliers_rack(&spec))
            }

            // ── organizer-cable-kitchen.md archetypes (Sprint 9、2026-08-23) ──
            "spice_rack" => {
                // spice_rack(count, jar_diameter, jar_height) 3 param、他 default
                let (count, dia, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SpiceRackSpec {
                    count: self.count(count, 1.0)?,
                    jar_diameter: dia,
                    jar_height: height,
                    recess_depth: 5.0,
                    shelf_depth_margin: 15.0,
                    base_thickness: 5.0,
                    wall_thickness: 3.0,
                    lip_height_ratio: 0.15,
                    lip_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::spice_rack(&spec))
            }
            "egg_tray" => {
                // egg_tray(rows, cols, cup_depth) 3 param、pitch は default 50mm 固定
                let (rows, cols, cup_depth) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::EggTraySpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    cup_depth,
                    pitch: 50.0,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::egg_tray(&spec))
            }
            "utensil_caddy" => {
                // utensil_caddy(count, compartment_dia, height) 3 param、他 default
                let (count, dia, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::UtensilCaddySpec {
                    count: self.count(count, 1.0)?,
                    compartment_diameter: dia,
                    height,
                    wall_thickness: 5.0,
                    floor_thickness: 4.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::utensil_caddy(
                    &spec,
                ))
            }

            // ── organizer-printer-modular.md archetypes (Sprint 10、2026-08-23) ──
            "filament_spool_holder" => {
                // filament_spool_holder(spool_od, spool_width, bore_diameter) 3 param、他 default
                let (od, width, bore) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::FilamentSpoolHolderSpec {
                    spool_outer_diameter: od,
                    spool_width: width,
                    bore_diameter: bore,
                    base_thickness: 5.0,
                    base_margin: 30.0,
                    peg_clearance: 1.0,
                    peg_extra_height: 20.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::filament_spool_holder(&spec))
            }
            "nozzle_holder" => {
                // nozzle_holder(count, hole_diameter, depth) 3 param、他 default
                let (count, dia, depth) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::NozzleHolderSpec {
                    count: self.count(count, 1.0)?,
                    hole_diameter: dia,
                    hole_depth: depth,
                    wall_thickness: 4.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::nozzle_holder(
                    &spec,
                ))
            }
            "build_plate_rack" => {
                // build_plate_rack(slot_count, slot_spacing, height) 3 param、他 default
                let (count, spacing, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::BuildPlateRackSpec {
                    slot_count: self.count(count, 1.0)?,
                    slot_spacing: spacing,
                    height,
                    slot_width: 5.5,
                    depth: 60.0,
                    wall_thickness: 5.0,
                    floor_thickness: 5.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::build_plate_rack(
                    &spec,
                ))
            }

            // ── organizer-drawer-wall.md archetypes (Sprint 11、2026-08-23) ──
            "cutlery_tray" => {
                // cutlery_tray(slot_count, slot_width, slot_length) 3 param、他 default
                let (count, width, length) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CutleryTraySpec {
                    slot_count: self.count(count, 1.0)?,
                    slot_width: width,
                    slot_length: length,
                    slot_depth: 40.0,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::cutlery_tray(&spec))
            }
            "pill_organizer" => {
                // pill_organizer(rows, cols, cell_size) 3 param、他 default
                let (rows, cols, cell) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::PillOrganizerSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    cell_size: cell,
                    cell_depth: 15.0,
                    wall_thickness: 1.5,
                    floor_thickness: 1.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::pill_organizer(
                    &spec,
                ))
            }
            "magnetic_strip" => {
                // magnetic_strip(magnet_count, magnet_diameter, spacing) 3 param、他 default
                let (count, dia, spacing) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::MagneticStripSpec {
                    magnet_count: self.count(count, 1.0)?,
                    magnet_diameter: dia,
                    magnet_spacing: spacing,
                    magnet_depth: 2.0,
                    bar_thickness: 5.0,
                    bar_height: 15.0,
                    end_margin: 5.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::magnetic_strip(
                    &spec,
                ))
            }

            // ── Sprint 12 ミックス archetypes (2026-08-23) ──
            "hairdryer_holder" => {
                // hairdryer_holder(barrel_diameter, holster_depth, wall_thickness) 3 param
                let (dia, depth, wall) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::HairdryerHolderSpec {
                    barrel_diameter: dia,
                    holster_depth: depth,
                    wall_thickness: wall,
                    floor_thickness: 5.0,
                    inner_clearance: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::hairdryer_holder(
                    &spec,
                ))
            }
            "kcup_holder" => {
                // kcup_holder(rows, cols, capsule_diameter) 3 param、depth は default 40mm
                let (rows, cols, dia) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::KcupHolderSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    capsule_diameter: dia,
                    capsule_depth: 40.0,
                    capsule_clearance: 3.5,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::kcup_holder(&spec))
            }
            "hex_key_holder" => {
                // hex_key_holder(count, min_key_mm, max_key_mm) 3 param、他 default
                let (count, min_mm, max_mm) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::HexKeyHolderSpec {
                    count: self.count(count, 1.0)?,
                    min_key_mm: min_mm,
                    max_key_mm: max_mm,
                    hole_depth: 18.0,
                    hole_clearance: 0.3,
                    wall_thickness: 3.0,
                    floor_thickness: 4.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::hex_key_holder(
                    &spec,
                ))
            }

            // ── Sprint 13 ミックス 2 archetypes (2026-08-23) ──
            "wrap_holder" => {
                // wrap_holder(roll_diameter, roll_width, wall_thickness) 3 param
                let (dia, width, wall) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::WrapHolderSpec {
                    roll_diameter: dia,
                    roll_width: width,
                    wall_thickness: wall,
                    roll_clearance: 1.5,
                    cradle_depth_ratio: 0.6,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::wrap_holder(&spec))
            }
            "sock_divider" => {
                // sock_divider(cell_count, cell_width, height) 3 param
                let (count, width, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SockDividerSpec {
                    cell_count: self.count(count, 1.0)?,
                    cell_width: width,
                    height,
                    cell_depth: 100.0,
                    wall_thickness: 2.5,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::sock_divider(&spec))
            }
            "soap_tray" => {
                // soap_tray(tray_length, tray_width, drain_slot_count) 3 param
                let (length, width, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SoapTraySpec {
                    tray_length: length,
                    tray_width: width,
                    drain_slot_count: self.count(count, 1.0)?,
                    tray_depth: 12.0,
                    drain_slot_width: 3.0,
                    wall_thickness: 2.5,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::soap_tray(&spec))
            }

            // ── Sprint 14 ミックス 3 archetypes (2026-08-23) ──
            "razor_holder" => {
                // razor_holder(slot_width, slot_depth, mount_hole_diameter) 3 param
                let (slot_w, slot_d, mount_dia) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::RazorHolderSpec {
                    slot_width: slot_w,
                    slot_depth: slot_d,
                    mount_hole_diameter: mount_dia,
                    blade_clearance_width: 55.0,
                    backplate_width: 80.0,
                    total_height: 60.0,
                    wall_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::razor_holder(&spec))
            }
            "chopstick_holder" => {
                // chopstick_holder(pair_count, slot_width, slot_length) 3 param
                let (count, width, length) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::ChopstickHolderSpec {
                    pair_count: self.count(count, 1.0)?,
                    slot_width: width,
                    slot_length: length,
                    slot_depth: 15.0,
                    wall_thickness: 2.5,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::chopstick_holder(
                    &spec,
                ))
            }
            "swatch_holder" => {
                // swatch_holder(rows, cols, swatch_width) 3 param、他 default
                let (rows, cols, width) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SwatchHolderSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    swatch_width: width,
                    swatch_height: 70.0,
                    swatch_thickness: 4.5,
                    wall_thickness: 2.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::swatch_holder(
                    &spec,
                ))
            }
            "tp_holder" => {
                // tp_holder(inner_diameter, roll_width, wall_thickness) 3 param
                let (inner_dia, roll_w, wall_t) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::TpHolderSpec {
                    inner_diameter: inner_dia,
                    roll_width: roll_w,
                    wall_thickness: wall_t,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::tp_holder(&spec))
            }
            "sd_card_holder" => {
                // sd_card_holder(rows, cols, card_width) 3 param、他 default
                let (rows, cols, width) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SdCardHolderSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    card_width: width,
                    card_height: 32.0,
                    card_thickness: 2.5,
                    wall_thickness: 1.5,
                    floor_thickness: 2.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::sd_card_holder(
                    &spec,
                ))
            }
            "driver_rack" => {
                // driver_rack(slot_count, slot_diameter, height) 3 param
                let (count, dia, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::DriverRackSpec {
                    slot_count: self.count(count, 1.0)?,
                    slot_diameter: dia,
                    height,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::driver_rack(&spec))
            }
            "cotton_dispenser" => {
                // cotton_dispenser(count, inner_diameter, height) 3 param、他 default
                let (count, inner_dia, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CottonDispenserSpec {
                    count: self.count(count, 1.0)?,
                    inner_diameter: inner_dia,
                    height,
                    wall_thickness: 2.5,
                    floor_thickness: 2.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::cotton_dispenser(
                    &spec,
                ))
            }
            "sink_caddy" => {
                // sink_caddy(tray_length, tray_width, drain_hole_count) 3 param、他 default
                let (length, width, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SinkCaddySpec {
                    tray_length: length,
                    tray_width: width,
                    drain_hole_count: self.count(count, 1.0)?,
                    tray_depth: 30.0,
                    drain_hole_diameter: 6.0,
                    wall_thickness: 2.5,
                    floor_thickness: 2.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::sink_caddy(&spec))
            }
            "clamp_rack" => {
                // clamp_rack(hook_count, hook_width, height) 3 param、他 default
                let (count, width, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::ClampRackSpec {
                    hook_count: self.count_smooth_folded(count, 1.0)?,
                    hook_width: width,
                    height,
                    hook_depth: 25.0,
                    wall_thickness: 5.0,
                    hook_opening: 15.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::clamp_rack(&spec))
            }
            "dry_box" => {
                // dry_box(rows, cols, filament_diameter) 3 param、他 default
                let (rows, cols, dia) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::DryBoxSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    filament_diameter: dia,
                    spool_width: 70.0,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::dry_box(&spec))
            }
            "outdoor_enclosure" => {
                // outdoor_enclosure(internal_w, internal_d, internal_h) 3 param
                let (w, d, h) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::OutdoorEnclosureSpec {
                    internal_width: w,
                    internal_depth: d,
                    internal_height: h,
                    wall_thickness: 3.5,
                    floor_thickness: 3.5,
                    gasket_width: 2.0,
                    gasket_depth: 1.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::outdoor_enclosure(
                    &spec,
                ))
            }
            "jewelry_stand" => {
                // jewelry_stand(tier_count, bottom_tier_dia, height) 3 param、他 default
                let (count, dia, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::JewelryStandSpec {
                    tier_count: self.count(count, 1.0)?,
                    bottom_tier_diameter: dia,
                    height,
                    tier_thickness: 5.0,
                    pillar_diameter: 10.0,
                    tier_ratio: 0.7,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::jewelry_stand(
                    &spec,
                ))
            }
            "phone_dock" => {
                // phone_dock(width, upright_height, cable_diameter) 3 param、他 default
                let (w, h, cable) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::PhoneDockSpec {
                    width: w,
                    upright_height: h,
                    cable_diameter: cable,
                    base_depth: 60.0,
                    base_thickness: 6.0,
                    upright_thickness: 4.0,
                    tilt_angle_deg: 15.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::phone_dock(&spec))
            }
            "cutting_board_rack" => {
                // cutting_board_rack(slot_count, slot_width, height) 3 param、他 default
                let (count, width, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CuttingBoardRackSpec {
                    slot_count: self.count(count, 1.0)?,
                    slot_width: width,
                    height,
                    slot_depth: 200.0,
                    wall_thickness: 4.0,
                    floor_thickness: 8.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::cutting_board_rack(
                    &spec,
                ))
            }
            "tape_dispenser" => {
                // tape_dispenser(inner_diameter, roll_width, wall_thickness) 3 param、他 default
                let (inner_dia, roll_w, wall_t) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::TapeDispenserSpec {
                    inner_diameter: inner_dia,
                    roll_width: roll_w,
                    wall_thickness: wall_t,
                    outer_diameter: 150.0,
                    tear_angle_deg: 30.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::tape_dispenser(
                    &spec,
                ))
            }
            "shower_caddy" => {
                // shower_caddy(tier_count, tier_length, tier_depth) 3 param、他 default
                let (count, length, depth) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::ShowerCaddySpec {
                    tier_count: self.count(count, 1.0)?,
                    tier_length: length,
                    tier_depth: depth,
                    tier_height: 40.0,
                    tier_spacing: 100.0,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                    drain_hole_diameter: 5.0,
                    drains_per_tier: 6,
                    mount_hole_diameter: 4.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::shower_caddy(&spec))
            }
            "caliper_holder" => {
                // caliper_holder(jaw_length, throat_depth, count) 3 param、他 default
                let (jaw, throat, count) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CaliperHolderSpec {
                    jaw_length: jaw,
                    throat_depth: throat,
                    count: self.count(count, 1.0)?,
                    slot_width: 15.0,
                    wall_thickness: 5.0,
                    mount_hole_diameter: 4.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::caliper_holder(
                    &spec,
                ))
            }
            "bag_clip_org" => {
                // bag_clip_org(slot_count, slot_width, height) 3 param、他 default
                let (count, width, height) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::BagClipOrgSpec {
                    slot_count: self.count(count, 1.0)?,
                    slot_width: width,
                    height,
                    wall_thickness: 2.5,
                    floor_thickness: 3.0,
                    slot_depth: 30.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::bag_clip_org(&spec))
            }
            "can_rack" => {
                // can_rack(rows, can_diameter, tilt_angle_deg) 3 param、他 default
                let (rows, dia, tilt) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CanRackSpec {
                    rows: self.count(rows, 1.0)?,
                    can_diameter: dia,
                    tilt_angle_deg: tilt,
                    cans_per_row: 6,
                    wall_thickness: 3.0,
                    shelf_thickness: 3.0,
                    front_lip_height: 15.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::can_rack(&spec))
            }
            "led_hub_box" => {
                // led_hub_box(internal_w, internal_d, internal_h) 3 param、他 default
                let (w, d, h) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::LedHubBoxSpec {
                    internal_width: w,
                    internal_depth: d,
                    internal_height: h,
                    led_window_width: 40.0,
                    led_window_height: 15.0,
                    antenna_hole_diameter: 12.0,
                    wall_thickness: 3.0,
                    floor_thickness: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::led_hub_box(&spec))
            }
            "makeup_organizer" => {
                // makeup_organizer(rows, cols, cell_size) 3 param、他 default
                let (rows, cols, size) = self.parse_3f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::MakeupOrganizerSpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    cell_size: size,
                    cell_depth: 40.0,
                    wall_thickness: 2.0,
                    floor_thickness: 2.5,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::makeup_organizer(
                    &spec,
                ))
            }

            // ── Sprint 21 Phase X.1 機械要素 (2026-08-27) ──
            "vesa_mount" => {
                // vesa_mount(size, plate_t, m_size) 3 param、bore_kind default 1 (counterbore)
                let (size, plate_t, m_size) = self.parse_3f()?;
                let hole = self.metric_size(m_size)?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::VesaMountSpec {
                    vesa_size: size,
                    plate_thickness: plate_t,
                    plate_margin: 15.0,
                    corner_radius: 3.0,
                    hole_size: hole,
                    bore_kind: 1,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::vesa_mount(&spec))
            }
            "l_bracket" => {
                // l_bracket(w, h, plate_t, m_size, holes_per_arm) 5 param、bore_kind default 0 (through)
                let (w, h, plate_t, m_size, holes) = self.parse_5f()?;
                let hole = self.metric_size(m_size)?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::LBracketSpec {
                    arm_width: w,
                    arm_height: h,
                    plate_thickness: plate_t,
                    depth: 40.0,
                    fillet_radius: 3.0,
                    hole_size: hole,
                    holes_per_arm: self.count(holes, 1.0)?,
                    bore_kind: 0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::l_bracket(&spec))
            }

            // ── Sprint 21 Phase X.1 追加 8 archetype (2026-08-27) ──
            "t_slot_bracket_2020" => {
                // t_slot_bracket_2020(arm_size, depth) 2 param、他 default
                let (arm, depth) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::TSlotBracket2020Spec {
                    arm_size: arm,
                    depth,
                    plate_thickness: 3.0,
                    fillet_radius: 3.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::t_slot_bracket_2020(&spec))
            }
            "raspi_mount_plate" => {
                // raspi_mount_plate(model, extra_m4_holes) 2 param
                let (model, extras) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::RaspiMountPlateSpec {
                    model: self.count(model, 0.0)?,
                    extra_m4_holes: self.count(extras, 0.0)?,
                    plate_thickness: 4.0,
                    plate_margin: 15.0,
                    m25_hole_dia: 2.8,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::raspi_mount_plate(
                    &spec,
                ))
            }
            "heat_set_array" => {
                // heat_set_array(rows, cols, m_size, pitch, base_t) 5 param
                let (rows, cols, m_size, pitch, base_t) = self.parse_5f()?;
                let m = self.metric_size(m_size)?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::HeatSetArraySpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    insert_size: m,
                    pitch,
                    base_thickness: base_t,
                    margin: 10.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::heat_set_array(
                    &spec,
                ))
            }
            "flange_mount" => {
                // flange_mount(od, m_size, hole_count) 3 param、thickness default 6
                let (od, m_size, count) = self.parse_3f()?;
                let m = self.metric_size(m_size)?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::FlangeMountSpec {
                    outer_dia: od,
                    bolt_size: m,
                    hole_count: self.count(count, 1.0)?,
                    thickness: 6.0,
                    bcd_ratio: 0.7,
                    center_bore_dia: 0.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::flange_mount(&spec))
            }
            "dovetail_pair" => {
                // dovetail_pair(w, h, d, gender) 4 param、gender: 0=male / 1=female
                let (w, h, d, gender) = self.parse_4f()?;
                let g = u8::from(gender >= 0.5);
                let spec = crate::stdlib::hardsurface::pattern_sdf::DovetailPairSpec {
                    base_width: w,
                    height: h,
                    depth: d,
                    gender: g,
                    female_margin: 10.0,
                    female_plate_thickness: 8.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::dovetail_pair(
                    &spec,
                ))
            }
            "profile_extrusion" => {
                // profile_extrusion(kind, length) 2 param、kind: 20=2020 / 30=3030
                let (kind, length) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::ProfileExtrusionSpec {
                    kind: self.count(kind, 20.0)?,
                    length,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::profile_extrusion(
                    &spec,
                ))
            }
            "snap_fit_pair" => {
                // snap_fit_pair(length, width, thickness, hook_height) 4 param
                let (l, w, t, hook_d) = self.parse_4f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::SnapFitPairSpec {
                    length: l,
                    width: w,
                    thickness: t,
                    hook_height: hook_d,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::snap_fit_pair(
                    &spec,
                ))
            }
            "boss_array" => {
                // boss_array(rows, cols, m_size, height, pitch, base_t) 6 param
                let (rows, cols, m_size, height, pitch, base_t) = self.parse_6f()?;
                let m = self.metric_size(m_size)?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::BossArraySpec {
                    rows: self.count(rows, 1.0)?,
                    cols: self.count_grid(rows, cols)?,
                    screw_size: m,
                    boss_height: height,
                    pitch,
                    base_thickness: base_t,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::boss_array(&spec))
            }

            // ── Sprint 22 Phase X.2 fastener 低レベル primitive (2026-08-27) ──
            // 全て Y-up native (raw)、Z-up 変換 (to_z_up) は user が組合せる時に指定
            "screw_hole" => {
                // screw_hole(m_size, depth) 2 param、H2D +0.2mm clearance
                let (m_size, depth) = self.parse_2f()?;
                let m = self.metric_size(m_size)?;
                Ok(crate::stdlib::hardsurface::fastener::screw_hole(m, depth))
            }
            "tap_hole" => {
                // tap_hole(m_size, depth) 2 param、accuracy default 0.1
                let (m_size, depth) = self.parse_2f()?;
                let m = self.metric_size(m_size)?;
                Ok(crate::stdlib::hardsurface::fastener::tap_hole(
                    m,
                    depth,
                    crate::stdlib::hardsurface::fastener::DEFAULT_ACCURACY,
                ))
            }
            "counterbore" => {
                // counterbore(m_size, plate_thickness) 2 param
                let (m_size, plate_t) = self.parse_2f()?;
                let m = self.metric_size(m_size)?;
                Ok(crate::stdlib::hardsurface::fastener::counterbore(
                    m, plate_t,
                ))
            }
            "countersink" => {
                // countersink(m_size, plate_thickness) 2 param
                let (m_size, plate_t) = self.parse_2f()?;
                let m = self.metric_size(m_size)?;
                Ok(crate::stdlib::hardsurface::fastener::countersink(
                    m, plate_t,
                ))
            }
            "heat_set_hole" => {
                // heat_set_hole(m_size) 1 param、McMaster/Voxel8 spec
                let m_size = self.parse_1f()?;
                let m = self.metric_size(m_size)?;
                Ok(crate::stdlib::hardsurface::fastener::heat_set_insert_hole(
                    m,
                ))
            }
            "bolt" => {
                // bolt(m_size, shank_length) 2 param、可視化用 (頭 + 軸 Union)
                let (m_size, shank) = self.parse_2f()?;
                let m = self.metric_size(m_size)?;
                Ok(crate::stdlib::hardsurface::fastener::bolt(m, shank))
            }

            // ── Sprint 22 Phase X.2 mount / joint / reinforcement 低レベル primitive ──
            "bracket_l" => {
                // bracket_l(w, h, plate_t, depth, fillet_r) 5 param、raw Y-up
                let (w, h, plate_t, depth, fillet) = self.parse_5f()?;
                Ok(crate::stdlib::hardsurface::mount::bracket_l(
                    w, h, plate_t, depth, fillet,
                ))
            }
            "flange_circular" => {
                // flange_circular(od, center_bore, thickness, pcd, bolt_count, bolt_dia) 6 param
                let (od, cb, thick, pcd, count, bolt_dia) = self.parse_6f()?;
                Ok(crate::stdlib::hardsurface::mount::flange_circular(
                    od,
                    cb,
                    thick,
                    pcd,
                    self.count(count, 1.0)?,
                    bolt_dia,
                ))
            }
            "t_slot_2020" => {
                // t_slot_2020(length) 1 param、Y-up T-slot cavity
                let length = self.parse_1f()?;
                Ok(crate::stdlib::hardsurface::joint::t_slot_2020(length))
            }
            "profile_2020" => {
                // profile_2020(length) 1 param、Y-up 2020 プロファイル外形
                let length = self.parse_1f()?;
                Ok(crate::stdlib::hardsurface::mount::profile_2020(length))
            }
            "profile_3030" => {
                // profile_3030(length) 1 param、Y-up 3030 プロファイル外形
                let length = self.parse_1f()?;
                Ok(crate::stdlib::hardsurface::mount::profile_3030(length))
            }
            "dovetail" => {
                // dovetail(base_width, height, depth) 3 param、10° テーパー台形
                let (bw, h, d) = self.parse_3f()?;
                Ok(crate::stdlib::hardsurface::joint::dovetail(bw, h, d))
            }
            "slot" => {
                // slot(length, width, depth) 3 param、両端 rounded
                let (l, w, d) = self.parse_3f()?;
                Ok(crate::stdlib::hardsurface::joint::slot(l, w, d))
            }
            "snap_fit_annular" => {
                // snap_fit_annular(shaft_dia, shaft_length, bulge_height, bulge_y_offset) 4 param
                let (sd, sl, bh, by) = self.parse_4f()?;
                Ok(crate::stdlib::hardsurface::joint::snap_fit_annular(
                    sd, sl, bh, by,
                ))
            }
            "pin_hinge_knuckle" => {
                // pin_hinge_knuckle(pin_dia, knuckle_length, knuckle_od) 3 param
                let (pd, kl, ko) = self.parse_3f()?;
                Ok(crate::stdlib::hardsurface::joint::pin_hinge_knuckle(
                    pd, kl, ko,
                ))
            }
            "boss" => {
                // boss(screw_dia, height) 2 param、raw float 呼び径
                let (dia, height) = self.parse_2f()?;
                Ok(crate::stdlib::hardsurface::reinforcement::boss(dia, height))
            }
            "rib" => {
                // rib(length, height, thickness) 3 param、Box3d wrapper
                let (l, h, t) = self.parse_3f()?;
                Ok(crate::stdlib::hardsurface::reinforcement::rib(l, h, t))
            }

            // ── Sprint 22 続行 mechanical primitive (2026-08-28) ──
            "bearing_seat" => {
                // bearing_seat(size, plate_t, style) 3 param
                // size (f32、OD) → BearingKind::from_f32_snap で最近接標準
                // style: 0=press-fit, 1=slip fit, 2=through with shoulder
                let (size, plate_t, style) = self.parse_3f()?;
                let bearing =
                    crate::stdlib::hardsurface::pattern_sdf::BearingKind::from_f32_snap(size);
                let plate_margin = 10.0;
                let corner_radius = plate_margin * 0.3;
                let style_u8 = if style >= 1.5 {
                    2_u8
                } else {
                    u8::from(style >= 0.5)
                };
                let spec = crate::stdlib::hardsurface::pattern_sdf::BearingSeatSpec {
                    bearing,
                    plate_thickness: plate_t,
                    plate_margin,
                    corner_radius,
                    style: style_u8,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::bearing_seat(&spec))
            }
            "rack_shelf" => {
                // rack_shelf(length, thickness, width, notch_pitch, notch_dia, notch_count) 6 param、Y-up raw
                let (length, thickness, width, pitch, dia, count) = self.parse_6f()?;
                Ok(crate::stdlib::hardsurface::mount::rack_shelf(
                    length,
                    thickness,
                    width,
                    pitch,
                    dia,
                    self.count(count, 0.0)?,
                ))
            }

            // ── Multi-domain 展開 (家具 + 建築、2026-08-28) ──
            "cable_grommet" => {
                // cable_grommet(outer_dia, height) 2 param、他 default
                let (od, h) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CableGrommetSpec {
                    outer_dia: od,
                    height: h,
                    flange_thickness: 3.0,
                    flange_overhang: 4.0,
                    inner_dia: raw_max_f32(od - 10.0, 4.0, crate::raw_minmax::Reason::NonzeroConst),
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::cable_grommet(
                    &spec,
                ))
            }
            "curtain_rod_bracket" => {
                // curtain_rod_bracket(rod_dia, projection) 2 param、他 default (M4 wall screw)
                let (rod, proj) = self.parse_2f()?;
                let spec = crate::stdlib::hardsurface::pattern_sdf::CurtainRodBracketSpec {
                    rod_dia: rod,
                    projection: proj,
                    wall_plate_w: 40.0,
                    wall_plate_h: 80.0,
                    plate_thickness: 4.0,
                    arm_thickness: 8.0,
                    arm_width: 20.0,
                    wall_screw: crate::stdlib::hardsurface::fastener::MetricSize::M4,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::curtain_rod_bracket(&spec))
            }
            "dowel_hole" => {
                // dowel_hole(dia, depth) 2 param、家具 flat-pack joinery、raw Y-up
                let (dia, depth) = self.parse_2f()?;
                Ok(crate::stdlib::hardsurface::fastener::dowel_hole(dia, depth))
            }
            "wood_screw_pilot" => {
                // wood_screw_pilot(screw_dia, hardwood_flag) 2 param、0=softwood / 1=hardwood
                let (dia, hw) = self.parse_2f()?;
                let hardwood = hw >= 0.5;
                Ok(crate::stdlib::hardsurface::fastener::wood_screw_pilot(
                    dia, hardwood,
                ))
            }

            // ── 電子工作 domain 展開 (Arduino / Pixhawk / Servo / JST-PH、2026-08-28) ──
            "arduino_mount_plate" => {
                // arduino_mount_plate(board_type, extras) 2 param、1=Uno / 2=Mega / 3=Nano
                let (board_type, extras) = self.parse_2f()?;
                let board = crate::stdlib::hardsurface::pattern_sdf::ArduinoBoard::from_f32_snap(
                    board_type,
                );
                let spec = crate::stdlib::hardsurface::pattern_sdf::ArduinoMountPlateSpec {
                    board,
                    plate_thickness: 4.0,
                    plate_margin: 10.0,
                    extra_m4_holes: self.count(extras, 0.0)?,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::arduino_mount_plate(&spec))
            }
            "pixhawk_mount" => {
                // pixhawk_mount(size, damper_style) 2 param、size = hole pattern (45 / 30)
                let (size, damper) = self.parse_2f()?;
                let damper_u8 = u8::from(damper >= 0.5);
                let spec = crate::stdlib::hardsurface::pattern_sdf::PixhawkMountSpec {
                    hole_pattern_size: size,
                    plate_thickness: 4.0,
                    plate_margin: 12.0,
                    damper_style: damper_u8,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::pixhawk_mount(
                    &spec,
                ))
            }
            "servo_mount" => {
                // servo_mount(servo_type) 1 param、1=SG90 / 2=MG996R
                let servo_type = self.parse_1f()?;
                let servo =
                    crate::stdlib::hardsurface::pattern_sdf::ServoKind::from_f32_snap(servo_type);
                let plate_thickness = match servo {
                    crate::stdlib::hardsurface::pattern_sdf::ServoKind::Sg90 => 3.0,
                    crate::stdlib::hardsurface::pattern_sdf::ServoKind::Mg996r => 4.0,
                };
                let spec = crate::stdlib::hardsurface::pattern_sdf::ServoMountSpec {
                    servo,
                    plate_thickness,
                    flange_margin: 5.0,
                };
                Ok(crate::stdlib::hardsurface::pattern_sdf::servo_mount(&spec))
            }
            "jst_ph_slot" => {
                // jst_ph_slot(pins) 1 param、2/3/4/5 pin 対応、raw Y-up Box3d
                let pins = self.parse_1f()?;
                Ok(crate::stdlib::hardsurface::joint::jst_ph_slot(
                    self.count(pins, 2.0)?,
                ))
            }

            other => Err(ParseError {
                message: format!("unknown LOL expression: '{other}'"),
                position: self.lexer.position(),
            }),
        }
    }
}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 公開 API
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

/// LOL テキストを [`SdfNode`] にパースする。
///
/// LLM が生成した LOL 構文テキストを受け取り、ALICE-SDF の [`SdfNode`] ツリーに変換。
/// `proc_macro` 版と同等の 76 構文をサポート（値は `f32` リテラルのみ）。
///
/// # Errors
///
/// 構文エラー、未知の関数名、引数の不足・過剰の場合に [`ParseError`] を返す。
///
/// # Examples
///
/// ```
/// use alice_lol::runtime_parser::parse_lol;
///
/// let node = parse_lol("sphere(1.0)").unwrap();
/// let dist = alice_lol::eval(&node, glam::Vec3::ZERO);
/// assert!((dist - (-1.0)).abs() < 1e-6);
/// ```
///
/// ```
/// use alice_lol::runtime_parser::parse_lol;
///
/// let node = parse_lol("smooth_union(0.3, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
/// ```
pub fn parse_lol(input: &str) -> Result<SdfNode, ParseError> {
    let mut parser = Parser::new(input);
    let node = parser.parse_expr()?;
    // 末尾にゴミがないか確認
    parser.lexer.skip_whitespace();
    if parser.lexer.position() < parser.lexer.input.len() {
        return Err(ParseError {
            message: "unexpected trailing content".into(),
            position: parser.lexer.position(),
        });
    }
    Ok(node)
}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Program / Intent パーサー (Phase 3、A0)
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

impl Parser<'_> {
    const fn err<T>(&self, message: String) -> Result<T, ParseError> {
        Err(ParseError {
            message,
            position: self.lexer.position(),
        })
    }

    /// 関数名 (Ident) 1 個
    fn expect_ident(&mut self) -> Result<String, ParseError> {
        match self.next()? {
            Some(Token::Ident(s)) => Ok(s),
            other => self.err(format!("expected identifier, got {other:?}")),
        }
    }

    /// `(` 1 個
    fn expect_lparen(&mut self, after: &str) -> Result<(), ParseError> {
        match self.next()? {
            Some(Token::LParen) => Ok(()),
            other => self.err(format!("expected '(' after '{after}', got {other:?}")),
        }
    }

    /// 非負整数 (`u32` 範囲)
    ///
    /// Lexer は数値を `f32` で保持するため、小数部なし + 範囲内を検証する
    /// `f32` の整数精度は 2^24 までなので `NodeId` / ms / byte 用途では十分
    fn expect_uint(&mut self, what: &str) -> Result<u32, ParseError> {
        let v = self.expect_number()?;
        if v < 0.0 || v.fract() != 0.0 || v > 16_777_216.0 {
            return self.err(format!("{what} must be a non-negative integer, got {v}"));
        }
        // 範囲は直前で検証済 (0 ..= 2^24)
        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
        Ok(v as u32)
    }

    /// 個数を取る引数 (rows / cols / count 等) を 1 以上 `MAX_STDLIB_COUNT` 以下の整数にする
    ///
    /// 個数は stdlib の生成器が `SdfNode` の個数・木の深さに直結する 旧実装は `as u32` で
    /// 上限なしに通していたので、`pill_organizer(1e6, 2, 3)` は stack overflow で abort
    /// (`catch_unwind` でも拾えない)、`1e5` は数分かけて確保し続けた LLM が生成した値が
    /// そのまま入る経路なので、境界で `ParseError` にする 非有限値も弾く
    fn count(&self, v: f32, min: f32) -> Result<u32, ParseError> {
        let v = self.bounded_count(v)?;
        Ok(lol_u32(crate::det_math::max(v.round(), min)))
    }

    /// 個数を取るが、生成器が `smooth_union` を 1 個ずつ重ねる (非結合なので balanced fold に
    /// できない) 引数 木の深さが個数の 2 倍になるので、上限は `MAX_STDLIB_SMOOTH_FOLD_COUNT`
    fn count_smooth_folded(&self, v: f32, min: f32) -> Result<u32, ParseError> {
        if v > MAX_STDLIB_SMOOTH_FOLD_COUNT {
            return Err(ParseError {
                message: format!(
                    "個数が上限 {MAX_STDLIB_SMOOTH_FOLD_COUNT} を超える (smooth union を線形に重ねる形状): {v}"
                ),
                position: self.lexer.pos,
            });
        }
        self.count(v, min)
    }

    /// 格子の列数 `cols` を取る `rows × cols` が `MAX_STDLIB_GRID_CELLS` 以下であることも検証する
    fn count_grid(&self, rows: f32, cols: f32) -> Result<u32, ParseError> {
        let c = self.count(cols, 1.0)?;
        let r = self.count(rows, 1.0)?;
        if f64::from(r) * f64::from(c) > f64::from(MAX_STDLIB_GRID_CELLS) {
            return Err(ParseError {
                message: format!("格子の要素数 {r} x {c} が上限 {MAX_STDLIB_GRID_CELLS} を超える"),
                position: self.lexer.pos,
            });
        }
        Ok(c)
    }

    /// `count` と同じ上限で、小数部は切り捨てる (旧 `lol_u32` と同じ丸め)
    fn count_trunc(&self, v: f32) -> Result<u32, ParseError> {
        Ok(lol_u32(self.bounded_count(v)?))
    }

    /// [`crate::limits::SpecError`] を `ParseError` に写す
    ///
    /// stdlib の `try_*` builder (`try_gridfinity_bin` / `try_skadis_panel_sdf` /
    /// `try_shelf_divider` 等) が返す fallible な検査結果を、この parser の唯一の
    /// error 型に揃える 旧実装は `skadis_size()` のように parser 側に同じ境界を
    /// 二重に持つ builder ごとの helper があったが、境界を一箇所 (builder 自身の
    /// `validate()`) にまとめ、parser は常に `try_*` を呼んでここで写すだけにする
    /// (`gridfinity_bin_ex` が infallible な `gridfinity_bin` を直接呼んでいたため、
    /// per-axis 上限内でも積が `MAX_NODE_EXPANSION` を超える入力で panic していた
    /// 事案の根本対応、2026-10-10)
    fn spec_error(&self, e: crate::limits::SpecError) -> ParseError {
        ParseError {
            message: e.to_string(),
            position: self.lexer.pos,
        }
    }

    fn bounded_count(&self, v: f32) -> Result<f32, ParseError> {
        if !v.is_finite() || v > MAX_STDLIB_COUNT {
            return Err(ParseError {
                message: format!("個数は有限で {MAX_STDLIB_COUNT} 以下でなければならない: {v}"),
                position: self.lexer.pos,
            });
        }
        Ok(v)
    }

    /// 0-255 の整数 (music packet byte)
    fn expect_u8(&mut self, what: &str) -> Result<u8, ParseError> {
        let v = self.expect_uint(what)?;
        u8::try_from(v).map_or_else(|_| self.err(format!("{what} must be 0-255, got {v}")), Ok)
    }

    /// entity registry を参照する `NodeId` (範囲検証込み)
    fn expect_node_id(&mut self, registry_len: usize) -> Result<NodeId, ParseError> {
        let id = self.expect_uint("entity id")?;
        if (id as usize) >= registry_len {
            return self.err(format!(
                "entity id {id} out of range (entities has {registry_len} entries)"
            ));
        }
        Ok(id)
    }

    /// `left` / `right` / `both`
    fn expect_hand(&mut self) -> Result<HandSide, ParseError> {
        let s = self.expect_ident()?;
        match s.as_str() {
            "left" => Ok(HandSide::Left),
            "right" => Ok(HandSide::Right),
            "both" => Ok(HandSide::Both),
            other => self.err(format!("expected hand (left|right|both), got '{other}'")),
        }
    }

    fn expect_vec3(&mut self) -> Result<Vec3, ParseError> {
        let x = self.expect_number()?;
        self.expect_comma()?;
        let y = self.expect_number()?;
        self.expect_comma()?;
        let z = self.expect_number()?;
        Ok(Vec3::new(x, y, z))
    }

    /// `entities(<sdf>, <sdf>, ...)` — 空も許容
    fn parse_entities(&mut self) -> Result<Vec<SdfNode>, ParseError> {
        let name = self.expect_ident()?;
        if name != "entities" {
            return self.err(format!("expected 'entities', got '{name}'"));
        }
        self.expect_lparen("entities")?;
        let mut out = Vec::new();
        if self.at_rparen()? {
            self.next()?;
            return Ok(out);
        }
        loop {
            out.push(self.parse_expr()?);
            match self.next()? {
                Some(Token::Comma) => {}
                Some(Token::RParen) => return Ok(out),
                other => {
                    return self.err(format!("expected ',' or ')' in entities, got {other:?}"))
                }
            }
        }
    }

    /// Intent 式 1 個 (`grasp(...)` / `seq(...)` / `latent(...)` 等)
    #[allow(clippy::too_many_lines)] // verb dispatch table、parse_expr と同型
    fn parse_intent(&mut self, registry_len: usize) -> Result<IntentNode, ParseError> {
        let name = self.expect_ident()?;
        self.expect_lparen(&name)?;
        match name.as_str() {
            "grasp" => {
                let target_id = self.expect_node_id(registry_len)?;
                self.expect_comma()?;
                let hand = self.expect_hand()?;
                self.expect_comma()?;
                let force = self.parse_1f()?;
                Ok(IntentNode::Grasp {
                    target_id,
                    hand,
                    force,
                })
            }
            "release" => {
                let target_id = self.expect_node_id(registry_len)?;
                self.expect_rparen()?;
                Ok(IntentNode::Release { target_id })
            }
            "catch" => {
                let object_id = self.expect_node_id(registry_len)?;
                self.expect_rparen()?;
                Ok(IntentNode::Catch { object_id })
            }
            "walk" => {
                let destination = self.expect_vec3()?;
                self.expect_comma()?;
                let speed = self.parse_1f()?;
                Ok(IntentNode::Walk { destination, speed })
            }
            "gaze" => {
                let target = self.expect_vec3()?;
                self.expect_comma()?;
                let duration_ms = self.expect_uint("gaze duration_ms")?;
                self.expect_rparen()?;
                Ok(IntentNode::Gaze {
                    target,
                    duration_ms,
                })
            }
            "point" => {
                let target = self.expect_vec3()?;
                self.expect_comma()?;
                let hand = self.expect_hand()?;
                self.expect_rparen()?;
                Ok(IntentNode::Point { target, hand })
            }
            "throw" => {
                let target = self.expect_vec3()?;
                self.expect_comma()?;
                let force = self.expect_number()?;
                self.expect_comma()?;
                let hand = self.expect_hand()?;
                self.expect_rparen()?;
                Ok(IntentNode::Throw {
                    target,
                    force,
                    hand,
                })
            }
            "push" | "pull" | "turn" => {
                let target_id = self.expect_node_id(registry_len)?;
                self.expect_comma()?;
                let v = self.expect_vec3()?;
                self.expect_comma()?;
                let f = self.parse_1f()?;
                Ok(match name.as_str() {
                    "push" => IntentNode::Push {
                        target_id,
                        direction: v,
                        force: f,
                    },
                    "pull" => IntentNode::Pull {
                        target_id,
                        direction: v,
                        force: f,
                    },
                    _ => IntentNode::Rotate {
                        target_id,
                        axis: v,
                        angle_rad: f,
                    },
                })
            }
            "align" => {
                let target_id = self.expect_node_id(registry_len)?;
                self.expect_comma()?;
                let reference = self.expect_vec3()?;
                self.expect_rparen()?;
                Ok(IntentNode::Align {
                    target_id,
                    reference,
                })
            }
            "follow" | "avoid" => {
                let target_id = self.expect_node_id(registry_len)?;
                self.expect_comma()?;
                let d = self.parse_1f()?;
                Ok(if name == "follow" {
                    IntentNode::Follow {
                        target_id,
                        distance: d,
                    }
                } else {
                    IntentNode::Avoid {
                        target_id,
                        min_distance: d,
                    }
                })
            }
            "rest" => {
                let duration_ms = self.expect_uint("rest duration_ms")?;
                self.expect_rparen()?;
                Ok(IntentNode::Rest { duration_ms })
            }
            "latent" => {
                let mut values = Vec::new();
                loop {
                    values.push(self.expect_number()?);
                    match self.next()? {
                        Some(Token::Comma) => {}
                        Some(Token::RParen) => break,
                        other => {
                            return self
                                .err(format!("expected ',' or ')' in latent, got {other:?}"))
                        }
                    }
                }
                if values.len() < 4 {
                    return self.err(format!(
                        "latent needs at least 4 values, got {}",
                        values.len()
                    ));
                }
                Ok(IntentNode::LatentIntent {
                    values: values.into_boxed_slice(),
                    semantic_hint: None,
                })
            }
            "seq" | "par" => {
                let mut items = Vec::new();
                loop {
                    items.push(self.parse_intent(registry_len)?);
                    match self.next()? {
                        Some(Token::Comma) => {}
                        Some(Token::RParen) => break,
                        other => {
                            return self
                                .err(format!("expected ',' or ')' in {name}, got {other:?}"))
                        }
                    }
                }
                Ok(if name == "seq" {
                    IntentNode::Sequence(items)
                } else {
                    IntentNode::Parallel(items)
                })
            }
            "music" => {
                let mut packet = [0u8; 8];
                for (i, slot) in packet.iter_mut().enumerate() {
                    if i > 0 {
                        self.expect_comma()?;
                    }
                    *slot = self.expect_u8("music byte")?;
                }
                self.expect_rparen()?;
                Ok(IntentNode::Music { packet })
            }
            other => self.err(format!("unknown intent verb '{other}'")),
        }
    }

    /// `program(<sdf> [, entities(...) [, <intent>]])`
    fn parse_program_body(&mut self) -> Result<Program, ParseError> {
        self.expect_lparen("program")?;
        let sdf = self.parse_expr()?;
        let mut builder = ProgramBuilder::new().with_sdf(sdf);
        let mut registry_len = 0;
        match self.next()? {
            Some(Token::RParen) => return Ok(builder.build()),
            Some(Token::Comma) => {}
            other => return self.err(format!("expected ',' or ')' in program, got {other:?}")),
        }
        for node in self.parse_entities()? {
            let id = builder.register(node);
            registry_len = id as usize + 1;
        }
        match self.next()? {
            Some(Token::RParen) => return Ok(builder.build()),
            Some(Token::Comma) => {}
            other => return self.err(format!("expected ',' or ')' in program, got {other:?}")),
        }
        let intent = self.parse_intent(registry_len)?;
        self.expect_rparen()?;
        Ok(builder.with_intent(intent).build())
    }
}

/// LOL テキストを [`Program`] (SDF + entity registry + Intent) に変換する
///
/// 受け付ける形:
///
/// ```text
/// program(<sdf>)                               // geometry のみ
/// program(<sdf>, entities(<sdf>, ...))         // registry あり、Intent なし
/// program(<sdf>, entities(<sdf>, ...), <intent>)
/// <sdf>                                        // 裸の SDF 式 (後方互換、= program(<sdf>))
/// ```
///
/// Intent verb は [`IntentNode`] の field 順に引数を取る `rotate` は SDF transform
/// と衝突するため Intent 側の verb 名は `turn` entity 参照は非負整数の `NodeId` で、
/// `entities(...)` の範囲外は parse error
///
/// ```
/// use alice_lol::runtime_parser::parse_program;
/// use alice_lol::intent::{HandSide, IntentNode};
///
/// let p = parse_program(
///     "program(sphere(1.0), entities(box3d(0.1, 0.1, 0.1)), seq(grasp(0, right, 5.0), rest(500)))",
/// ).unwrap();
/// assert_eq!(p.sdf_registry.len(), 1);
/// assert!(matches!(p.intent, Some(IntentNode::Sequence(ref v)) if v.len() == 2));
/// assert!(matches!(p.intent, Some(IntentNode::Sequence(ref v))
///     if v[0] == IntentNode::Grasp { target_id: 0, hand: HandSide::Right, force: 5.0 }));
/// ```
///
/// # Errors
///
/// 構文エラー / 未知の verb / entity id 範囲外 / 整数が要る箇所に小数 / 末尾ゴミ
pub fn parse_program(input: &str) -> Result<Program, ParseError> {
    let mut parser = Parser::new(input);
    let is_program = matches!(parser.peek()?, Some(Token::Ident(s)) if s == "program");
    let program = if is_program {
        parser.next()?;
        parser.parse_program_body()?
    } else {
        Program::sdf_only(parser.parse_expr()?)
    };
    parser.lexer.skip_whitespace();
    if parser.lexer.position() < parser.lexer.input.len() {
        return Err(ParseError {
            message: "unexpected trailing content".into(),
            position: parser.lexer.position(),
        });
    }
    Ok(program)
}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// 監査 Law (行ごとに 1 項、SDF の式とも Intent とも別の文)
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

/// 監査 Law を読む
///
/// 1 行 1 項で、先頭の語が項の種類を決める (`audit` / `evidence` / `expect` /
/// `range`、一覧は test 専用の `syntax_table::LAW_SYNTAX`) `#` から行末は注記
///
/// ```text
/// audit lock-single-version
/// evidence packages
/// expect unbaselined_duplicates == 0
/// range alice-det-math 0.3.2 0.4.0
/// ```
///
/// # Errors
///
/// `audit` の行が無い / 項が 0 件 / 読めない行がある場合
pub fn parse_law(input: &str) -> Result<AuditLaw, ParseError> {
    let mut name: Option<String> = None;
    let mut clauses: Vec<Clause> = Vec::new();
    let mut position = 0_usize;

    for raw in input.lines() {
        let at = position;
        position += raw.len() + 1;
        let line = raw.split('#').next().unwrap_or("").trim();
        if line.is_empty() {
            continue;
        }
        let mut words = line.split_whitespace();
        let head = words.next().unwrap_or("");
        let rest: Vec<&str> = words.collect();
        match head {
            "audit" => {
                if rest.len() != 1 {
                    return Err(law_error("`audit` takes one name", at));
                }
                // the name is given once
                if name.is_some() {
                    return Err(law_error("a second `audit <name>` line", at));
                }
                name = Some(rest[0].to_owned());
            }
            "evidence" => {
                if rest.len() != 1 {
                    return Err(law_error("`evidence` takes one metric", at));
                }
                clauses.push(Clause::Evidence {
                    metric: rest[0].to_owned(),
                });
            }
            "expect" => clauses.push(
                law_expect(&rest)
                    .ok_or_else(|| law_error("`expect <metric> == <value> [within <tol>]`", at))?,
            ),
            "range" => {
                let (key, values) = rest
                    .split_first()
                    .ok_or_else(|| law_error("`range <key> <value>...`", at))?;
                if values.is_empty() {
                    return Err(law_error("`range` needs at least one value", at));
                }
                clauses.push(Clause::Range {
                    key: (*key).to_owned(),
                    values: sorted_values(values),
                });
            }
            other => {
                return Err(law_error(
                    &format!("unknown audit law clause `{other}`"),
                    at,
                ))
            }
        }
    }

    let name = name.ok_or_else(|| law_error("no `audit <name>` line", 0))?;
    if clauses.is_empty() {
        return Err(law_error(
            &format!("`{name}` states nothing (an audit needs at least one clause)"),
            0,
        ));
    }
    Ok(AuditLaw::new(name, clauses))
}

fn law_error(message: &str, position: usize) -> ParseError {
    ParseError {
        message: message.to_owned(),
        position,
    }
}

/// A number of a law file: ASCII decimal, finite as a double
///
/// The form is `[+-]? (digits [. digits?] | . digits) ([eE] [+-]? digits)?`: `2`, `-1`, `+2`,
/// `2.`, `.5`, `2e0` are numbers; `inf`, `nan`, `1_0`, `0x2`, a full-width or non-ASCII
/// digit and `1e400` are not
///
/// In Rust the form check is a defence: every spelling `f64::from_str` reads as a finite
/// number already has this form (an equivalent mutant: removing the check changes no
/// result), while other languages' parsers read more (`1_0`, `２`, padded spaces)
///
/// The form is checked here, not left to a language's number parser (which accept
/// different spellings: `inf`, `nan`, `infinity`, underscores, other digits)
#[must_use]
pub fn law_number(token: &str) -> Option<f64> {
    let b = token.as_bytes();
    let mut i = usize::from(matches!(b.first(), Some(b'+' | b'-')));
    let digits = |i: &mut usize| {
        let start = *i;
        while b.get(*i).is_some_and(u8::is_ascii_digit) {
            *i += 1;
        }
        *i - start
    };
    let int = digits(&mut i);
    let frac = if b.get(i) == Some(&b'.') {
        i += 1;
        digits(&mut i)
    } else {
        0
    };
    if int == 0 && frac == 0 {
        return None;
    }
    if matches!(b.get(i), Some(b'e' | b'E')) {
        i += 1;
        if matches!(b.get(i), Some(b'+' | b'-')) {
            i += 1;
        }
        if digits(&mut i) == 0 {
            return None;
        }
    }
    if i != b.len() {
        return None;
    }
    token.parse::<f64>().ok().filter(|v| v.is_finite())
}

fn law_expect(rest: &[&str]) -> Option<Clause> {
    let metric = rest.first()?;
    if *rest.get(1)? != "==" {
        return None;
    }
    let value = law_number(rest.get(2)?)?;
    let tolerance = match rest.len() {
        3 => 0.0,
        // a tolerance is an allowed deviation: not negative
        5 if rest[3] == "within" => law_number(rest[4]).filter(|t| *t >= 0.0)?,
        _ => return None,
    };
    Some(Clause::Expect {
        metric: (*metric).to_owned(),
        value,
        tolerance,
    })
}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// テスト
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

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

    #[test]
    fn a_law_number_is_ascii_decimal_and_finite() {
        for (t, v) in [
            ("2", 2.0),
            ("2.0", 2.0),
            ("+2", 2.0),
            ("2e0", 2.0),
            ("2.", 2.0),
            (".5", 0.5),
            ("-1", -1.0),
            ("1E-3", 0.001),
            ("002", 2.0),
        ] {
            assert_eq!(law_number(t), Some(v), "{t}");
        }
        for t in [
            "nan", "NaN", "inf", "-inf", "infinity", "1_0", "\u{ff12}", "\u{662}", "1e400", "0x2",
            ".", "e5", "1e", "+", "", " 2", "--1", "1.2.3",
        ] {
            assert_eq!(law_number(t), None, "{t:?}");
        }
    }

    #[test]
    fn the_name_of_an_audit_is_given_once() {
        assert!(parse_law("audit a\naudit b\nevidence m\n").is_err());
        assert!(parse_law("audit a\nevidence m\naudit a\n").is_err());
    }

    #[test]
    fn an_expect_clause_takes_only_law_numbers() {
        assert!(parse_law("audit a\nexpect m == 2 within 0.5\n").is_ok());
        assert!(parse_law("audit a\nexpect m == -2 within 0\n").is_ok());
        for bad in [
            "expect m == 2 within -1",
            "expect m == 2 within -0.5",
            "expect m == nan",
            "expect m == inf",
            "expect m == 2 within inf",
            "expect m == 1_0",
            "expect m == 2 junk",
        ] {
            assert!(parse_law(&format!("audit a\n{bad}\n")).is_err(), "{bad}");
        }
    }

    #[test]
    fn test_sphere() {
        let node = parse_lol("sphere(1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!((d - (-1.0)).abs() < 1e-6);
    }

    #[test]
    fn test_box3d() {
        let node = parse_lol("box3d(1.0, 1.0, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0); // 内部
    }

    #[test]
    fn test_union() {
        let node = parse_lol("union(sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_smooth_union() {
        let node = parse_lol("smooth_union(0.3, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_translate() {
        let node = parse_lol("translate(2.0, 0.0, 0.0, sphere(0.5))").unwrap();
        let d_origin = crate::eval(&node, Vec3::ZERO);
        let d_offset = crate::eval(&node, Vec3::new(2.0, 0.0, 0.0));
        assert!(d_origin > 0.0); // 原点は外
        assert!(d_offset < 0.0); // 移動先は内
    }

    #[test]
    fn test_rotate() {
        let node = parse_lol("rotate(0.0, 90.0, 0.0, box3d(2.0, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_scale() {
        let node = parse_lol("scale(2.0, sphere(1.0))").unwrap();
        let d = crate::eval(&node, Vec3::new(1.5, 0.0, 0.0));
        assert!(d < 0.0); // r=2 に拡大
    }

    #[test]
    fn test_subtract() {
        let node = parse_lol("subtract(sphere(1.0), sphere(0.5))").unwrap();
        let d_origin = crate::eval(&node, Vec3::ZERO);
        assert!(d_origin > 0.0); // 内部がくり抜かれている
    }

    #[test]
    fn test_intersection() {
        let node = parse_lol("intersection(sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_round() {
        let node = parse_lol("round(0.1, box3d(1.0, 1.0, 1.0))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_onion() {
        let node = parse_lol("onion(0.1, sphere(1.0))").unwrap();
        let d_origin = crate::eval(&node, Vec3::ZERO);
        assert!(d_origin > 0.0); // 中空
    }

    #[test]
    fn test_twist() {
        let node = parse_lol("twist(0.5, box3d(1.0, 2.0, 1.0))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_mirror() {
        let node =
            parse_lol("mirror(1.0, 0.0, 0.0, translate(1.0, 0.0, 0.0, sphere(0.3)))").unwrap();
        let d_pos = crate::eval(&node, Vec3::new(1.0, 0.0, 0.0));
        let d_neg = crate::eval(&node, Vec3::new(-1.0, 0.0, 0.0));
        assert!(d_pos < 0.0);
        assert!(d_neg < 0.0); // ミラーで反対側にもある
    }

    #[test]
    fn test_polar_repeat() {
        let node = parse_lol("polar_repeat(6, translate(2.0, 0.0, 0.0, sphere(0.3)))").unwrap();
        let d = crate::eval(&node, Vec3::new(2.0, 0.0, 0.0));
        assert!(d < 0.0);
    }

    #[test]
    fn test_torus() {
        let node = parse_lol("torus(1.0, 0.3)").unwrap();
        let d = crate::eval(&node, Vec3::new(1.0, 0.0, 0.0));
        assert!(d < 0.0);
    }

    #[test]
    fn test_cylinder() {
        let node = parse_lol("cylinder(0.5, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_capsule() {
        let node = parse_lol("capsule(0.3, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_cone() {
        let node = parse_lol("cone(1.0, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::new(0.0, 0.5, 0.0));
        assert!(d < 0.0);
    }

    #[test]
    fn test_ellipsoid() {
        let node = parse_lol("ellipsoid(1.0, 0.5, 0.7)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_octahedron() {
        let node = parse_lol("octahedron(1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_heart() {
        let node = parse_lol("heart(1.0)").unwrap();
        assert!(parse_lol("heart(1.0)").is_ok());
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_egg() {
        let node = parse_lol("egg(1.0, 0.3)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_tetrahedron() {
        let node = parse_lol("tetrahedron(1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_diamond() {
        let node = parse_lol("diamond(0.8, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_box_frame() {
        let node = parse_lol("box_frame(1.0, 1.0, 1.0, 0.1)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_helix() {
        let node = parse_lol("helix(1.0, 0.1, 1.0, 2.0)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_nary_union() {
        let node = parse_lol("union(sphere(1.0), sphere(0.5), sphere(0.3))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_smooth_subtract() {
        let node = parse_lol("smooth_subtract(0.1, sphere(1.0), sphere(0.5))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_xor() {
        let node = parse_lol("xor(sphere(1.0), sphere(0.8))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_morph() {
        let node = parse_lol("morph(0.5, sphere(1.0), box3d(1.0, 1.0, 1.0))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_scale_non_uniform() {
        let node = parse_lol("scale_non_uniform(2.0, 1.0, 1.0, sphere(1.0))").unwrap();
        let d = crate::eval(&node, Vec3::new(1.5, 0.0, 0.0));
        assert!(d < 0.0);
    }

    #[test]
    fn test_negative_number() {
        let node = parse_lol("translate(-1.0, -2.0, 0.0, sphere(0.5))").unwrap();
        let d = crate::eval(&node, Vec3::new(-1.0, -2.0, 0.0));
        assert!(d < 0.0);
    }

    #[test]
    fn test_nested_complex() {
        let input = "smooth_union(0.2, \
            translate(0.0, 1.0, 0.0, scale_non_uniform(1.5, 0.4, 1.5, sphere(1.0))), \
            cylinder(0.3, 0.8))";
        let node = parse_lol(input).unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_whitespace_tolerance() {
        let input = "  smooth_union( 0.3 , sphere( 1.0 ) , box3d( 0.5 , 0.5 , 0.5 ) )  ";
        let node = parse_lol(input).unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_multiline() {
        let input = "union(\n  sphere(1.0),\n  translate(0.0, 2.0, 0.0, sphere(0.5))\n)";
        let node = parse_lol(input).unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_error_unknown_function() {
        let result = parse_lol("foobar(1.0)");
        assert!(result.is_err());
        assert!(result.unwrap_err().message.contains("unknown"));
    }

    #[test]
    fn test_error_missing_rparen() {
        let result = parse_lol("sphere(1.0");
        assert!(result.is_err());
    }

    #[test]
    fn test_error_trailing_content() {
        let result = parse_lol("sphere(1.0) extra");
        assert!(result.is_err());
        assert!(result.unwrap_err().message.contains("trailing"));
    }

    #[test]
    fn test_chamfer_union() {
        let node = parse_lol("chamfer_union(0.1, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_elongate() {
        let node = parse_lol("elongate(0.0, 1.0, 0.0, sphere(0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_extrude() {
        let node = parse_lol("extrude(0.5, sphere(1.0))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_taper() {
        let node = parse_lol("taper(0.3, cylinder(1.0, 2.0))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_displacement() {
        let node = parse_lol("displacement(0.1, sphere(1.0))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_noise() {
        let node = parse_lol("noise(0.1, 2.0, 42, sphere(1.0))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_bend() {
        let node = parse_lol("bend(0.3, box3d(0.5, 2.0, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_shear() {
        let node = parse_lol("shear(0.5, 0.0, 0.0, box3d(1.0, 1.0, 1.0))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_revolution() {
        let node = parse_lol("revolution(1.0, sphere(0.3))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_pipe() {
        let node = parse_lol("pipe(0.1, sphere(1.0), box3d(1.0, 1.0, 1.0))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_engrave() {
        let node = parse_lol("engrave(0.05, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_animate() {
        let node = parse_lol("animate(1.0, 0.5, sphere(1.0))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_with_material() {
        let node = parse_lol("with_material(1, sphere(1.0))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!((d - (-1.0)).abs() < 1e-6);
    }

    #[test]
    fn test_snowman_example() {
        let input = "union(\
            sphere(1.0),\
            translate(0.0, 1.3, 0.0, sphere(0.7)),\
            translate(0.0, 2.2, 0.0, sphere(0.5))\
        )";
        let node = parse_lol(input).unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_gear_example() {
        let input = "subtract(\
            polar_repeat(12, translate(1.5, 0.0, 0.0, cylinder(0.15, 0.2))),\
            subtract(cylinder(1.8, 0.2), cylinder(0.5, 0.3))\
        )";
        let node = parse_lol(input).unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_plane() {
        let node = parse_lol("plane(0.0, 1.0, 0.0, 0.0)").unwrap();
        let d_below = crate::eval(&node, Vec3::new(0.0, -1.0, 0.0));
        let d_above = crate::eval(&node, Vec3::new(0.0, 1.0, 0.0));
        assert!(d_below < 0.0);
        assert!(d_above > 0.0);
    }

    #[test]
    fn test_pyramid() {
        let node = parse_lol("pyramid(1.0)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_hex_prism() {
        let node = parse_lol("hex_prism(0.5, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_link() {
        let node = parse_lol("link(0.5, 0.5, 0.1)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_capped_cone() {
        let node = parse_lol("capped_cone(1.0, 0.8, 0.3)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_rounded_cone() {
        let node = parse_lol("rounded_cone(0.5, 0.2, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_rounded_cylinder() {
        let node = parse_lol("rounded_cylinder(0.5, 0.05, 1.0)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_tube() {
        let node = parse_lol("tube(1.0, 0.1, 1.0)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_barrel() {
        let node = parse_lol("barrel(0.8, 1.0, 0.2)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_star_polygon() {
        let node = parse_lol("star_polygon(1.0, 5.0, 0.4, 0.3)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_cross_shape() {
        let node = parse_lol("cross_shape(1.0, 0.3, 0.05, 0.3)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_rounded_box() {
        let node = parse_lol("rounded_box(1.0, 1.0, 1.0, 0.1)").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_capped_torus() {
        let node = parse_lol("capped_torus(1.0, 0.3, 1.57)").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_repeat_finite() {
        let node = parse_lol("repeat_finite(3.0, 1.0, 3.0, 2.0, 0.0, 2.0, sphere(0.3))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_octant_mirror() {
        let node = parse_lol("octant_mirror(translate(1.0, 1.0, 1.0, sphere(0.2)))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_icosahedral_symmetry() {
        let node =
            parse_lol("icosahedral_symmetry(translate(1.0, 0.0, 0.0, sphere(0.2)))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_surface_roughness() {
        let node = parse_lol("surface_roughness(5.0, 0.1, 3, sphere(1.0))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_groove() {
        let node = parse_lol("groove(0.1, 0.05, sphere(1.0), box3d(0.8, 0.8, 0.8))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_tongue() {
        let node = parse_lol("tongue(0.1, 0.05, sphere(1.0), box3d(0.8, 0.8, 0.8))").unwrap();
        let _ = crate::eval(&node, Vec3::ZERO);
    }

    #[test]
    fn test_columns_union() {
        let node = parse_lol("columns_union(0.1, 4.0, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_exp_smooth_union() {
        let node = parse_lol("exp_smooth_union(0.3, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    #[test]
    fn test_stairs_union() {
        let node = parse_lol("stairs_union(0.2, 4.0, sphere(1.0), box3d(0.5, 0.5, 0.5))").unwrap();
        let d = crate::eval(&node, Vec3::ZERO);
        assert!(d < 0.0);
    }

    // ── v1.0 新プリミティブ パーステスト ──

    #[test]
    fn test_v10_simple_prims() {
        // 1-param prims
        for (name, args) in [
            ("infinite_cylinder", "0.5"),
            ("infinite_cone", "0.3"),
            ("dodecahedron", "1.0"),
            ("icosahedron", "1.0"),
            ("truncated_octahedron", "1.0"),
            ("truncated_icosahedron", "1.0"),
        ] {
            let input = format!("{name}({args})");
            assert!(parse_lol(&input).is_ok(), "failed: {input}");
        }
    }

    #[test]
    fn test_v10_2f_prims() {
        for (name, args) in [
            ("triangular_prism", "0.5, 1.0"),
            ("cut_sphere", "1.0, 0.3"),
            ("solid_angle", "0.5, 1.0"),
            ("vesica", "1.0, 0.5"),
            ("gyroid", "3.0, 0.1"),
            ("schwarz_p", "3.0, 0.1"),
            ("blobby_cross", "0.5, 1.0"),
            ("diamond_surface", "3.0, 0.1"),
            ("neovius", "3.0, 0.1"),
            ("lidinoid", "3.0, 0.1"),
            ("iwp", "3.0, 0.1"),
            ("frd", "3.0, 0.1"),
            ("fischer_koch_s", "3.0, 0.1"),
            ("pmy", "3.0, 0.1"),
            ("circle_2d", "0.5, 1.0"),
        ] {
            let input = format!("{name}({args})");
            assert!(parse_lol(&input).is_ok(), "failed: {input}");
        }
    }

    /// `alice_sdf`'s 9 TPMS surfaces (`gyroid`/`schwarz_p`/`diamond_surface`/
    /// `neovius`/`lidinoid`/`iwp`/`frd`/`fischer_koch_s`/`pmy`) all compute
    /// `d.abs() / scale - thickness` with no guard on `scale`: a scale of
    /// exactly `0.0` or `-0.0` divides into `+inf` / `-inf`. Reject at the
    /// language boundary instead of letting an accepted builder produce a
    /// tree whose `eval` is infinite. The accept threshold is plain `> 0.0`:
    /// an earlier version of this check used `>= 1e-6` instead, matching
    /// `fmt_f32`'s then-near-zero-collapsing behavior (a scale accepted below
    /// that threshold would have been silently rounded to `0.0` by the first
    /// `to_lol`, making the emitted text unparseable by this very check).
    /// `fmt_f32` is a faithful round-trip for every finite value now (no
    /// near-zero collapsing left), so that extra margin is no longer needed:
    /// any finite positive scale, however small, round-trips through
    /// emit/parse unchanged.
    #[test]
    fn tpms_scale_and_thickness_reject_degenerate_values() {
        let names = [
            "gyroid",
            "schwarz_p",
            "diamond_surface",
            "neovius",
            "lidinoid",
            "iwp",
            "frd",
            "fischer_koch_s",
            "pmy",
        ];
        // scale: must be finite and > 0.0. "NaN"/"inf"/"-inf" are not
        // included here: this crate's lexer already refuses any literal that
        // reads as non-finite, for every numeric field in the whole grammar
        // (see `tpms_fields_validation_rejects_non_finite_values_directly`,
        // which exercises `validate_tpms_fields` without going through that
        // earlier, unrelated gate -- confirmed by mutation: deleting the
        // scale/thickness checks in `validate_tpms_fields` does not turn a
        // text-level "NaN"/"inf" case red, because the lexer's gate is what
        // actually rejects it).
        let bad_scales = ["-0.0", "0.0", "-1.0", "-5e-7"];
        for name in names {
            for scale in bad_scales {
                let input = format!("{name}({scale}, 0.1)");
                assert!(
                    parse_lol(&input).is_err(),
                    "{input} should be rejected (degenerate scale)"
                );
            }
            // any finite positive value, however small, is accepted and
            // round-trips through one emit-reparse unchanged -- "1e-45" and
            // "5e-7" were rejected by the old 1e-6 floor.
            for scale in ["1e-45", "1e-10", "5e-7", "1e-6", "3.0"] {
                let input = format!("{name}({scale}, 0.1)");
                let node = parse_lol(&input).unwrap_or_else(|e| panic!("{input}: {e}"));
                let text = crate::emit::to_lol(&node)
                    .unwrap_or_else(|e| panic!("{input}: to_lol failed: {e}"));
                assert!(
                    parse_lol(&text).is_ok(),
                    "{input} -> {text:?} should re-parse"
                );
                assert_eq!(
                    text, input,
                    "{input} must round-trip bit-exact through emit/parse"
                );
            }
        }
    }

    /// `lattice_infill`/`diamond_infill`/`schwarz_infill` build an
    /// `SdfNode::Gyroid`/`DiamondSurface`/`SchwarzP` directly (a different
    /// surface syntax from the raw constructor, same underlying node type):
    /// the same scale/thickness constraint as
    /// `tpms_scale_and_thickness_reject_degenerate_values` must hold here
    /// too, or a tree built through this syntax can still reach the exact
    /// `-inf`/`inf` disagreement that change closed for the raw syntax --
    /// `emit` writes the SAME canonical `gyroid(...)`/etc. text for a node
    /// regardless of which syntax built it, so a degenerate value accepted
    /// here would merely move the round-trip failure to a different source
    /// text instead of removing it.
    #[test]
    fn infill_wrappers_reject_the_same_degenerate_tpms_fields() {
        for name in ["lattice_infill", "diamond_infill", "schwarz_infill"] {
            for scale in ["-0.0", "0.0", "-1.0", "-5e-7"] {
                let input = format!("{name}(1.0, {scale}, 0.1, sphere(1.0))");
                assert!(
                    parse_lol(&input).is_err(),
                    "{input} should be rejected (degenerate lattice scale)"
                );
            }
            // any finite positive lattice scale, however small, is accepted
            // ("1e-45"/"5e-7" were rejected by the old 1e-6 floor).
            for scale in ["1e-45", "5e-7", "3.0"] {
                let input = format!("{name}(1.0, {scale}, 0.1, sphere(1.0))");
                assert!(parse_lol(&input).is_ok(), "{input} should still parse");
            }
        }
    }

    /// `validate_tpms_fields`'s own `thickness.is_finite()` branch has no
    /// reachable text-level case: this lexer already refuses any literal
    /// that reads as `NaN`/`±inf` for every numeric field in the grammar
    /// (`read_number`'s own `!v.is_finite()` check, and "NaN"/"inf" are not
    /// even numeric syntax -- they lex as identifiers), before any
    /// constructor-specific validation runs. Exercise the branch directly,
    /// bypassing the lexer, so a mutant that deletes it is still caught
    /// (confirmed: a text-level case for this did NOT catch that mutant).
    #[test]
    fn tpms_fields_validation_rejects_non_finite_values_directly() {
        let p = Parser::new("");
        for bad_thickness in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
            assert!(
                p.validate_tpms_fields(3.0, bad_thickness).is_err(),
                "thickness={bad_thickness} should be rejected"
            );
        }
        for bad_scale in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, 0.0, -0.0, -1.0] {
            assert!(
                p.validate_tpms_fields(bad_scale, 0.1).is_err(),
                "scale={bad_scale} should be rejected"
            );
        }
        assert!(p.validate_tpms_fields(3.0, 0.1).is_ok());
        assert!(
            p.validate_tpms_fields(3.0, -5.0).is_ok(),
            "a negative thickness is not restricted"
        );
    }

    #[test]
    fn test_v10_3f_prims() {
        for (name, args) in [
            ("cut_hollow_sphere", "1.0, 0.3, 0.1"),
            ("death_star", "1.0, 0.5, 0.8"),
            ("rounded_x", "0.5, 0.1, 1.0"),
            ("pie", "0.5, 1.0, 0.5"),
            ("tunnel", "0.5, 0.8, 1.0"),
            ("parabola_segment", "0.5, 0.8, 1.0"),
            ("regular_polygon", "1.0, 6.0, 0.5"),
            ("rect_2d", "0.5, 0.3, 1.0"),
            ("annular_2d", "1.0, 0.1, 0.5"),
        ] {
            let input = format!("{name}({args})");
            assert!(parse_lol(&input).is_ok(), "failed: {input}");
        }
    }

    #[test]
    fn test_v10_4f_prims() {
        for (name, args) in [
            ("rhombus", "0.5, 0.3, 1.0, 0.05"),
            ("chamfered_cube", "0.5, 0.5, 0.5, 0.1"),
            ("trapezoid", "0.5, 0.3, 1.0, 0.5"),
            ("parallelogram", "0.5, 1.0, 0.2, 0.5"),
            ("uneven_capsule", "0.3, 0.5, 1.0, 0.5"),
            ("arc_shape", "0.5, 1.0, 0.1, 0.5"),
            ("moon", "0.5, 1.0, 0.8, 0.5"),
            ("stairs_prim", "0.3, 0.2, 5.0, 0.5"),
            ("rounded_rect_2d", "0.5, 0.3, 0.1, 1.0"),
        ] {
            let input = format!("{name}({args})");
            assert!(parse_lol(&input).is_ok(), "failed: {input}");
        }
    }

    #[test]
    fn test_v10_5f_prims() {
        assert!(parse_lol("horseshoe(0.5, 1.0, 0.3, 0.1, 0.05)").is_ok());
        assert!(parse_lol("superellipsoid(0.5, 0.5, 0.5, 1.0, 1.0)").is_ok());
    }

    #[test]
    fn test_v10_segment_2d() {
        assert!(parse_lol("segment_2d(0.0, 0.0, 1.0, 1.0, 0.1, 0.5)").is_ok());
    }

    #[test]
    fn test_v10_triangle_bezier() {
        assert!(parse_lol("triangle(0.0,0.0,0.0, 1.0,0.0,0.0, 0.5,1.0,0.0)").is_ok());
        assert!(parse_lol("bezier(0.0,0.0,0.0, 0.5,1.0,0.0, 1.0,0.0,0.0, 0.1)").is_ok());
    }

    #[test]
    fn test_v10_sweep_bezier() {
        assert!(
            parse_lol("sweep_bezier(0.0, 0.0, 0.5, 1.0, 1.0, 0.0, circle_2d(0.2, 0.5))").is_ok()
        );
    }

    // ── Phase 5.1 高階 primitive tests ──

    #[test]
    fn test_shopping_cart_coin() {
        let node = parse_lol("shopping_cart_coin(22.8, 1.7)").unwrap();
        match node {
            SdfNode::Cylinder {
                radius,
                half_height,
            } => {
                assert!((radius - 11.4).abs() < 1e-4);
                assert!((half_height - 0.85).abs() < 1e-4);
            }
            _ => panic!("expected Cylinder"),
        }
    }

    #[test]
    fn test_skadis_panel() {
        let node = parse_lol("skadis_panel(300, 5, 5)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_skadis_panel_variadic_defaults() {
        // 0-arg → SKADIS canonical (300 × 5 × 5) 全 case で
        // SdfNode 生成成功のみ verify (defaults の絶対値は
        // skadis_sdf::skadis_panel_sdf の canonical unit test に委ねる)
        // LLM UX 用の forgiving 動作 (2026-09-04 追加、text-to-print β
        // で LLM が「SKADISパネル 10✖10」→ `skadis_panel(10, 10)` 出力
        // する parse fail 事案由来)
        assert!(matches!(
            parse_lol("skadis_panel()").unwrap(),
            SdfNode::Subtraction { .. }
        ));
        assert!(matches!(
            parse_lol("skadis_panel(400)").unwrap(),
            SdfNode::Subtraction { .. }
        ));
        assert!(matches!(
            parse_lol("skadis_panel(10, 10)").unwrap(),
            SdfNode::Subtraction { .. }
        ));
        assert!(matches!(
            parse_lol("skadis_panel(300, 5, 5)").unwrap(),
            SdfNode::Subtraction { .. }
        ));
    }

    #[test]
    fn test_mug() {
        // Phase P.1 products primitive
        // マグカップ φ50 × H100 (円筒 + 内側くぼみ + torus 取手)
        let node = parse_lol("mug(50, 100)").unwrap();
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_skadis_hook_l_no_args() {
        let node = parse_lol("skadis_hook_l()").unwrap();
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_skadis_hook_j_no_args() {
        let node = parse_lol("skadis_hook_j()").unwrap();
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_skadis_hook_s_no_args() {
        let node = parse_lol("skadis_hook_s()").unwrap();
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_phase_5_1_high_level_primitives_eval_correctly() {
        // Phase 5.1 追加 5 primitive の parse + eval sanity check
        use alice_sdf::eval;
        for lol in [
            "shopping_cart_coin(22.8, 1.7)",
            "skadis_panel(300, 5, 5)",
            "skadis_hook_l()",
            "skadis_hook_j()",
            "skadis_hook_s()",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Phase B.1.b 高階 primitive tests (pattern_sdf 経路) ──

    #[test]
    fn test_gridfinity_bin_2x2_6u() {
        let node = parse_lol("gridfinity_bin(2, 2, 6)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_wall_hook_no_args() {
        let node = parse_lol("wall_hook()").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_drawer_organizer_no_args() {
        let node = parse_lol("drawer_organizer()").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_shelf_divider_no_args() {
        let node = parse_lol("shelf_divider()").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_phase_b_1_b_pattern_sdf_primitives_eval_correctly() {
        // Phase B.1.b 追加 4 primitive の parse + eval sanity check
        use alice_sdf::eval;
        for lol in [
            "gridfinity_bin(2, 2, 6)",
            "wall_hook()",
            "drawer_organizer()",
            "shelf_divider()",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Phase C: gridfinity_bin_ex (7 param advanced) tests ──

    #[test]
    fn test_gridfinity_bin_ex_no_dividers_no_walls() {
        // divx=0/divy=0 → dividers=None、wall=0/floor=0 → default (1.2, 1.5)
        let node = parse_lol("gridfinity_bin_ex(2, 2, 6, 0, 0, 0, 0)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_gridfinity_bin_ex_with_dividers_and_walls() {
        // 3×3 grid × 6U + dividers 2×2 + wall=1.5 + floor=2.0
        let node = parse_lol("gridfinity_bin_ex(3, 3, 6, 2, 2, 1.5, 2.0)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    // ── Phase B: PART 2 archetype tests ──

    #[test]
    fn test_sticky_note_holder_small_square() {
        let node = parse_lol("sticky_note_holder(76, 76, 30)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_business_card_holder_jp_meishi() {
        let node = parse_lol("business_card_holder(91, 55, 22)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_pen_cup_standard() {
        let node = parse_lol("pen_cup(75, 100)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_phone_stand_with_cable_hole() {
        let node = parse_lol("phone_stand(14, 100, 18)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_phone_stand_no_cable_hole() {
        // cable_hole_dia=0 で穴なし、それでも slot subtract で Subtraction
        let node = parse_lol("phone_stand(14, 100, 0)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_phase_b_part2_archetypes_eval_correctly() {
        // organizer-gridfinity-desk PART 2 追加 4 archetype の parse + eval sanity check
        use alice_sdf::eval;
        for lol in [
            "sticky_note_holder(76, 76, 30)",
            "business_card_holder(91, 55, 22)",
            "pen_cup(75, 100)",
            "phone_stand(14, 100, 18)",
            "gridfinity_bin_ex(3, 3, 6, 2, 2, 1.5, 2.0)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Phase B2: PART 2 完成 4 archetype tests ──

    // 2026-08-20 (v2): archetype 別 print-optimal 方針
    // - headphone_holder / under_desk_mount: unwrap (Subtraction/SmoothUnion)
    // - desk_shelf / tissue_box_cover: to_z_up_flipped (Rotate)

    #[test]
    fn test_headphone_holder_wall_mount() {
        let node = parse_lol("headphone_holder(80, 50, 100)").unwrap();
        // unwrap 済、mount_hole あり → Subtraction (mount plate flat 印刷姿勢)
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_under_desk_mount_standard() {
        let node = parse_lol("under_desk_mount(25, 40, 4)").unwrap();
        // unwrap 済、screw_hole あり → Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_under_desk_mount_no_screw() {
        // screw=0 で穴なし、unwrap 済 → SmoothUnion (両面テープ想定)
        let node = parse_lol("under_desk_mount(25, 40, 0)").unwrap();
        assert!(matches!(node, SdfNode::SmoothUnion { .. }));
    }

    #[test]
    fn test_desk_shelf_desktop() {
        let node = parse_lol("desk_shelf(400, 200, 100)").unwrap();
        // to_z_up_flipped で Rotate top-level (shelf 下 印刷)
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_monitor_riser_compact() {
        let node = parse_lol("monitor_riser(250, 180, 90)").unwrap();
        // cable_hole 有 → Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_phase_b2_part2_archetypes_eval_correctly() {
        // organizer-gridfinity-desk PART 2 B2 追加 4 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "headphone_holder(80, 50, 100)",
            "under_desk_mount(25, 40, 4)",
            "desk_shelf(400, 200, 100)",
            "monitor_riser(250, 180, 90)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 4: household.md 3 archetype tests ──

    #[test]
    fn test_coaster_round() {
        let node = parse_lol("coaster(95, 5)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_tissue_box_cover_rectangular_us() {
        let node = parse_lol("tissue_box_cover(231, 116, 53)").unwrap();
        // to_z_up_flipped wrap で Rotate top-level (slot 下 印刷 upside-down)
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_storage_box_medium() {
        let node = parse_lol("storage_box(150, 100, 60)").unwrap();
        // to_z_up wrap で Rotate top-level (内部 Subtraction)
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint4_household_archetypes_eval_correctly() {
        // household.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "coaster(95, 5)",
            "tissue_box_cover(231, 116, 53)",
            "storage_box(150, 100, 60)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 5: hobby-diy.md 4 archetype tests ──

    #[test]
    fn test_cable_clip_hdmi() {
        let node = parse_lol("cable_clip(7, 28)").unwrap();
        // cavity + slot 2 段 subtract で最終 Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_led_channel_ws2812b() {
        let node = parse_lol("led_channel(10, 300)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_card_tray_poker() {
        let node = parse_lol("card_tray(63, 88, 30)").unwrap();
        // to_z_up wrap で Rotate top-level
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_token_well_dice_4() {
        let node = parse_lol("token_well(20, 20, 4)").unwrap();
        // to_z_up wrap で Rotate top-level
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_token_well_count_zero_defaults_to_one() {
        // count=0 → max(1) で 1 well 生成 (defensive)
        let node = parse_lol("token_well(15, 10, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint5_hobby_diy_archetypes_eval_correctly() {
        // hobby-diy.md 追加 4 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "cable_clip(7, 28)",
            "led_channel(10, 300)",
            "card_tray(63, 88, 30)",
            "token_well(20, 20, 4)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 6: tools.md 3 archetype tests ──

    #[test]
    fn test_wrench_holder_metric_6() {
        let node = parse_lol("wrench_holder(8, 19, 6)").unwrap();
        // to_z_up wrap で Rotate top-level
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_socket_rail_half_inch_6() {
        let node = parse_lol("socket_rail(12.4, 22, 6)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_hex_bit_holder_grid_4x5() {
        let node = parse_lol("hex_bit_holder(5, 4, 12)").unwrap();
        // Z-up direct、hex subtract で Subtraction top-level
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_hex_bit_holder_count_zero_defaults_to_one() {
        // rows=0 cols=0 → max(1) で 1×1 hex 生成 (defensive)
        let node = parse_lol("hex_bit_holder(0, 0, 12)").unwrap();
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_sprint6_tools_archetypes_eval_correctly() {
        // tools.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "wrench_holder(8, 19, 6)",
            "socket_rail(12.4, 22, 6)",
            "hex_bit_holder(5, 4, 12)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 7: electronics-enclosure.md 3 archetype tests ──

    #[test]
    fn test_raspi_case_rpi5() {
        let node = parse_lol("raspi_case(85, 56, 25)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_esp32_enclosure_devkit() {
        let node = parse_lol("esp32_enclosure(51.6, 28.4, 15)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_battery_18650_holder_row_4() {
        let node = parse_lol("battery_18650_holder(4, 2.5, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_battery_18650_holder_count_zero_defaults_to_one() {
        let node = parse_lol("battery_18650_holder(0, 2.5, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint7_electronics_archetypes_eval_correctly() {
        // electronics-enclosure.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "raspi_case(85, 56, 25)",
            "esp32_enclosure(51.6, 28.4, 15)",
            "battery_18650_holder(4, 2.5, 0)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 8: organizer-bathroom-garage.md 3 archetype tests ──

    #[test]
    fn test_toothbrush_holder_manual_4() {
        let node = parse_lol("toothbrush_holder(4, 15, 70)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_drill_bit_holder_metric() {
        let node = parse_lol("drill_bit_holder(3, 13, 11)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_pliers_rack_standard_6() {
        let node = parse_lol("pliers_rack(6, 15, 60)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint8_bathroom_garage_archetypes_eval_correctly() {
        // organizer-bathroom-garage.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "toothbrush_holder(4, 15, 70)",
            "drill_bit_holder(3, 13, 11)",
            "pliers_rack(6, 15, 60)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 9: organizer-cable-kitchen.md 3 archetype tests ──

    #[test]
    fn test_spice_rack_standard_6() {
        let node = parse_lol("spice_rack(6, 48, 100)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_egg_tray_4x3() {
        let node = parse_lol("egg_tray(3, 4, 18)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_utensil_caddy_standard_4() {
        let node = parse_lol("utensil_caddy(4, 65, 130)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint9_cable_kitchen_archetypes_eval_correctly() {
        // organizer-cable-kitchen.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "spice_rack(6, 48, 100)",
            "egg_tray(3, 4, 18)",
            "utensil_caddy(4, 65, 130)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 10: organizer-printer-modular.md 3 archetype tests ──

    #[test]
    fn test_filament_spool_holder_1kg() {
        let node = parse_lol("filament_spool_holder(200, 68, 52)").unwrap();
        // Z-up direct、base + peg union
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_nozzle_holder_m6_row_8() {
        let node = parse_lol("nozzle_holder(8, 8, 6)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_build_plate_rack_standard_5() {
        let node = parse_lol("build_plate_rack(5, 15, 200)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint10_printer_modular_archetypes_eval_correctly() {
        // organizer-printer-modular.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "filament_spool_holder(200, 68, 52)",
            "nozzle_holder(8, 8, 6)",
            "build_plate_rack(5, 15, 200)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 11: organizer-drawer-wall.md 3 archetype tests ──

    #[test]
    fn test_cutlery_tray_standard_3() {
        let node = parse_lol("cutlery_tray(3, 35, 220)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_pill_organizer_weekly_7x2() {
        let node = parse_lol("pill_organizer(7, 2, 20)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_magnetic_strip_knife_rail_8() {
        let node = parse_lol("magnetic_strip(8, 6, 30)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint11_drawer_wall_archetypes_eval_correctly() {
        // organizer-drawer-wall.md 追加 3 archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "cutlery_tray(3, 35, 220)",
            "pill_organizer(7, 2, 20)",
            "magnetic_strip(8, 6, 30)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 12 ミックス archetype tests ──

    #[test]
    fn test_hairdryer_holder_dyson() {
        let node = parse_lol("hairdryer_holder(85, 110, 3)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_kcup_holder_4x3() {
        let node = parse_lol("kcup_holder(3, 4, 53)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_hex_key_holder_metric_9() {
        let node = parse_lol("hex_key_holder(9, 1.5, 10)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint12_mix_archetypes_eval_correctly() {
        // Sprint 12 ミックス archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "hairdryer_holder(85, 110, 3)",
            "kcup_holder(3, 4, 53)",
            "hex_key_holder(9, 1.5, 10)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 13 ミックス archetype tests ──

    #[test]
    fn test_wrap_holder_foil_12inch() {
        let node = parse_lol("wrap_holder(55, 305, 3)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sock_divider_standard_4() {
        let node = parse_lol("sock_divider(4, 80, 89)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_soap_tray_dual_bottle() {
        let node = parse_lol("soap_tray(200, 90, 6)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint13_mix_archetypes_eval_correctly() {
        // Sprint 13 ミックス archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "wrap_holder(55, 305, 3)",
            "sock_divider(4, 80, 89)",
            "soap_tray(200, 90, 6)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 14 ミックス archetype tests ──

    #[test]
    fn test_razor_holder_cartridge() {
        let node = parse_lol("razor_holder(12, 22, 4.5)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_chopstick_holder_adult_4() {
        let node = parse_lol("chopstick_holder(4, 13, 260)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_swatch_holder_standard_8x4() {
        let node = parse_lol("swatch_holder(8, 4, 32)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint14_mix_archetypes_eval_correctly() {
        // Sprint 14 ミックス archetype の parse + eval sanity
        use alice_sdf::eval;
        for lol in [
            "razor_holder(12, 22, 4.5)",
            "chopstick_holder(4, 13, 260)",
            "swatch_holder(8, 4, 32)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 15 ミックス archetype tests ──

    #[test]
    fn test_tp_holder_standard() {
        let node = parse_lol("tp_holder(40, 110, 5)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sd_card_holder_full_sd_4x4() {
        let node = parse_lol("sd_card_holder(4, 4, 24)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_driver_rack_standard_8() {
        let node = parse_lol("driver_rack(8, 25, 100)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint15_mix_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "tp_holder(40, 110, 5)",
            "sd_card_holder(4, 4, 24)",
            "driver_rack(8, 25, 100)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 16 ミックス 5 archetype tests ──

    #[test]
    fn test_cotton_dispenser_standard() {
        let node = parse_lol("cotton_dispenser(80, 90, 100)").unwrap();
        // cotton_dispenser は Z-axis direct、to_z_up wrap なし = Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_sink_caddy_standard_l200() {
        let node = parse_lol("sink_caddy(200, 100, 8)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_clamp_rack_standard_5() {
        let node = parse_lol("clamp_rack(5, 30, 150)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint16_mix_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "cotton_dispenser(80, 90, 100)",
            "sink_caddy(200, 100, 8)",
            "clamp_rack(5, 30, 150)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 17 ミックス 6 archetype tests ──

    #[test]
    fn test_dry_box_standard_2x2() {
        let node = parse_lol("dry_box(2, 2, 68)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_outdoor_enclosure_ip54() {
        let node = parse_lol("outdoor_enclosure(120, 80, 45)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_jewelry_stand_standard_3_tier() {
        let node = parse_lol("jewelry_stand(3, 100, 100)").unwrap();
        // jewelry_stand は Z-axis direct + tier disk union、to_z_up wrap なし
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_sprint17_mix_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "dry_box(2, 2, 68)",
            "outdoor_enclosure(120, 80, 45)",
            "jewelry_stand(3, 100, 100)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 18 ミックス 7 archetype tests ──

    #[test]
    fn test_phone_dock_standard() {
        let node = parse_lol("phone_dock(80, 100, 8)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_cutting_board_rack_standard_3() {
        let node = parse_lol("cutting_board_rack(3, 12, 220)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_tape_dispenser_packing_standard() {
        let node = parse_lol("tape_dispenser(76, 50, 3)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint18_mix_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "phone_dock(80, 100, 8)",
            "cutting_board_rack(3, 12, 220)",
            "tape_dispenser(76, 50, 3)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 19 ミックス 8 archetype tests ──

    #[test]
    fn test_shower_caddy_standard_2_tier() {
        let node = parse_lol("shower_caddy(2, 250, 120)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_caliper_holder_standard_3() {
        let node = parse_lol("caliper_holder(150, 40, 3)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_bag_clip_org_standard_8() {
        let node = parse_lol("bag_clip_org(8, 8, 100)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint19_mix_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "shower_caddy(2, 250, 120)",
            "caliper_holder(150, 40, 3)",
            "bag_clip_org(8, 8, 100)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 20 ミックス 9 archetype tests ──

    #[test]
    fn test_can_rack_standard_2_tier() {
        let node = parse_lol("can_rack(2, 66, 10)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_led_hub_box_standard() {
        let node = parse_lol("led_hub_box(80, 60, 30)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_makeup_organizer_standard_3x4() {
        let node = parse_lol("makeup_organizer(3, 4, 45)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint20_mix_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "can_rack(2, 66, 10)",
            "led_hub_box(80, 60, 30)",
            "makeup_organizer(3, 4, 45)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 21 Phase X.1 機械要素 tests ──

    #[test]
    fn test_vesa_mount_75_m4() {
        let node = parse_lol("vesa_mount(75, 5, 4)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_vesa_mount_100_m5() {
        let node = parse_lol("vesa_mount(100, 6, 5)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_l_bracket_m4_2holes() {
        let node = parse_lol("l_bracket(60, 60, 4, 4, 2)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_l_bracket_m5_3holes() {
        let node = parse_lol("l_bracket(80, 80, 5, 5, 3)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint21_mechanical_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "vesa_mount(75, 5, 4)",
            "vesa_mount(100, 6, 5)",
            "l_bracket(60, 60, 4, 4, 2)",
            "l_bracket(80, 80, 5, 5, 3)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 21 Phase X.1 追加 8 archetype tests ──

    #[test]
    fn test_t_slot_bracket_2020_standard() {
        let node = parse_lol("t_slot_bracket_2020(20, 20)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_raspi_mount_plate_pi4b() {
        let node = parse_lol("raspi_mount_plate(4, 4)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_raspi_mount_plate_zero() {
        let node = parse_lol("raspi_mount_plate(0, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_heat_set_array_m3_2x2() {
        let node = parse_lol("heat_set_array(2, 2, 3, 20, 6)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_flange_mount_od80_m5_4() {
        let node = parse_lol("flange_mount(80, 5, 4)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_dovetail_pair_male() {
        let node = parse_lol("dovetail_pair(20, 15, 10, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_dovetail_pair_female() {
        let node = parse_lol("dovetail_pair(20, 15, 10, 1)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_profile_extrusion_2020() {
        let node = parse_lol("profile_extrusion(20, 100)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_profile_extrusion_3030() {
        let node = parse_lol("profile_extrusion(30, 100)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_snap_fit_pair_standard() {
        let node = parse_lol("snap_fit_pair(20, 5, 2, 1)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_boss_array_m3_2x2() {
        let node = parse_lol("boss_array(2, 2, 3, 10, 20, 2)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_sprint21_extra8_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "t_slot_bracket_2020(20, 20)",
            "t_slot_bracket_2020(40, 40)",
            "raspi_mount_plate(4, 4)",
            "raspi_mount_plate(0, 0)",
            "heat_set_array(2, 2, 3, 20, 6)",
            "heat_set_array(3, 3, 4, 25, 8)",
            "flange_mount(80, 5, 4)",
            "flange_mount(100, 6, 6)",
            "dovetail_pair(20, 15, 10, 0)",
            "dovetail_pair(20, 15, 10, 1)",
            "profile_extrusion(20, 100)",
            "profile_extrusion(30, 100)",
            "snap_fit_pair(20, 5, 2, 1)",
            "boss_array(2, 2, 3, 10, 20, 2)",
            "boss_array(3, 3, 4, 15, 25, 3)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Sprint 22 Phase X.2 fastener 6 primitive tests ──

    #[test]
    fn test_screw_hole_m4() {
        let node = parse_lol("screw_hole(4, 10)").unwrap();
        // screw_hole returns Cylinder (Y-up native)
        assert!(matches!(node, SdfNode::Cylinder { .. }));
    }

    #[test]
    fn test_screw_hole_m2_5_pi() {
        // SBC mount M2.5 = snap to M2_5
        let node = parse_lol("screw_hole(2.5, 8)").unwrap();
        assert!(matches!(node, SdfNode::Cylinder { .. }));
    }

    #[test]
    fn test_tap_hole_m3() {
        let node = parse_lol("tap_hole(3, 6)").unwrap();
        assert!(matches!(node, SdfNode::Cylinder { .. }));
    }

    #[test]
    fn test_counterbore_m4() {
        let node = parse_lol("counterbore(4, 8)").unwrap();
        // counterbore returns Union (through hole + bore)
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_countersink_m4() {
        let node = parse_lol("countersink(4, 8)").unwrap();
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_heat_set_hole_m3() {
        let node = parse_lol("heat_set_hole(3)").unwrap();
        assert!(matches!(node, SdfNode::Cylinder { .. }));
    }

    #[test]
    fn test_heat_set_hole_m2_pi() {
        // M2 Pi Zero mount
        let node = parse_lol("heat_set_hole(2)").unwrap();
        assert!(matches!(node, SdfNode::Cylinder { .. }));
    }

    #[test]
    fn test_bolt_m5() {
        let node = parse_lol("bolt(5, 20)").unwrap();
        // bolt returns Union (shank + head)
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    // ── Sprint 22 Phase X.2 low-level mount / joint / reinforcement tests ──

    #[test]
    fn test_bracket_l_raw() {
        let node = parse_lol("bracket_l(60, 40, 4, 40, 3)").unwrap();
        // bracket_l with fillet returns SmoothUnion
        assert!(matches!(node, SdfNode::SmoothUnion { .. }));
    }

    #[test]
    fn test_flange_circular_raw() {
        let node = parse_lol("flange_circular(60, 20, 6, 45, 4, 4.2)").unwrap();
        // flange with center_bore returns Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_t_slot_2020_raw() {
        let node = parse_lol("t_slot_2020(100)").unwrap();
        // t_slot_2020 returns Union (opening + inner)
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_profile_2020_raw() {
        use alice_sdf::eval;
        let node = parse_lol("profile_2020(100)").unwrap();
        // profile is composite, just parses
        let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
        assert!(d.is_finite());
    }

    #[test]
    fn test_profile_3030_raw() {
        use alice_sdf::eval;
        let node = parse_lol("profile_3030(100)").unwrap();
        let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
        assert!(d.is_finite());
    }

    #[test]
    fn test_dovetail_raw() {
        let node = parse_lol("dovetail(10, 5, 20)").unwrap();
        // dovetail returns Intersection (base ∩ 2 planes)
        assert!(matches!(node, SdfNode::Intersection { .. }));
    }

    #[test]
    fn test_slot_raw() {
        let node = parse_lol("slot(20, 4, 6)").unwrap();
        // slot returns nested Union
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_snap_fit_annular_raw() {
        let node = parse_lol("snap_fit_annular(8, 20, 0.5, 7)").unwrap();
        assert!(matches!(node, SdfNode::Union { .. }));
    }

    #[test]
    fn test_pin_hinge_knuckle_raw() {
        let node = parse_lol("pin_hinge_knuckle(3, 8, 8)").unwrap();
        // barrel - pin = Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_boss_raw() {
        let node = parse_lol("boss(3, 8)").unwrap();
        // boss = barrel - tap_hole = Subtraction
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_rib_raw() {
        let node = parse_lol("rib(20, 10, 2)").unwrap();
        assert!(matches!(node, SdfNode::Box3d { .. }));
    }

    #[test]
    fn test_sprint22_phase_x2_primitives_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            // fastener 6
            "screw_hole(4, 10)",
            "screw_hole(2.5, 8)",
            "tap_hole(3, 6)",
            "counterbore(4, 8)",
            "countersink(4, 8)",
            "heat_set_hole(3)",
            "heat_set_hole(2)",
            "bolt(5, 20)",
            // mount / joint / reinforcement 11
            "bracket_l(60, 40, 4, 40, 3)",
            "flange_circular(60, 20, 6, 45, 4, 4.2)",
            "t_slot_2020(100)",
            "profile_2020(100)",
            "profile_3030(100)",
            "dovetail(10, 5, 20)",
            "slot(20, 4, 6)",
            "snap_fit_annular(8, 20, 0.5, 7)",
            "pin_hinge_knuckle(3, 8, 8)",
            "boss(3, 8)",
            "rib(20, 10, 2)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    #[test]
    fn test_sprint22_composition_example() {
        // 「M4 貫通穴 4 隅の 60×5×60 プレート」を LOL DSL 組合せで
        // subtract(rounded_box(30, 2.5, 30, 3), translate(screw_hole(4, 10), ...))
        // という pattern が parse できるか確認 (LLM が生成する典型例)
        let lol = "subtract(rounded_box(30, 2.5, 30, 3), screw_hole(4, 10))";
        let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    // ── Sprint 22 Phase X.2 MetricSize::M2 / M2_5 f32 snap tests ──

    #[test]
    fn test_metric_size_m2_snap_via_screw_hole() {
        use alice_sdf::SdfNode as S;
        // screw_hole(2.0, ...) should map to M2 → Cylinder radius = (2.0 + 0.2) / 2 = 1.1
        let node = parse_lol("screw_hole(2, 5)").unwrap();
        if let S::Cylinder { radius, .. } = node {
            assert!(
                (radius - 1.1).abs() < 1e-4,
                "M2 clearance radius = 1.1, got {radius}"
            );
        } else {
            panic!("expected Cylinder");
        }
    }

    #[test]
    fn test_metric_size_m2_5_snap_via_screw_hole() {
        use alice_sdf::SdfNode as S;
        // screw_hole(2.5, ...) → M2_5 → radius = (2.5 + 0.2) / 2 = 1.35
        let node = parse_lol("screw_hole(2.5, 5)").unwrap();
        if let S::Cylinder { radius, .. } = node {
            assert!(
                (radius - 1.35).abs() < 1e-4,
                "M2.5 clearance radius = 1.35, got {radius}"
            );
        } else {
            panic!("expected Cylinder");
        }
    }

    // ── Sprint 22 続行 mechanical primitive tests (2026-08-28) ──

    #[test]
    fn test_bearing_seat_608_press_fit() {
        let node = parse_lol("bearing_seat(22, 5, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_bearing_seat_608_slip_fit() {
        let node = parse_lol("bearing_seat(22, 5, 1)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_bearing_seat_688_snap() {
        // 16.0 は B688 に snap
        let node = parse_lol("bearing_seat(16, 4, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_rack_shelf_raw_5_notch() {
        // rack_shelf(length, thickness, width, notch_pitch, notch_dia, notch_count)
        let node = parse_lol("rack_shelf(200, 5, 30, 25, 6, 2)").unwrap();
        // rack_shelf returns Subtraction (plate - notch_row)
        assert!(matches!(node, SdfNode::Subtraction { .. }));
    }

    #[test]
    fn test_sprint22_mechanical_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "bearing_seat(22, 5, 0)",
            "bearing_seat(22, 5, 1)",
            "bearing_seat(16, 4, 0)",
            "rack_shelf(200, 5, 30, 25, 6, 2)",
            "rack_shelf(400, 6, 40, 35, 8, 3)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── Multi-domain 展開 tests (家具 + 建築、2026-08-28) ──

    #[test]
    fn test_cable_grommet_standard_60() {
        let node = parse_lol("cable_grommet(60, 15)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_curtain_rod_bracket_standard() {
        let node = parse_lol("curtain_rod_bracket(25, 120)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_dowel_hole_standard_8() {
        let node = parse_lol("dowel_hole(8, 15)").unwrap();
        // dowel_hole returns raw Cylinder (Y-up)
        assert!(matches!(node, SdfNode::Cylinder { .. }));
    }

    #[test]
    fn test_wood_screw_pilot_softwood() {
        let node = parse_lol("wood_screw_pilot(4, 0)").unwrap();
        if let SdfNode::Cylinder { radius, .. } = node {
            // 4 × 0.7 = 2.8 → radius 1.4
            assert!((radius - 1.4).abs() < 1e-4, "softwood #8 radius = 1.4");
        } else {
            panic!("expected Cylinder");
        }
    }

    #[test]
    fn test_wood_screw_pilot_hardwood() {
        let node = parse_lol("wood_screw_pilot(4, 1)").unwrap();
        if let SdfNode::Cylinder { radius, .. } = node {
            // 4 × 0.9 = 3.6 → radius 1.8
            assert!((radius - 1.8).abs() < 1e-4, "hardwood #8 radius = 1.8");
        } else {
            panic!("expected Cylinder");
        }
    }

    #[test]
    fn test_multidomain_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "cable_grommet(60, 15)",
            "cable_grommet(80, 20)",
            "curtain_rod_bracket(25, 120)",
            "curtain_rod_bracket(30, 150)",
            "dowel_hole(8, 15)",
            "dowel_hole(6, 10)",
            "wood_screw_pilot(4, 0)",
            "wood_screw_pilot(5, 1)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }

    // ── 電子工作 domain tests (Arduino / Pixhawk / Servo / JST-PH、2026-08-28) ──

    #[test]
    fn test_arduino_mount_uno() {
        let node = parse_lol("arduino_mount_plate(1, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_arduino_mount_uno_vesa() {
        let node = parse_lol("arduino_mount_plate(1, 4)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_arduino_mount_nano() {
        let node = parse_lol("arduino_mount_plate(3, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_pixhawk_45_solid() {
        let node = parse_lol("pixhawk_mount(45, 0)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_pixhawk_45_damper() {
        let node = parse_lol("pixhawk_mount(45, 1)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_servo_sg90() {
        let node = parse_lol("servo_mount(1)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_servo_mg996r() {
        let node = parse_lol("servo_mount(2)").unwrap();
        assert!(matches!(node, SdfNode::Rotate { .. }));
    }

    #[test]
    fn test_jst_ph_slot_4pin() {
        let node = parse_lol("jst_ph_slot(4)").unwrap();
        // JST-PH slot returns raw Box3d (Y-up)
        assert!(matches!(node, SdfNode::Box3d { .. }));
    }

    #[test]
    fn test_electronics_archetypes_eval_correctly() {
        use alice_sdf::eval;
        for lol in [
            "arduino_mount_plate(1, 0)",
            "arduino_mount_plate(1, 4)",
            "arduino_mount_plate(2, 0)",
            "arduino_mount_plate(3, 0)",
            "pixhawk_mount(45, 0)",
            "pixhawk_mount(45, 1)",
            "pixhawk_mount(30, 0)",
            "servo_mount(1)",
            "servo_mount(2)",
            "jst_ph_slot(2)",
            "jst_ph_slot(4)",
        ] {
            let node = parse_lol(lol).unwrap_or_else(|e| panic!("{lol}: {e:?}"));
            let d = eval(&node, Vec3::new(0.1, 0.1, 0.1));
            assert!(d.is_finite(), "{lol}: non-finite SDF at (0.1,0.1,0.1)");
        }
    }
}