brink-syntax 0.0.16

//! Typed AST node wrappers for every node kind in the ink CST.
//!
//! Each struct is a zero-cost newtype around [`SyntaxNode`] generated by
//! [`ast_node!`]. Structs with hand-written accessors have `impl` blocks
//! below their definition.

use crate::SyntaxKind::{
    self, AMP, AMP_AMP, BANG, BANG_EQ, BANG_QUESTION, CARET, COLON, DIVERT, DOLLAR, EQ, EQ_EQ,
    FLOAT, GT, GT_EQ, HASH, IDENT, INTEGER, KW_AND, KW_CYCLE, KW_DONE, KW_ELSE, KW_END, KW_FALSE,
    KW_FUNCTION, KW_HAS, KW_HASNT, KW_MOD, KW_NOT, KW_ONCE, KW_OR, KW_REF, KW_SHUFFLE, KW_STOPPING,
    KW_TODO, KW_TRUE, L_PAREN, LT, LT_EQ, MINUS, MINUS_EQ, NEWLINE, PERCENT, PIPE, PLUS, PLUS_EQ,
    QUESTION, R_PAREN, SLASH, STAR, TILDE,
};
use crate::ast::AstNode as _;
use crate::ast::ast_node;
use crate::ast::support;
use crate::{SyntaxNode, SyntaxToken};

// ── Top-level ────────────────────────────────────────────────────────

ast_node!(SourceFile, SOURCE_FILE);
ast_node!(IncludeStmt, INCLUDE_STMT);
ast_node!(ImportStmt, IMPORT_STMT);
ast_node!(ImportList, IMPORT_LIST);
ast_node!(ImportItem, IMPORT_ITEM);
ast_node!(ImportModule, IMPORT_MODULE);
ast_node!(FilePath, FILE_PATH);
ast_node!(ExternalDecl, EXTERNAL_DECL);

// ── Knots & stitches ─────────────────────────────────────────────────

ast_node!(KnotDef, KNOT_DEF);
ast_node!(KnotHeader, KNOT_HEADER);
ast_node!(KnotBody, KNOT_BODY);
ast_node!(KnotParams, KNOT_PARAMS);
ast_node!(KnotParamDecl, KNOT_PARAM_DECL);
ast_node!(StitchDef, STITCH_DEF);
ast_node!(StitchHeader, STITCH_HEADER);
ast_node!(StitchBody, STITCH_BODY);

// ── Lines ────────────────────────────────────────────────────────────

ast_node!(EmptyLine, EMPTY_LINE);
ast_node!(AuthorWarning, AUTHOR_WARNING);
ast_node!(LogicLine, LOGIC_LINE);
ast_node!(ContentLine, CONTENT_LINE);
ast_node!(TagLine, TAG_LINE);
ast_node!(AnnotationLine, ANNOTATION_LINE);
ast_node!(StrayClosingBrace, STRAY_CLOSING_BRACE);

// ── Logic ────────────────────────────────────────────────────────────

ast_node!(ReturnStmt, RETURN_STMT);
ast_node!(TempDecl, TEMP_DECL);
ast_node!(Assignment, ASSIGNMENT);
ast_node!(AwaitStmt, AWAIT_STMT);

// ── Content ──────────────────────────────────────────────────────────

ast_node!(MixedContent, MIXED_CONTENT);
ast_node!(Text, TEXT);
ast_node!(Escape, ESCAPE);
ast_node!(GlueNode, GLUE_NODE);

// ── Choices ──────────────────────────────────────────────────────────

ast_node!(Choice, CHOICE);
ast_node!(ChoiceBullets, CHOICE_BULLETS);
ast_node!(Label, LABEL);
ast_node!(ChoiceCondition, CHOICE_CONDITION);
ast_node!(ChoiceStartContent, CHOICE_START_CONTENT);
ast_node!(ChoiceBracketContent, CHOICE_BRACKET_CONTENT);
ast_node!(ChoiceInnerContent, CHOICE_INNER_CONTENT);

// ── Gathers ──────────────────────────────────────────────────────────

ast_node!(Gather, GATHER);
ast_node!(GatherDashes, GATHER_DASHES);

// ── Tags ─────────────────────────────────────────────────────────────

ast_node!(Tags, TAGS);
ast_node!(Tag, TAG);

// ── Inline logic ─────────────────────────────────────────────────────

ast_node!(InlineLogic, INLINE_LOGIC);
ast_node!(MultilineBlock, MULTILINE_BLOCK);
ast_node!(SequenceWithAnnotation, SEQUENCE_WITH_ANNOTATION);
ast_node!(SequenceSymbolAnnotation, SEQUENCE_SYMBOL_ANNOTATION);
ast_node!(SequenceWordAnnotation, SEQUENCE_WORD_ANNOTATION);
ast_node!(InlineBranchesSeq, INLINE_BRANCHES_SEQ);
ast_node!(MultilineBranchesSeq, MULTILINE_BRANCHES_SEQ);
ast_node!(MultilineBranchSeq, MULTILINE_BRANCH_SEQ);
ast_node!(BranchContent, BRANCH_CONTENT);

// ── Conditionals ─────────────────────────────────────────────────────

ast_node!(ConditionalWithExpr, CONDITIONAL_WITH_EXPR);
ast_node!(BranchlessCondBody, BRANCHLESS_COND_BODY);
ast_node!(ElseBranch, ELSE_BRANCH);
ast_node!(InlineBranchesCond, INLINE_BRANCHES_COND);
ast_node!(MultilineBranchesCond, MULTILINE_BRANCHES_COND);
ast_node!(MultilineConditional, MULTILINE_CONDITIONAL);
ast_node!(MultilineBranchCond, MULTILINE_BRANCH_COND);
ast_node!(MultilineBranchBody, MULTILINE_BRANCH_BODY);
ast_node!(ImplicitSequence, IMPLICIT_SEQUENCE);

// ── Expressions ──────────────────────────────────────────────────────

ast_node!(InnerExpression, INNER_EXPRESSION);
ast_node!(PrefixExpr, PREFIX_EXPR);
ast_node!(PostfixExpr, POSTFIX_EXPR);
ast_node!(InfixExpr, INFIX_EXPR);
ast_node!(ParenExpr, PAREN_EXPR);
ast_node!(FunctionCall, FUNCTION_CALL);
ast_node!(ArgList, ARG_LIST);
ast_node!(DivertTargetExpr, DIVERT_TARGET_EXPR);
ast_node!(ListExpr, LIST_EXPR);

// ── T1b superset: sigil literals + indexing (docs/t1b-surface-spec.md §3-4) ──

ast_node!(ArrayLiteral, ARRAY_LITERAL);
ast_node!(MapLiteral, MAP_LITERAL);
ast_node!(MapEntry, MAP_ENTRY);
ast_node!(IndexExpr, INDEX_EXPR);
ast_node!(RangeExpr, RANGE_EXPR);

// ── T1b superset: multi-line `~ { … }` blocks (docs/t1b-surface-spec.md §2) ──

ast_node!(StmtBlock, STMT_BLOCK);
ast_node!(IfStmt, IF_STMT);
ast_node!(ElseClause, ELSE_CLAUSE);
ast_node!(WhileStmt, WHILE_STMT);
ast_node!(ForStmt, FOR_STMT);
ast_node!(BreakStmt, BREAK_STMT);
ast_node!(ContinueStmt, CONTINUE_STMT);
ast_node!(ExprStmt, EXPR_STMT);

// ── TM-2 inline type annotations (docs/typed-mode-spec.md §3) ────────

ast_node!(TypeAnnotation, TYPE_ANNOTATION);
ast_node!(TypeExpr, TYPE_EXPR);
ast_node!(TypeName, TYPE_NAME);
ast_node!(TypeGeneric, TYPE_GENERIC);
ast_node!(TypeFn, TYPE_FN);

// ── TM-4b structs (docs/typed-mode-spec.md §6) ────────────────────────

ast_node!(StructDecl, STRUCT_DECL);
ast_node!(StructFieldDecl, STRUCT_FIELD_DECL);
ast_node!(StructLiteral, STRUCT_LITERAL);
ast_node!(StructFieldInit, STRUCT_FIELD_INIT);
ast_node!(FieldAccessExpr, FIELD_ACCESS_EXPR);

// ── T1c function values (docs/t1c-spec.md §2) ─────────────────────────

ast_node!(FnLiteral, FN_LITERAL);

// ── T1e path projections (docs/t1e-spec.md §2) ────────────────────────

ast_node!(RefExpr, REF_EXPR);

// ── Computed-callee call attempt (docs/t1c-spec.md §3/§10, issue #869) ──

ast_node!(CallExpr, CALL_EXPR);

// ── Diverts ──────────────────────────────────────────────────────────

ast_node!(DivertNode, DIVERT_NODE);
ast_node!(SimpleDivert, SIMPLE_DIVERT);
ast_node!(DivertTargetWithArgs, DIVERT_TARGET_WITH_ARGS);
ast_node!(ThreadStart, THREAD_START);
ast_node!(TunnelOnwardsNode, TUNNEL_ONWARDS_NODE);
ast_node!(TunnelCallNode, TUNNEL_CALL_NODE);

// ── TM-2 inline type annotations (docs/typed-mode-spec.md §3) ────────

impl TypeAnnotation {
    /// The annotated type expression after `:`.
    pub fn type_expr(&self) -> Option<TypeExpr> {
        support::child(&self.syntax)
    }
}

/// What a [`TypeExpr`] wraps — exactly one of these per node.
pub enum TypeExprKind {
    Name(TypeName),
    Generic(TypeGeneric),
    Fn(TypeFn),
}

impl TypeExpr {
    /// The single child this type expression wraps.
    ///
    /// `None` only for a malformed/error-recovered `TYPE_EXPR` (e.g. an
    /// empty annotation at the parser's nesting depth limit) — every
    /// well-formed one always has exactly one of these.
    pub fn kind(&self) -> Option<TypeExprKind> {
        if let Some(n) = support::child::<TypeName>(&self.syntax) {
            Some(TypeExprKind::Name(n))
        } else if let Some(g) = support::child::<TypeGeneric>(&self.syntax) {
            Some(TypeExprKind::Generic(g))
        } else {
            support::child::<TypeFn>(&self.syntax).map(TypeExprKind::Fn)
        }
    }
}

impl TypeName {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    /// The bare type name text (e.g. `"int"`, `"void"`, or an unrecognized
    /// name — grammar accepts any identifier; validity is a semantic check).
    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }
}

impl TypeGeneric {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    /// The generic head name (e.g. `"list"`, `"array"`, `"map"`).
    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The type arguments in source order (e.g. `[K, V]` for `Map<K, V>`).
    pub fn args(&self) -> impl Iterator<Item = TypeExpr> {
        support::children(&self.syntax)
    }
}

impl TypeFn {
    /// Every `TYPE_EXPR` child in source order: the last is the return type,
    /// every earlier one is a parameter type.
    fn type_exprs(&self) -> Vec<TypeExpr> {
        support::children(&self.syntax).collect()
    }

    /// Parameter types, in declaration order.
    pub fn params(&self) -> Vec<TypeExpr> {
        let mut exprs = self.type_exprs();
        if exprs.is_empty() {
            return exprs;
        }
        exprs.pop(); // drop the return type
        exprs
    }

    /// The return type after `:`.
    pub fn return_type(&self) -> Option<TypeExpr> {
        self.type_exprs().pop()
    }
}

// ── Identifiers ──────────────────────────────────────────────────────

ast_node!(Identifier, IDENTIFIER);
ast_node!(Path, PATH);

// ── Declarations ─────────────────────────────────────────────────────

ast_node!(VarDecl, VAR_DECL);
ast_node!(ConstDecl, CONST_DECL);
ast_node!(ListDecl, LIST_DECL);
ast_node!(ListDef, LIST_DEF);
ast_node!(ListMember, LIST_MEMBER);
ast_node!(ListMemberOn, LIST_MEMBER_ON);
ast_node!(ListMemberOff, LIST_MEMBER_OFF);
ast_node!(FunctionParamList, FUNCTION_PARAM_LIST);

// ── Literals ─────────────────────────────────────────────────────────

ast_node!(IntegerLit, INTEGER_LIT);
ast_node!(FloatLit, FLOAT_LIT);
ast_node!(StringLit, STRING_LIT);
ast_node!(BooleanLit, BOOLEAN_LIT);

// ── Error recovery ───────────────────────────────────────────────────

ast_node!(Error, ERROR);

// ── Expression enum ──────────────────────────────────────────────────

/// A typed expression node.
///
/// Covers every node kind the Pratt expression parser can produce.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum Expr {
    Prefix(PrefixExpr),
    Postfix(PostfixExpr),
    Infix(InfixExpr),
    Paren(ParenExpr),
    FunctionCall(FunctionCall),
    IntegerLit(IntegerLit),
    FloatLit(FloatLit),
    StringLit(StringLit),
    BooleanLit(BooleanLit),
    Path(Path),
    ListExpr(ListExpr),
    DivertTarget(DivertTargetExpr),
    /// `#[expr, …]` — array sigil literal (T1b §3, brink extension).
    ArrayLiteral(ArrayLiteral),
    /// `#{key: expr, …}` — map sigil literal (T1b §3, brink extension).
    MapLiteral(MapLiteral),
    /// `base[index]` — postfix indexing (T1b §4, brink extension).
    Index(IndexExpr),
    /// `Name#{field: expr, …}` — struct construction literal (TM-4b,
    /// docs/typed-mode-spec.md §6, brink extension).
    StructLiteral(StructLiteral),
    /// `base.field` — postfix field access (TM-4b, docs/typed-mode-spec.md
    /// §6, brink extension). Only produced where the dotted-`PATH` grammar
    /// doesn't already cover the shape — see `FIELD_ACCESS_EXPR`'s doc.
    FieldAccess(FieldAccessExpr),
    /// `#fn(target, args…)` — function-value creation (T1c,
    /// docs/t1c-spec.md §2, brink extension).
    FnLiteral(FnLiteral),
    /// `ref lvalue-path` — path-projection creation (T1e,
    /// docs/t1e-spec.md §2, brink extension). Legal only in ref-argument
    /// position (calls, `#fn(…)`, `bind(…)`) — a `brink-analyzer` concern,
    /// not a grammar one.
    RefExpr(RefExpr),
    /// `expr(args…)` where `expr` isn't a bare identifier immediately
    /// followed by `(` (that shape is `FunctionCall`) — a computed callee
    /// (indexed, field access, call-result, parenthesized, …). Parses so
    /// the call syntax and its args aren't silently reinterpreted as
    /// trailing prose text; always rejected at HIR lowering (E104,
    /// docs/t1c-spec.md §3/§10, issue #869) since Direct-call syntax is
    /// RULED to a bare variable/temp/param callee only.
    ComputedCall(CallExpr),
    /// `a..b` / `a..=b` — range literal (NS-A5, docs/stdlib-spec.md §7,
    /// brink extension).
    Range(RangeExpr),
}

impl std::fmt::Debug for Expr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(self.syntax(), f)
    }
}

impl std::fmt::Display for Expr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.syntax().text(), f)
    }
}

impl crate::ast::AstNode for Expr {
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            SyntaxKind::PREFIX_EXPR
                | SyntaxKind::POSTFIX_EXPR
                | SyntaxKind::INFIX_EXPR
                | SyntaxKind::PAREN_EXPR
                | SyntaxKind::FUNCTION_CALL
                | SyntaxKind::INTEGER_LIT
                | SyntaxKind::FLOAT_LIT
                | SyntaxKind::STRING_LIT
                | SyntaxKind::BOOLEAN_LIT
                | SyntaxKind::PATH
                | SyntaxKind::LIST_EXPR
                | SyntaxKind::DIVERT_TARGET_EXPR
                | SyntaxKind::ARRAY_LITERAL
                | SyntaxKind::MAP_LITERAL
                | SyntaxKind::INDEX_EXPR
                | SyntaxKind::STRUCT_LITERAL
                | SyntaxKind::FIELD_ACCESS_EXPR
                | SyntaxKind::FN_LITERAL
                | SyntaxKind::REF_EXPR
                | SyntaxKind::CALL_EXPR
                | SyntaxKind::RANGE_EXPR
        )
    }

    fn cast(node: SyntaxNode) -> Option<Self> {
        match node.kind() {
            SyntaxKind::PREFIX_EXPR => PrefixExpr::cast(node).map(Expr::Prefix),
            SyntaxKind::POSTFIX_EXPR => PostfixExpr::cast(node).map(Expr::Postfix),
            SyntaxKind::INFIX_EXPR => InfixExpr::cast(node).map(Expr::Infix),
            SyntaxKind::PAREN_EXPR => ParenExpr::cast(node).map(Expr::Paren),
            SyntaxKind::FUNCTION_CALL => FunctionCall::cast(node).map(Expr::FunctionCall),
            SyntaxKind::INTEGER_LIT => IntegerLit::cast(node).map(Expr::IntegerLit),
            SyntaxKind::FLOAT_LIT => FloatLit::cast(node).map(Expr::FloatLit),
            SyntaxKind::STRING_LIT => StringLit::cast(node).map(Expr::StringLit),
            SyntaxKind::BOOLEAN_LIT => BooleanLit::cast(node).map(Expr::BooleanLit),
            SyntaxKind::PATH => Path::cast(node).map(Expr::Path),
            SyntaxKind::LIST_EXPR => ListExpr::cast(node).map(Expr::ListExpr),
            SyntaxKind::DIVERT_TARGET_EXPR => DivertTargetExpr::cast(node).map(Expr::DivertTarget),
            SyntaxKind::ARRAY_LITERAL => ArrayLiteral::cast(node).map(Expr::ArrayLiteral),
            SyntaxKind::MAP_LITERAL => MapLiteral::cast(node).map(Expr::MapLiteral),
            SyntaxKind::INDEX_EXPR => IndexExpr::cast(node).map(Expr::Index),
            SyntaxKind::STRUCT_LITERAL => StructLiteral::cast(node).map(Expr::StructLiteral),
            SyntaxKind::FIELD_ACCESS_EXPR => FieldAccessExpr::cast(node).map(Expr::FieldAccess),
            SyntaxKind::FN_LITERAL => FnLiteral::cast(node).map(Expr::FnLiteral),
            SyntaxKind::REF_EXPR => RefExpr::cast(node).map(Expr::RefExpr),
            SyntaxKind::CALL_EXPR => CallExpr::cast(node).map(Expr::ComputedCall),
            SyntaxKind::RANGE_EXPR => RangeExpr::cast(node).map(Expr::Range),
            _ => None,
        }
    }

    fn syntax(&self) -> &SyntaxNode {
        match self {
            Expr::Prefix(n) => n.syntax(),
            Expr::Postfix(n) => n.syntax(),
            Expr::Infix(n) => n.syntax(),
            Expr::Paren(n) => n.syntax(),
            Expr::FunctionCall(n) => n.syntax(),
            Expr::IntegerLit(n) => n.syntax(),
            Expr::FloatLit(n) => n.syntax(),
            Expr::StringLit(n) => n.syntax(),
            Expr::BooleanLit(n) => n.syntax(),
            Expr::Path(n) => n.syntax(),
            Expr::ListExpr(n) => n.syntax(),
            Expr::DivertTarget(n) => n.syntax(),
            Expr::ArrayLiteral(n) => n.syntax(),
            Expr::MapLiteral(n) => n.syntax(),
            Expr::Index(n) => n.syntax(),
            Expr::StructLiteral(n) => n.syntax(),
            Expr::FieldAccess(n) => n.syntax(),
            Expr::FnLiteral(n) => n.syntax(),
            Expr::RefExpr(n) => n.syntax(),
            Expr::ComputedCall(n) => n.syntax(),
            Expr::Range(n) => n.syntax(),
        }
    }
}

// ── Content node accessor macro ─────────────────────────────────────

/// Generates shared content-element accessors for nodes that contain
/// mixed inline content (`TEXT`, `INLINE_LOGIC`, `GLUE_NODE`, `ESCAPE`).
macro_rules! content_node_accessors {
    ($name:ident) => {
        impl $name {
            pub fn texts(&self) -> impl Iterator<Item = Text> {
                support::children(&self.syntax)
            }

            pub fn inline_logics(&self) -> impl Iterator<Item = InlineLogic> {
                support::children(&self.syntax)
            }

            pub fn glue_nodes(&self) -> impl Iterator<Item = GlueNode> {
                support::children(&self.syntax)
            }

            pub fn escapes(&self) -> impl Iterator<Item = Escape> {
                support::children(&self.syntax)
            }
        }
    };
}

content_node_accessors!(ChoiceStartContent);
content_node_accessors!(ChoiceBracketContent);
content_node_accessors!(ChoiceInnerContent);
content_node_accessors!(BranchContent);

// ═══════════════════════════════════════════════════════════════════════
// Accessors
// ═══════════════════════════════════════════════════════════════════════

// ── SourceFile ───────────────────────────────────────────────────────

impl SourceFile {
    pub fn knots(&self) -> impl Iterator<Item = KnotDef> {
        support::children(&self.syntax)
    }

    pub fn includes(&self) -> impl Iterator<Item = IncludeStmt> {
        support::children(&self.syntax)
    }

    /// `IMPORT` statements (M-2, docs/modules-spec.md §2). Top-level only.
    pub fn imports(&self) -> impl Iterator<Item = ImportStmt> {
        support::children(&self.syntax)
    }

    pub fn externals(&self) -> impl Iterator<Item = ExternalDecl> {
        support::children(&self.syntax)
    }

    pub fn stitches(&self) -> impl Iterator<Item = StitchDef> {
        support::children(&self.syntax)
    }

    pub fn var_decls(&self) -> impl Iterator<Item = VarDecl> {
        support::children(&self.syntax)
    }

    pub fn const_decls(&self) -> impl Iterator<Item = ConstDecl> {
        support::children(&self.syntax)
    }

    pub fn list_decls(&self) -> impl Iterator<Item = ListDecl> {
        support::children(&self.syntax)
    }

    /// `STRUCT` declarations (TM-4b, docs/typed-mode-spec.md §6) — unlike
    /// `VAR`/`CONST`/`LIST` (which C# allows at any statement level, so
    /// callers walk `.descendants()` for those), a struct shape is
    /// top-level only, so a direct-children scan is exact.
    pub fn struct_decls(&self) -> impl Iterator<Item = StructDecl> {
        support::children(&self.syntax)
    }

    pub fn content_lines(&self) -> impl Iterator<Item = ContentLine> {
        support::children(&self.syntax)
    }

    pub fn logic_lines(&self) -> impl Iterator<Item = LogicLine> {
        support::children(&self.syntax)
    }

    pub fn choices(&self) -> impl Iterator<Item = Choice> {
        support::children(&self.syntax)
    }

    pub fn gathers(&self) -> impl Iterator<Item = Gather> {
        support::children(&self.syntax)
    }
}

// ── IncludeStmt ──────────────────────────────────────────────────────

impl IncludeStmt {
    pub fn file_path(&self) -> Option<FilePath> {
        support::child(&self.syntax)
    }
}

// ── ImportStmt (M-2, docs/modules-spec.md §2) ────────────────────────

impl ImportStmt {
    /// The `{ … }` name list, present only for the bare form
    /// (`IMPORT { a } FROM mod`). Absent for the qualified form
    /// (`IMPORT mod`).
    pub fn list(&self) -> Option<ImportList> {
        support::child(&self.syntax)
    }

    /// The imported module name node (present in both forms).
    pub fn module(&self) -> Option<ImportModule> {
        support::child(&self.syntax)
    }
}

impl ImportList {
    pub fn items(&self) -> impl Iterator<Item = ImportItem> {
        support::children(&self.syntax)
    }
}

impl ImportItem {
    /// The imported name (first identifier) and its optional alias (the
    /// identifier after `AS`). The list has one entry with no alias, or two
    /// with `[name, alias]`.
    fn identifiers(&self) -> impl Iterator<Item = Identifier> {
        support::children(&self.syntax)
    }

    /// The imported definition's own name.
    pub fn name(&self) -> Option<String> {
        self.identifiers().next().and_then(|id| id.name())
    }

    /// The local alias (`AS gt`), if any.
    pub fn alias(&self) -> Option<String> {
        self.identifiers().nth(1).and_then(|id| id.name())
    }
}

impl ImportModule {
    pub fn name(&self) -> Option<String> {
        support::child::<Identifier>(&self.syntax).and_then(|id| id.name())
    }
}

// ── FilePath ─────────────────────────────────────────────────────────

impl FilePath {
    /// Returns the raw text of the file path (concatenation of all child tokens).
    pub fn text(&self) -> String {
        self.syntax.text().to_string()
    }
}

// ── ExternalDecl ─────────────────────────────────────────────────────

impl ExternalDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    pub fn param_list(&self) -> Option<FunctionParamList> {
        support::child(&self.syntax)
    }
}

// ── KnotDef ──────────────────────────────────────────────────────────

impl KnotDef {
    pub fn header(&self) -> Option<KnotHeader> {
        support::child(&self.syntax)
    }

    pub fn body(&self) -> Option<KnotBody> {
        support::child(&self.syntax)
    }
}

// ── KnotHeader ───────────────────────────────────────────────────────

impl KnotHeader {
    pub fn function_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_FUNCTION)
    }

    pub fn is_function(&self) -> bool {
        self.function_kw().is_some()
    }

    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    pub fn params(&self) -> Option<KnotParams> {
        support::child(&self.syntax)
    }

    /// The return type annotation after the params (TM-2, docs/typed-mode-spec.md
    /// §3: `): type ===`), if present.
    pub fn return_type(&self) -> Option<TypeAnnotation> {
        support::child(&self.syntax)
    }
}

// ── KnotBody ─────────────────────────────────────────────────────────

impl KnotBody {
    pub fn stitches(&self) -> impl Iterator<Item = StitchDef> {
        support::children(&self.syntax)
    }

    pub fn content_lines(&self) -> impl Iterator<Item = ContentLine> {
        support::children(&self.syntax)
    }

    pub fn logic_lines(&self) -> impl Iterator<Item = LogicLine> {
        support::children(&self.syntax)
    }

    pub fn choices(&self) -> impl Iterator<Item = Choice> {
        support::children(&self.syntax)
    }

    pub fn gathers(&self) -> impl Iterator<Item = Gather> {
        support::children(&self.syntax)
    }
}

// ── KnotParams ───────────────────────────────────────────────────────

impl KnotParams {
    pub fn params(&self) -> impl Iterator<Item = KnotParamDecl> {
        support::children(&self.syntax)
    }
}

// ── KnotParamDecl ────────────────────────────────────────────────────

impl KnotParamDecl {
    pub fn divert_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, DIVERT)
    }

    pub fn is_divert(&self) -> bool {
        self.divert_token().is_some()
    }

    pub fn ref_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_REF)
    }

    pub fn is_ref(&self) -> bool {
        self.ref_kw().is_some()
    }

    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The parameter's type annotation (TM-2, docs/typed-mode-spec.md §3:
    /// `name: type`), if present.
    pub fn type_annotation(&self) -> Option<TypeAnnotation> {
        support::child(&self.syntax)
    }
}

// ── StitchDef ────────────────────────────────────────────────────────

impl StitchDef {
    pub fn header(&self) -> Option<StitchHeader> {
        support::child(&self.syntax)
    }

    pub fn body(&self) -> Option<StitchBody> {
        support::child(&self.syntax)
    }
}

// ── StitchHeader ─────────────────────────────────────────────────────

impl StitchHeader {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    pub fn params(&self) -> Option<KnotParams> {
        support::child(&self.syntax)
    }

    /// The return type annotation after the params (NG-C, issue #1489,
    /// widened to stitches by #1509: `= name(params): type`), if present —
    /// the same TM-2 grammar position `KnotHeader::return_type` parses,
    /// minus the trailing `===` a stitch header never has.
    pub fn return_type(&self) -> Option<TypeAnnotation> {
        support::child(&self.syntax)
    }
}

// ── StitchBody ───────────────────────────────────────────────────────

impl StitchBody {
    pub fn content_lines(&self) -> impl Iterator<Item = ContentLine> {
        support::children(&self.syntax)
    }

    pub fn logic_lines(&self) -> impl Iterator<Item = LogicLine> {
        support::children(&self.syntax)
    }

    pub fn choices(&self) -> impl Iterator<Item = Choice> {
        support::children(&self.syntax)
    }

    pub fn gathers(&self) -> impl Iterator<Item = Gather> {
        support::children(&self.syntax)
    }
}

// ── ContentLine ──────────────────────────────────────────────────────

impl ContentLine {
    pub fn mixed_content(&self) -> Option<MixedContent> {
        support::child(&self.syntax)
    }

    pub fn divert(&self) -> Option<DivertNode> {
        support::child(&self.syntax)
    }

    pub fn tags(&self) -> Option<Tags> {
        support::child(&self.syntax)
    }
}

// ── LogicLine ────────────────────────────────────────────────────────

impl LogicLine {
    pub fn return_stmt(&self) -> Option<ReturnStmt> {
        support::child(&self.syntax)
    }

    pub fn temp_decl(&self) -> Option<TempDecl> {
        support::child(&self.syntax)
    }

    pub fn assignment(&self) -> Option<Assignment> {
        support::child(&self.syntax)
    }

    /// The `~ await <cond>` `FlowFrame` suspension point, if this logic line is
    /// one (docs/flow-suspension-spec.md §3).
    pub fn await_stmt(&self) -> Option<AwaitStmt> {
        support::child(&self.syntax)
    }

    /// The T1b `~ { … }` multi-line block body, if this logic line opens one
    /// (docs/t1b-surface-spec.md §2) rather than a single statement.
    pub fn stmt_block(&self) -> Option<StmtBlock> {
        support::child(&self.syntax)
    }
}

// ── TagLine ──────────────────────────────────────────────────────────

impl TagLine {
    pub fn tags(&self) -> Option<Tags> {
        support::child(&self.syntax)
    }
}

// ── AnnotationLine ───────────────────────────────────────────────────

impl AnnotationLine {
    /// The annotation's name token — the `IDENT` after `@[` (e.g. `effects`
    /// in `@[effects(pure)]`).
    pub fn name_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|t| t.kind() == IDENT)
    }

    /// The raw text between the annotation's balanced `( … )` argument
    /// parens, if present — `None` for a bare `@[name]`. Mirrors the
    /// directive channel's raw-string argument contract
    /// (`brink-ir`'s `ParsedDirective::arg`): the argument mini-grammar is
    /// parsed downstream, not here.
    pub fn arg_text(&self) -> Option<String> {
        let mut depth = 0usize;
        let mut collecting = false;
        let mut out = String::new();
        for el in self.syntax.children_with_tokens() {
            let rowan::NodeOrToken::Token(tok) = el else {
                continue;
            };
            match tok.kind() {
                L_PAREN => {
                    if collecting {
                        out.push_str(tok.text());
                    }
                    depth += 1;
                    collecting = true;
                }
                R_PAREN => {
                    depth = depth.saturating_sub(1);
                    if depth == 0 {
                        return Some(out);
                    }
                    out.push_str(tok.text());
                }
                _ if collecting => out.push_str(tok.text()),
                _ => {}
            }
        }
        collecting.then_some(out)
    }
}

// ── ReturnStmt ───────────────────────────────────────────────────────

impl ReturnStmt {
    /// Returns the value expression, if any.
    ///
    /// A bare `return` has no child expression node; `return expr` always
    /// wraps the expression in a typed node (the parser calls `expression()`).
    pub fn value(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }

    /// Returns `true` if the return has a value expression.
    pub fn has_value(&self) -> bool {
        self.value().is_some()
    }
}

// ── AwaitStmt ────────────────────────────────────────────────────────

impl AwaitStmt {
    /// The condition expression — the `<cond>` in `await <cond>`
    /// (docs/flow-suspension-spec.md §3). Absent only for a malformed bare
    /// `await` with no expression (the parser emits a diagnostic there).
    pub fn condition(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

// ── TempDecl ─────────────────────────────────────────────────────────

impl TempDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The ascription's type annotation (TM-2, docs/typed-mode-spec.md §3:
    /// `~ temp name: type = expr`), if present.
    pub fn type_annotation(&self) -> Option<TypeAnnotation> {
        support::child(&self.syntax)
    }

    pub fn eq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, EQ)
    }

    /// Returns the initializer expression after `=`.
    pub fn value(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── Assignment ───────────────────────────────────────────────────────

impl Assignment {
    pub fn target(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    /// The assignment operator token (`=`, `+=`, or `-=`).
    pub fn op_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|tok| matches!(tok.kind(), EQ | PLUS_EQ | MINUS_EQ))
    }

    /// Returns the right-hand side value expression (the second `Expr` child).
    pub fn value(&self) -> Option<Expr> {
        self.syntax.children().filter_map(Expr::cast).nth(1)
    }
}

// ═══════════════════════════════════════════════════════════════════════
// T1b superset: multi-line `~ { … }` blocks (docs/t1b-surface-spec.md §2)
// ═══════════════════════════════════════════════════════════════════════

/// A single statement inside a `~ { … }` block body.
///
/// Deliberately excludes every weave concept (content, choices, diverts,
/// gathers, threads) — the seam rule from docs/t1b-surface-spec.md §2:
/// blocks compute, weave flows.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum BlockStmt {
    TempDecl(TempDecl),
    Assignment(Assignment),
    Return(ReturnStmt),
    If(IfStmt),
    While(WhileStmt),
    For(ForStmt),
    Break(BreakStmt),
    Continue(ContinueStmt),
    ExprStmt(ExprStmt),
    /// `await <cond>` — a `FlowFrame` suspension point inside a `~ { … }` block
    /// (docs/flow-suspension-spec.md §3).
    Await(AwaitStmt),
}

impl std::fmt::Debug for BlockStmt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(self.syntax(), f)
    }
}

impl crate::ast::AstNode for BlockStmt {
    fn can_cast(kind: SyntaxKind) -> bool {
        matches!(
            kind,
            SyntaxKind::TEMP_DECL
                | SyntaxKind::ASSIGNMENT
                | SyntaxKind::RETURN_STMT
                | SyntaxKind::IF_STMT
                | SyntaxKind::WHILE_STMT
                | SyntaxKind::FOR_STMT
                | SyntaxKind::BREAK_STMT
                | SyntaxKind::CONTINUE_STMT
                | SyntaxKind::EXPR_STMT
                | SyntaxKind::AWAIT_STMT
        )
    }

    fn cast(node: SyntaxNode) -> Option<Self> {
        match node.kind() {
            SyntaxKind::TEMP_DECL => TempDecl::cast(node).map(BlockStmt::TempDecl),
            SyntaxKind::ASSIGNMENT => Assignment::cast(node).map(BlockStmt::Assignment),
            SyntaxKind::RETURN_STMT => ReturnStmt::cast(node).map(BlockStmt::Return),
            SyntaxKind::IF_STMT => IfStmt::cast(node).map(BlockStmt::If),
            SyntaxKind::WHILE_STMT => WhileStmt::cast(node).map(BlockStmt::While),
            SyntaxKind::FOR_STMT => ForStmt::cast(node).map(BlockStmt::For),
            SyntaxKind::BREAK_STMT => BreakStmt::cast(node).map(BlockStmt::Break),
            SyntaxKind::CONTINUE_STMT => ContinueStmt::cast(node).map(BlockStmt::Continue),
            SyntaxKind::EXPR_STMT => ExprStmt::cast(node).map(BlockStmt::ExprStmt),
            SyntaxKind::AWAIT_STMT => AwaitStmt::cast(node).map(BlockStmt::Await),
            _ => None,
        }
    }

    fn syntax(&self) -> &SyntaxNode {
        match self {
            BlockStmt::TempDecl(n) => n.syntax(),
            BlockStmt::Assignment(n) => n.syntax(),
            BlockStmt::Return(n) => n.syntax(),
            BlockStmt::If(n) => n.syntax(),
            BlockStmt::While(n) => n.syntax(),
            BlockStmt::For(n) => n.syntax(),
            BlockStmt::Break(n) => n.syntax(),
            BlockStmt::Continue(n) => n.syntax(),
            BlockStmt::ExprStmt(n) => n.syntax(),
            BlockStmt::Await(n) => n.syntax(),
        }
    }
}

// ── StmtBlock ────────────────────────────────────────────────────────

impl StmtBlock {
    /// The statements in this block, in source order.
    pub fn stmts(&self) -> impl Iterator<Item = BlockStmt> {
        support::children(&self.syntax)
    }
}

// ── IfStmt ───────────────────────────────────────────────────────────

impl IfStmt {
    /// The condition expression (the first `Expr` child).
    pub fn condition(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    /// The `{ … }` body executed when the condition holds.
    pub fn body(&self) -> Option<StmtBlock> {
        support::child(&self.syntax)
    }

    /// The `else` arm, if present.
    pub fn else_clause(&self) -> Option<ElseClause> {
        support::child(&self.syntax)
    }
}

// ── ElseClause ───────────────────────────────────────────────────────

impl ElseClause {
    /// The nested `if` for an `else if` chain, if this is one.
    pub fn if_stmt(&self) -> Option<IfStmt> {
        support::child(&self.syntax)
    }

    /// The `{ … }` body for a bare `else`, if this is one (mutually
    /// exclusive with [`ElseClause::if_stmt`]).
    pub fn body(&self) -> Option<StmtBlock> {
        support::child(&self.syntax)
    }
}

// ── WhileStmt ────────────────────────────────────────────────────────

impl WhileStmt {
    pub fn condition(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn body(&self) -> Option<StmtBlock> {
        support::child(&self.syntax)
    }

    /// Whether this is the persistent-await form `while await cond { … }`
    /// (docs/flow-suspension-spec.md §3) rather than a plain `while` loop. The
    /// parser bumps the marker `await` as a direct `IDENT` token child (the
    /// `while` keyword is the only other direct `IDENT` token; the condition
    /// lives inside an `Expr` node, never a bare token), so the presence of an
    /// `IDENT` token spelled `await` here is the unambiguous marker.
    pub fn is_await(&self) -> bool {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .any(|tok| tok.kind() == SyntaxKind::IDENT && tok.text() == "await")
    }
}

// ── ForStmt ──────────────────────────────────────────────────────────

impl ForStmt {
    /// The loop variable name.
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The iterable expression (after `in`).
    pub fn iterable(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn body(&self) -> Option<StmtBlock> {
        support::child(&self.syntax)
    }
}

// ── ExprStmt ─────────────────────────────────────────────────────────

impl ExprStmt {
    pub fn expr(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ═══════════════════════════════════════════════════════════════════════
// T1b superset: sigil literals + indexing (docs/t1b-surface-spec.md §3-4)
// ═══════════════════════════════════════════════════════════════════════

// ── ArrayLiteral ─────────────────────────────────────────────────────

impl ArrayLiteral {
    pub fn elements(&self) -> impl Iterator<Item = Expr> {
        support::children(&self.syntax)
    }
}

// ── MapLiteral ───────────────────────────────────────────────────────

impl MapLiteral {
    pub fn entries(&self) -> impl Iterator<Item = MapEntry> {
        support::children(&self.syntax)
    }
}

// ── MapEntry ─────────────────────────────────────────────────────────

impl MapEntry {
    /// The key expression (the first `Expr` child).
    pub fn key(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    /// The value expression (the second `Expr` child).
    pub fn value(&self) -> Option<Expr> {
        self.syntax.children().filter_map(Expr::cast).nth(1)
    }
}

// ── IndexExpr ────────────────────────────────────────────────────────

impl IndexExpr {
    /// The base being indexed (the first `Expr` child) — `a` in `a[i]`.
    pub fn base(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    /// The index expression (the second `Expr` child) — `i` in `a[i]`.
    pub fn index(&self) -> Option<Expr> {
        self.syntax.children().filter_map(Expr::cast).nth(1)
    }
}

// ── RangeExpr (NS-A5, docs/stdlib-spec.md §7) ────────────────────────

impl RangeExpr {
    /// The start bound (the first `Expr` child) — `a` in `a..b`.
    pub fn start(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    /// The end bound (the second `Expr` child) — `b` in `a..b`.
    pub fn end(&self) -> Option<Expr> {
        self.syntax.children().filter_map(Expr::cast).nth(1)
    }

    /// `true` for the inclusive `..=` form — detected by the `EQ` token the
    /// parser bumped between the dots and the end bound.
    pub fn is_inclusive(&self) -> bool {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .any(|t| t.kind() == SyntaxKind::EQ)
    }
}

// ═══════════════════════════════════════════════════════════════════════
// TM-4b structs (docs/typed-mode-spec.md §6)
// ═══════════════════════════════════════════════════════════════════════

// ── StructDecl ───────────────────────────────────────────────────────

impl StructDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The declared fields, in source order.
    pub fn fields(&self) -> impl Iterator<Item = StructFieldDecl> {
        support::children(&self.syntax)
    }
}

// ── StructFieldDecl ──────────────────────────────────────────────────

impl StructFieldDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The field's declared type (value position — mirrors the
    /// construction literal's field-init value position, §6).
    pub fn type_expr(&self) -> Option<TypeExpr> {
        support::child(&self.syntax)
    }
}

// ── StructLiteral ────────────────────────────────────────────────────

impl StructLiteral {
    /// The leading shape-name identifier (e.g. `Point` in `Point#{…}`).
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn shape_name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The field initializers, in source order.
    pub fn fields(&self) -> impl Iterator<Item = StructFieldInit> {
        support::children(&self.syntax)
    }
}

// ── StructFieldInit ──────────────────────────────────────────────────

impl StructFieldInit {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The initializer expression after `:`.
    pub fn value(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── FieldAccessExpr ──────────────────────────────────────────────────

impl FieldAccessExpr {
    /// The expression being accessed (the first, and only, `Expr` child) —
    /// `base` in `base.field`.
    pub fn base(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    /// The field name identifier after `.`.
    pub fn field(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn field_name(&self) -> Option<String> {
        self.field().and_then(|id| id.name())
    }
}

// ═══════════════════════════════════════════════════════════════════════
// T1c function values (docs/t1c-spec.md §2)
// ═══════════════════════════════════════════════════════════════════════

// ── FnLiteral ────────────────────────────────────────────────────────

impl FnLiteral {
    /// The static target path (the first `PATH` child) — `heal` in
    /// `#fn(heal, hp)`. `None` on malformed input (`#fn()`, `#fn(1)`).
    pub fn target(&self) -> Option<Path> {
        support::child(&self.syntax)
    }

    /// The bound-argument expressions after the target, in source order.
    /// The target `PATH` is itself castable to `Expr::Path`, so this skips
    /// the first `Expr` child iff it is that target node.
    pub fn args(&self) -> impl Iterator<Item = Expr> {
        let target_node = self.target().map(|t| t.syntax().clone());
        self.syntax
            .children()
            .filter_map(Expr::cast)
            .filter(move |e| Some(e.syntax()) != target_node.as_ref())
    }
}

// ═══════════════════════════════════════════════════════════════════════
// T1e path projections (docs/t1e-spec.md §2)
// ═══════════════════════════════════════════════════════════════════════

// ── RefExpr ──────────────────────────────────────────────────────────

impl RefExpr {
    pub fn ref_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_REF)
    }

    /// The lvalue-shaped operand after `ref` — a plain path, a dotted field
    /// chain, `[…]` indexing, or a mix. `None` on malformed input (`ref` at
    /// end of input, or followed by a token that starts no expression).
    pub fn operand(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── MixedContent ─────────────────────────────────────────────────────

impl MixedContent {
    pub fn texts(&self) -> impl Iterator<Item = Text> {
        support::children(&self.syntax)
    }

    pub fn glue_nodes(&self) -> impl Iterator<Item = GlueNode> {
        support::children(&self.syntax)
    }

    pub fn inline_logics(&self) -> impl Iterator<Item = InlineLogic> {
        support::children(&self.syntax)
    }

    pub fn escapes(&self) -> impl Iterator<Item = Escape> {
        support::children(&self.syntax)
    }
}

// ── Choice ───────────────────────────────────────────────────────────

impl Choice {
    pub fn bullets(&self) -> Option<ChoiceBullets> {
        support::child(&self.syntax)
    }

    pub fn label(&self) -> Option<Label> {
        support::child(&self.syntax)
    }

    pub fn conditions(&self) -> impl Iterator<Item = ChoiceCondition> {
        support::children(&self.syntax)
    }

    pub fn start_content(&self) -> Option<ChoiceStartContent> {
        support::child(&self.syntax)
    }

    pub fn bracket_content(&self) -> Option<ChoiceBracketContent> {
        support::child(&self.syntax)
    }

    pub fn inner_content(&self) -> Option<ChoiceInnerContent> {
        support::child(&self.syntax)
    }

    pub fn divert(&self) -> Option<DivertNode> {
        support::child(&self.syntax)
    }

    pub fn tags(&self) -> Option<Tags> {
        support::child(&self.syntax)
    }

    /// Returns an iterator over all TAGS children (tags can appear on
    /// each content region within a choice line).
    pub fn all_tags(&self) -> impl Iterator<Item = Tags> {
        support::children(&self.syntax)
    }
}

// ── ChoiceBullets ────────────────────────────────────────────────────

impl ChoiceBullets {
    /// Number of bullet characters (nesting depth).
    pub fn depth(&self) -> usize {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .filter(|tok| matches!(tok.kind(), STAR | PLUS))
            .count()
    }

    /// Returns `true` if using `+` (sticky), `false` if using `*`.
    ///
    /// Determined by the first bullet token, matching the reference ink
    /// compiler's behavior for degenerate mixed-bullet cases.
    pub fn is_sticky(&self) -> bool {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|tok| matches!(tok.kind(), STAR | PLUS))
            .is_some_and(|tok| tok.kind() == PLUS)
    }

    /// Returns `true` if bullets mix `*` and `+` (e.g. `*+`, `+*`).
    ///
    /// Mixed bullets are degenerate input — a diagnostic pass should flag them.
    pub fn is_mixed(&self) -> bool {
        let mut has_star = false;
        let mut has_plus = false;
        for tok in self
            .syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
        {
            match tok.kind() {
                STAR => has_star = true,
                PLUS => has_plus = true,
                _ => {}
            }
        }
        has_star && has_plus
    }
}

// ── Label ────────────────────────────────────────────────────────────

impl Label {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }
}

// ── Gather ───────────────────────────────────────────────────────────

impl Gather {
    pub fn dashes(&self) -> Option<GatherDashes> {
        support::child(&self.syntax)
    }

    pub fn label(&self) -> Option<Label> {
        support::child(&self.syntax)
    }

    pub fn mixed_content(&self) -> Option<MixedContent> {
        support::child(&self.syntax)
    }

    /// Inline choice on the same line as the gather (e.g. `- * hello`).
    pub fn choice(&self) -> Option<Choice> {
        support::child(&self.syntax)
    }

    pub fn divert(&self) -> Option<DivertNode> {
        support::child(&self.syntax)
    }

    pub fn tags(&self) -> Option<Tags> {
        support::child(&self.syntax)
    }
}

// ── GatherDashes ─────────────────────────────────────────────────────

impl GatherDashes {
    /// Number of dashes (nesting depth).
    pub fn depth(&self) -> usize {
        support::tokens(&self.syntax, MINUS).count()
    }
}

// ── Tags ─────────────────────────────────────────────────────────────

impl Tags {
    pub fn tags(&self) -> impl Iterator<Item = Tag> {
        support::children(&self.syntax)
    }
}

// ── Tag ──────────────────────────────────────────────────────────────

impl Tag {
    /// Returns the tag value with the leading `#` stripped.
    ///
    /// Walks tokens directly rather than string-manipulating the full node text.
    /// The parser guarantees a `HASH` token is always present.
    pub fn text(&self) -> String {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .filter(|tok| tok.kind() != HASH)
            .map(|tok| tok.text().to_string())
            .collect::<String>()
            .trim()
            .to_string()
    }
}

// ── InlineLogic ──────────────────────────────────────────────────────

impl InlineLogic {
    pub fn inner_expression(&self) -> Option<InnerExpression> {
        support::child(&self.syntax)
    }

    pub fn conditional(&self) -> Option<ConditionalWithExpr> {
        support::child(&self.syntax)
    }

    pub fn sequence(&self) -> Option<SequenceWithAnnotation> {
        support::child(&self.syntax)
    }

    pub fn implicit_sequence(&self) -> Option<ImplicitSequence> {
        support::child(&self.syntax)
    }

    pub fn multiline_conditional(&self) -> Option<MultilineConditional> {
        support::child(&self.syntax)
    }
}

// ── MultilineBlock ───────────────────────────────────────────────────

impl MultilineBlock {
    pub fn conditional(&self) -> Option<ConditionalWithExpr> {
        support::child(&self.syntax)
    }

    pub fn sequence(&self) -> Option<SequenceWithAnnotation> {
        support::child(&self.syntax)
    }

    pub fn branches_cond(&self) -> Option<MultilineBranchesCond> {
        support::child(&self.syntax)
    }
}

// ── SequenceWithAnnotation ───────────────────────────────────────────

impl SequenceWithAnnotation {
    pub fn symbol_annotation(&self) -> Option<SequenceSymbolAnnotation> {
        support::child(&self.syntax)
    }

    pub fn word_annotation(&self) -> Option<SequenceWordAnnotation> {
        support::child(&self.syntax)
    }

    pub fn inline_branches(&self) -> Option<InlineBranchesSeq> {
        support::child(&self.syntax)
    }

    pub fn multiline_branches(&self) -> Option<MultilineBranchesSeq> {
        support::child(&self.syntax)
    }
}

// ── SequenceSymbolAnnotation ──────────────────────────────────────────

impl SequenceSymbolAnnotation {
    pub fn amp_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, AMP)
    }

    pub fn bang_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, BANG)
    }

    pub fn tilde_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, TILDE)
    }

    pub fn dollar_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, DOLLAR)
    }
}

// ── SequenceWordAnnotation ───────────────────────────────────────────

impl SequenceWordAnnotation {
    pub fn stopping_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_STOPPING)
    }

    pub fn cycle_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_CYCLE)
    }

    pub fn shuffle_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_SHUFFLE)
    }

    pub fn once_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_ONCE)
    }
}

// ── InlineBranchesSeq ────────────────────────────────────────────────

impl InlineBranchesSeq {
    pub fn branches(&self) -> impl Iterator<Item = BranchContent> {
        support::children(&self.syntax)
    }
}

// ── InlineBranchesCond ───────────────────────────────────────────────

impl InlineBranchesCond {
    pub fn branches(&self) -> impl Iterator<Item = BranchContent> {
        support::children(&self.syntax)
    }
}

// ── MultilineBranchesSeq ─────────────────────────────────────────────

impl MultilineBranchesSeq {
    pub fn branches(&self) -> impl Iterator<Item = MultilineBranchSeq> {
        support::children(&self.syntax)
    }
}

// ── MultilineBranchesCond ────────────────────────────────────────────

impl MultilineBranchesCond {
    pub fn branches(&self) -> impl Iterator<Item = MultilineBranchCond> {
        support::children(&self.syntax)
    }
}

// ── MultilineBranchSeq ───────────────────────────────────────────────

impl MultilineBranchSeq {
    pub fn body(&self) -> Option<MultilineBranchBody> {
        support::child(&self.syntax)
    }
}

// ── MultilineBranchCond ──────────────────────────────────────────────

impl MultilineBranchCond {
    /// Returns the branch condition expression (if not an else branch).
    pub fn condition(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }

    pub fn body(&self) -> Option<MultilineBranchBody> {
        support::child(&self.syntax)
    }

    pub fn else_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_ELSE)
    }

    pub fn is_else(&self) -> bool {
        self.else_kw().is_some()
    }
}

// ── ConditionalWithExpr ──────────────────────────────────────────────

impl ConditionalWithExpr {
    /// Returns the condition expression.
    pub fn condition(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }

    pub fn inline_branches(&self) -> Option<InlineBranchesCond> {
        support::child(&self.syntax)
    }

    pub fn multiline_branches(&self) -> Option<MultilineBranchesCond> {
        support::child(&self.syntax)
    }

    pub fn branchless_body(&self) -> Option<BranchlessCondBody> {
        support::child(&self.syntax)
    }
}

// ── BranchlessCondBody ───────────────────────────────────────────────

impl BranchlessCondBody {
    pub fn texts(&self) -> impl Iterator<Item = Text> {
        support::children(&self.syntax)
    }

    pub fn inline_logics(&self) -> impl Iterator<Item = InlineLogic> {
        support::children(&self.syntax)
    }

    pub fn glue_nodes(&self) -> impl Iterator<Item = GlueNode> {
        support::children(&self.syntax)
    }

    pub fn escapes(&self) -> impl Iterator<Item = Escape> {
        support::children(&self.syntax)
    }

    pub fn logic_lines(&self) -> impl Iterator<Item = LogicLine> {
        support::children(&self.syntax)
    }

    pub fn divert(&self) -> Option<DivertNode> {
        support::child(&self.syntax)
    }

    pub fn content_lines(&self) -> impl Iterator<Item = ContentLine> {
        support::children(&self.syntax)
    }

    pub fn else_branch(&self) -> Option<ElseBranch> {
        support::child(&self.syntax)
    }
}

// ── ElseBranch ───────────────────────────────────────────────────────

impl ElseBranch {
    pub fn branch(&self) -> Option<MultilineBranchCond> {
        support::child(&self.syntax)
    }
}

// ── MultilineConditional ─────────────────────────────────────────────

impl MultilineConditional {
    pub fn branches(&self) -> impl Iterator<Item = MultilineBranchCond> {
        support::children(&self.syntax)
    }
}

// ── ImplicitSequence ─────────────────────────────────────────────────

impl ImplicitSequence {
    pub fn branches(&self) -> impl Iterator<Item = BranchContent> {
        support::children(&self.syntax)
    }
}

// ── PrefixExpr ───────────────────────────────────────────────────────

impl PrefixExpr {
    pub fn op_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|tok| matches!(tok.kind(), MINUS | BANG | KW_NOT))
    }

    /// Returns the operand expression.
    pub fn operand(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── PostfixExpr ──────────────────────────────────────────────────────

impl PostfixExpr {
    /// Returns the first operator token (`PLUS` for `++`, `MINUS` for `--`).
    /// Both operators are two adjacent tokens inside this node.
    pub fn op_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|tok| matches!(tok.kind(), PLUS | MINUS))
    }

    /// Returns the operand expression.
    pub fn operand(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── InfixExpr ────────────────────────────────────────────────────────

impl InfixExpr {
    pub fn op_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|tok| {
                matches!(
                    tok.kind(),
                    PLUS | MINUS
                        | STAR
                        | SLASH
                        | PERCENT
                        | CARET
                        | EQ_EQ
                        | BANG_EQ
                        | LT
                        | GT
                        | LT_EQ
                        | GT_EQ
                        | KW_AND
                        | AMP_AMP
                        | KW_OR
                        | PIPE
                        | KW_MOD
                        | KW_HAS
                        | KW_HASNT
                        | QUESTION
                        | BANG_QUESTION
                        | PLUS_EQ
                        | MINUS_EQ
                )
            })
    }

    pub fn lhs(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn rhs(&self) -> Option<Expr> {
        self.syntax.children().filter_map(Expr::cast).nth(1)
    }
}

// ── FunctionCall ─────────────────────────────────────────────────────

impl FunctionCall {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    pub fn arg_list(&self) -> Option<ArgList> {
        support::child(&self.syntax)
    }
}

// ── CallExpr (computed-callee call attempt, issue #869) ──────────────

impl CallExpr {
    /// The callee expression — the first (and only non-`ARG_LIST`) child.
    /// Always some non-identifier-immediately-followed-by-`(` shape
    /// (`FUNCTION_CALL`'s bare-name fast path never reaches this node).
    pub fn callee(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn arg_list(&self) -> Option<ArgList> {
        support::child(&self.syntax)
    }
}

// ── ArgList ──────────────────────────────────────────────────────────

impl ArgList {
    /// Number of arguments (child expression nodes).
    pub fn arg_count(&self) -> usize {
        self.syntax
            .children()
            .filter(|child| child.kind() != SyntaxKind::ERROR)
            .count()
    }

    /// Iterator over the argument expressions.
    pub fn args(&self) -> impl Iterator<Item = Expr> {
        support::children(&self.syntax)
    }
}

// ── DivertTargetExpr ─────────────────────────────────────────────────

impl DivertTargetExpr {
    pub fn target(&self) -> Option<Path> {
        support::child(&self.syntax)
    }
}

// ── ListExpr ─────────────────────────────────────────────────────────

impl ListExpr {
    pub fn items(&self) -> impl Iterator<Item = Path> {
        support::children(&self.syntax)
    }
}

// ── DivertNode ───────────────────────────────────────────────────────

impl DivertNode {
    pub fn thread_start(&self) -> Option<ThreadStart> {
        support::child(&self.syntax)
    }

    pub fn tunnel_onwards(&self) -> Option<TunnelOnwardsNode> {
        support::child(&self.syntax)
    }

    pub fn tunnel_call(&self) -> Option<TunnelCallNode> {
        support::child(&self.syntax)
    }

    pub fn simple_divert(&self) -> Option<SimpleDivert> {
        support::child(&self.syntax)
    }
}

// ── SimpleDivert ─────────────────────────────────────────────────────

impl SimpleDivert {
    pub fn targets(&self) -> impl Iterator<Item = DivertTargetWithArgs> {
        support::children(&self.syntax)
    }
}

// ── DivertTargetWithArgs ─────────────────────────────────────────────

impl DivertTargetWithArgs {
    pub fn path(&self) -> Option<Path> {
        support::child(&self.syntax)
    }

    pub fn done_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_DONE)
    }

    pub fn end_kw(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, KW_END)
    }

    pub fn arg_list(&self) -> Option<ArgList> {
        support::child(&self.syntax)
    }
}

// ── ThreadStart ──────────────────────────────────────────────────────

impl ThreadStart {
    /// Returns the target path.
    ///
    /// The parser produces a `PATH` child directly (not wrapped in
    /// `DivertTargetWithArgs`), so this returns `Option<Path>`.
    pub fn target(&self) -> Option<Path> {
        support::child(&self.syntax)
    }

    pub fn arg_list(&self) -> Option<ArgList> {
        support::child(&self.syntax)
    }
}

// ── TunnelOnwardsNode ────────────────────────────────────────────────

impl TunnelOnwardsNode {
    pub fn targets(&self) -> impl Iterator<Item = DivertTargetWithArgs> {
        support::children(&self.syntax)
    }

    pub fn tunnel_call(&self) -> Option<TunnelCallNode> {
        support::child(&self.syntax)
    }
}

// ── TunnelCallNode ──────────────────────────────────────────────────

impl TunnelCallNode {
    pub fn targets(&self) -> impl Iterator<Item = DivertTargetWithArgs> {
        support::children(&self.syntax)
    }
}

// ── Identifier ───────────────────────────────────────────────────────

impl Identifier {
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, IDENT)
    }

    /// Returns the name text, accepting either `IDENT` or keyword tokens
    /// (ink keywords are contextual and may appear as identifiers).
    pub fn name(&self) -> Option<String> {
        self.ident_token()
            .or_else(|| {
                self.syntax
                    .children_with_tokens()
                    .filter_map(rowan::NodeOrToken::into_token)
                    .find(|t| t.kind().is_keyword())
            })
            .map(|t| t.text().to_string())
    }
}

// ── Path ─────────────────────────────────────────────────────────────

impl Path {
    /// Iterator over the segment tokens (`IDENT` or keyword tokens between dots).
    pub fn segments(&self) -> impl Iterator<Item = SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .filter(|t| t.kind() == IDENT || t.kind().is_keyword())
    }

    /// Full dotted name (e.g. `"knot.stitch"`).
    pub fn full_name(&self) -> String {
        self.segments()
            .map(|t| t.text().to_string())
            .collect::<Vec<_>>()
            .join(".")
    }
}

// ── VarDecl ──────────────────────────────────────────────────────────

impl VarDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The declared type annotation (TM-2, docs/typed-mode-spec.md §3:
    /// `VAR name: type = expr`), if present.
    pub fn type_annotation(&self) -> Option<TypeAnnotation> {
        support::child(&self.syntax)
    }

    /// Returns the initializer expression after `=`.
    pub fn value(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── ConstDecl ────────────────────────────────────────────────────────

impl ConstDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    /// The declared type annotation (TM-2, docs/typed-mode-spec.md §3:
    /// `CONST name: type = expr`), if present.
    pub fn type_annotation(&self) -> Option<TypeAnnotation> {
        support::child(&self.syntax)
    }

    /// Returns the initializer expression after `=`.
    pub fn value(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── ListDecl ─────────────────────────────────────────────────────────

impl ListDecl {
    pub fn identifier(&self) -> Option<Identifier> {
        support::child(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.identifier().and_then(|id| id.name())
    }

    pub fn definition(&self) -> Option<ListDef> {
        support::child(&self.syntax)
    }
}

// ── ListDef ──────────────────────────────────────────────────────────

impl ListDef {
    pub fn members(&self) -> impl Iterator<Item = ListMember> {
        support::children(&self.syntax)
    }
}

// ── ListMember ───────────────────────────────────────────────────────

impl ListMember {
    pub fn on_member(&self) -> Option<ListMemberOn> {
        support::child(&self.syntax)
    }

    pub fn off_member(&self) -> Option<ListMemberOff> {
        support::child(&self.syntax)
    }
}

// ── ListMemberOn ─────────────────────────────────────────────────────

impl ListMemberOn {
    pub fn name_token(&self) -> Option<SyntaxToken> {
        // Ink keywords are contextual — accept IDENT or keywords as member names.
        support::ident_or_keyword_token(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.name_token().map(|t| t.text().to_string())
    }

    pub fn value_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, INTEGER)
    }

    /// Returns the explicit integer value assigned to this member, if any.
    pub fn value(&self) -> Option<i64> {
        self.value_token()
            .and_then(|t| t.text().parse::<i64>().ok())
    }
}

// ── ListMemberOff ────────────────────────────────────────────────────

impl ListMemberOff {
    pub fn name_token(&self) -> Option<SyntaxToken> {
        // Ink keywords are contextual — accept IDENT or keywords as member names.
        support::ident_or_keyword_token(&self.syntax)
    }

    pub fn name(&self) -> Option<String> {
        self.name_token().map(|t| t.text().to_string())
    }

    pub fn value_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, INTEGER)
    }

    /// Returns the explicit integer value assigned to this member, if any.
    pub fn value(&self) -> Option<i64> {
        self.value_token()
            .and_then(|t| t.text().parse::<i64>().ok())
    }
}

// ── FunctionParamList ────────────────────────────────────────────────

impl FunctionParamList {
    /// Iterator over the `Identifier` nodes in the param list.
    pub fn params(&self) -> impl Iterator<Item = Identifier> {
        support::children(&self.syntax)
    }
}

// ── IntegerLit ───────────────────────────────────────────────────────

impl IntegerLit {
    pub fn value_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, INTEGER)
    }

    pub fn value(&self) -> Option<i64> {
        self.value_token()
            .and_then(|t| t.text().parse::<i64>().ok())
    }
}

// ── FloatLit ─────────────────────────────────────────────────────────

impl FloatLit {
    pub fn value_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, FLOAT)
    }

    pub fn value(&self) -> Option<f64> {
        self.value_token()
            .and_then(|t| t.text().parse::<f64>().ok())
    }
}

// ── StringLit ────────────────────────────────────────────────────────

impl StringLit {
    /// Returns the raw content between the quotes (excluding the quotes themselves).
    ///
    /// The opening quote is always present (the parser enters `string_literal`
    /// only on a `QUOTE` token). The closing quote may be absent if the string
    /// is unterminated — the parser emits an error and closes the node without
    /// consuming a trailing `QUOTE`. The `strip_suffix` fallback handles that
    /// error-recovery case.
    pub fn raw_text(&self) -> String {
        let full = self.syntax.text().to_string();
        let trimmed = full.strip_prefix('"').unwrap_or(&full);
        trimmed.strip_suffix('"').unwrap_or(trimmed).to_string()
    }
}

// ── BooleanLit ───────────────────────────────────────────────────────

impl BooleanLit {
    pub fn value(&self) -> Option<bool> {
        let tok = self
            .syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .find(|tok| matches!(tok.kind(), KW_TRUE | KW_FALSE))?;
        match tok.kind() {
            KW_TRUE => Some(true),
            KW_FALSE => Some(false),
            _ => None,
        }
    }
}

// ── AuthorWarning ────────────────────────────────────────────────────

impl AuthorWarning {
    /// Returns the warning text with the `TODO:` prefix stripped.
    ///
    /// Walks tokens directly — skips the `KW_TODO` token and the optional
    /// `COLON`, then collects remaining content until `NEWLINE`.
    pub fn text(&self) -> String {
        self.syntax
            .children_with_tokens()
            .filter_map(rowan::NodeOrToken::into_token)
            .skip_while(|tok| matches!(tok.kind(), KW_TODO | COLON) || tok.kind().is_trivia())
            .take_while(|tok| tok.kind() != NEWLINE)
            .map(|tok| tok.text().to_string())
            .collect::<String>()
            .trim()
            .to_string()
    }
}

// ── ChoiceCondition ──────────────────────────────────────────────────

impl ChoiceCondition {
    /// Returns the condition expression inside `{ expr }`.
    pub fn expr(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── InnerExpression ──────────────────────────────────────────────────

impl InnerExpression {
    /// Returns the wrapped expression.
    pub fn expr(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── ParenExpr ────────────────────────────────────────────────────────

impl ParenExpr {
    /// Returns the inner expression inside `( expr )`.
    pub fn inner(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
}

// ── BranchContent (extra) ────────────────────────────────────────────

impl BranchContent {
    pub fn divert(&self) -> Option<DivertNode> {
        support::child(&self.syntax)
    }
}

// ── MultilineBranchBody ──────────────────────────────────────────────

impl MultilineBranchBody {
    pub fn texts(&self) -> impl Iterator<Item = Text> {
        support::children(&self.syntax)
    }

    pub fn inline_logics(&self) -> impl Iterator<Item = InlineLogic> {
        support::children(&self.syntax)
    }

    pub fn glue_nodes(&self) -> impl Iterator<Item = GlueNode> {
        support::children(&self.syntax)
    }

    pub fn escapes(&self) -> impl Iterator<Item = Escape> {
        support::children(&self.syntax)
    }

    pub fn logic_lines(&self) -> impl Iterator<Item = LogicLine> {
        support::children(&self.syntax)
    }

    pub fn divert(&self) -> Option<DivertNode> {
        support::child(&self.syntax)
    }

    pub fn content_lines(&self) -> impl Iterator<Item = ContentLine> {
        support::children(&self.syntax)
    }

    pub fn choices(&self) -> impl Iterator<Item = Choice> {
        support::children(&self.syntax)
    }
}