atmos/os_lib/js/

dom_bridge.rs

//! JS ⇄ レンダラの DOM ブリッジ。
//!
//! `dom::parse_html` の結果を **ドキュメント順** にフラット化した軽量アリーナを持ち、
//! JS から `document.getElementById` 等で参照されるノードと、`textContent` /
//! `style` / `classList` の変更、`addEventListener('click')` で登録されたリスナを保持する。
//!
//! レンダラは毎レイアウトで `last_html` を再パースするため、ブリッジは
//! 「同一 HTML を同一ドキュメント順で歩けばインデックスが一致する」性質を使い、
//! `apply_overrides` で再パース木へ JS の変更を焼き戻してから CSS カスケードに渡す。
//! これにより既存のレンダリング経路をそのまま再利用できる（HTML 再シリアライズ不要）。

use alloc::collections::BTreeMap;
use alloc::collections::BTreeSet;
use alloc::format;
use alloc::string::String;
use alloc::string::ToString;
use alloc::vec::Vec;

use super::value::Value;
use crate::os_lib::dom::{Node, NodeType};

/// ブリッジ上の 1 ノード。要素またはテキスト。
pub struct DomNode {
    /// 要素タグ（小文字）。テキストノードは空。
    pub tag: String,
    pub is_text: bool,
    pub id: String,
    pub classes: Vec<String>,
    /// インライン style（プロパティ→値）。
    pub style: BTreeMap<String, String>,
    /// その他の属性（id/class/style 以外も含む生の値）。
    pub attrs: BTreeMap<String, String>,
    /// テキストノードの内容、または textContent 上書き値。
    pub text_override: Option<String>,
    /// 構築時のテキスト（textContent ゲッタ用）。
    pub initial_text: String,
    pub parent: Option<usize>,
    pub children: Vec<usize>,
    /// JS が classes を変更したか（apply で焼き戻す）。
    pub classes_dirty: bool,
    /// JS が style を変更したか。
    pub style_dirty: bool,
}

/// MutationObserver の登録エントリ。
pub struct MutObsReg {
    pub id: u32,
    pub target_idx: usize,
    pub child_list: bool,
    pub attributes: bool,
    pub subtree: bool,
    pub callback: Value,
    /// `observe(target, {attributeOldValue: true})`。変更前の属性値を
    /// レコードの `oldValue` として公開するかどうか。
    pub attribute_old_value: bool,
    /// `observe(target, {attributeFilter: [...]})`。指定時はこの一覧に
    /// 含まれる属性名の変化のみ通知する（`None` は全属性を監視）。
    pub attribute_filter: Option<Vec<String>>,
    /// `observe(target, {characterData: true})`（丸ごと未対応だった。
    /// テキストノードの`.data`/`.nodeValue`/`textContent`変更を監視する
    /// オプション自体が存在せず、対応する通知ヘルパ〔`notify_character_
    /// data`〕も無かったため、`characterData`を指定してもコールバックが
    /// 一切呼ばれなかった。`childList`/`attributes`は既に対応済みで
    /// `characterData`だけ抜けていた兄弟ギャップ。2026-07-17 発見・実装）。
    pub character_data: bool,
    /// `observe(target, {characterDataOldValue: true})`。変更前のテキスト
    /// 値をレコードの`oldValue`として公開するかどうか（`attributeOldValue`
    /// と対）。
    pub character_data_old_value: bool,
}

/// MutationObserver に届けるレコード（Rust 側内部表現）。
pub struct MutRec {
    pub type_: &'static str, // "childList" | "attributes"
    pub target_idx: usize,
    pub added: Vec<usize>,
    pub removed: Vec<usize>,
    pub attribute_name: Option<String>,
    /// `attributeOldValue: true` が指定された観察者向けにのみ Some を積む。
    pub old_value: Option<String>,
}

/// click 等のイベントリスナ登録。
pub struct Listener {
    pub node: usize,
    pub event: String,
    pub func: Value,
    /// キャプチャフェーズで発火するリスナか（addEventListener の capture オプション）。
    pub capture: bool,
    /// 一度発火したら自動削除されるか（once オプション）。
    pub once: bool,
    /// 一意 ID（once 削除や removeEventListener の照合に使う）。
    pub id: u64,
    /// `addEventListener(type, fn, {signal})`（丸ごと未対応だった。
    /// `AbortController` でリスナを一括解除する定番パターン。2026-07-14
    /// 発見・実装）。`signal.aborted` を都度チェックし、abort 済みなら
    /// 発火しない簡略実装（`abort` イベント発火と同時に即座に物理削除は
    /// せず、次回参照時に遅延評価する。実務上は「以後発火しなくなる」
    /// という観測可能な挙動が同じであれば十分なため）。
    pub signal: Option<Value>,
}

/// `AbortSignal` オブジェクトの `.aborted` が `true` か。
pub fn is_signal_aborted(signal: &Value) -> bool {
    matches!(signal, Value::Object(o) if matches!(o.borrow().props.get("aborted"), Some(Value::Bool(true))))
}

fn is_listener_aborted(l: &Listener) -> bool {
    l.signal.as_ref().is_some_and(is_signal_aborted)
}

/// DOM ブリッジ本体。`JsRuntime` が `Rc<RefCell<>>` で保持し、レンダラと共有する。
pub struct DomBridge {
    pub nodes: Vec<DomNode>,
    pub listeners: Vec<Listener>,
    /// JS が DOM を変更したフラグ。ホストはこれを見て再レイアウトする。
    pub dirty: bool,
    /// 構築済みかどうか（未構築なら getElementById 等は空を返す）。
    pub built: bool,
    /// レイアウト後の要素矩形 (x, y, w, h)（ページ座標）。getBoundingClientRect /
    /// offsetWidth 等が参照。レンダラが flatten 後に populate する。
    pub rects: BTreeMap<usize, (i32, i32, i32, i32)>,
    /// レイアウト後の各要素のborder幅 (top, right, bottom, left)。
    pub border_widths: BTreeMap<usize, (i32, i32, i32, i32)>,
    /// 算出スタイル（カスケード後の specified_values、kebab-case キー）。
    /// getComputedStyle が参照。レンダラがスタイル適用後に populate する。
    pub computed_styles: BTreeMap<usize, BTreeMap<String, String>>,
    /// サブスクロールコンテナの現在 scrollTop (node_idx → px)。
    /// JS が `el.scrollTop = N` で書き込み、レンダラが再レイアウト後に同期する。
    pub scroll_tops: BTreeMap<usize, i32>,
    /// サブスクロールコンテナの scrollHeight (node_idx → px)。
    /// レンダラが parse_and_layout 後に populate する（コンテナ高 + scroll_max_y）。
    pub scroll_heights: BTreeMap<usize, i32>,
    /// リスナ ID の発番カウンタ（once / removeEventListener 照合用）。
    pub next_listener_id: u64,
    /// 登録済み MutationObserver。
    pub mut_observers: Vec<MutObsReg>,
    /// DOM 変更時に積まれるレコードキュー（observer_id, record）。
    pub mut_records: Vec<(u32, MutRec)>,
    /// MutationObserver の ID 発番カウンタ。
    pub next_mut_obs_id: u32,
    /// `setPointerCapture`/`releasePointerCapture`/`hasPointerCapture`
    /// （Pointer Events。丸ごと未対応だった）が捕捉中の (node_idx, pointerId) 集合。
    /// この処理系のイベント配信はヒットテストベースのため、実際にその後の
    /// pointer イベントをこの要素へ強制配送するところまでは配線しない
    /// （`hasPointerCapture` が仕様どおりの真偽を返せるようにする状態管理のみの
    /// 簡略実装。`inert` 属性のポインタ操作抑制のみ実装と同種の部分対応）。
    pub pointer_captures: BTreeSet<(usize, i32)>,
    /// `document.activeElement`/`element.focus()`/`.blur()`（HTML5。丸ごと
    /// 未対応だった）。現在フォーカス中のノード index。`WebEngine::focused_id`
    /// （レンダラ側の文字列キー版フォーカス状態）とは別に、JS 側から直接
    /// 読み書きできる node index ベースの状態としてここに持つ。レンダラの
    /// 実クリック/`autofocus` によるフォーカス変更も同期される（詳細は
    /// `layout.rs`/`render.rs` の `focused_id` 代入箇所を参照）。id/name 属性を
    /// 持たない要素へのレンダラ起点フォーカスは同期対象外（レンダラ自身の
    /// 既存の制約と同じ）。
    pub focused_idx: Option<usize>,
    /// `window.scrollTo(x, y)`/`window.scroll(x, y)`（丸ごと未対応だった。
    /// 実装はあったが `SCROLL_Y` という孤立した `static` へ書き込むのみで、
    /// `window.scrollY`/実際のレンダラ描画位置のどちらにも一切反映されない
    /// 死んだ経路だった。2026-07-16 発見）。JS→レンダラの片方向同期用の
    /// 「保留中の絶対スクロール先」。`focused_idx`と同じ「レンダラが毎フレーム
    /// 消費する」設計だが、フォーカスと違い同一フレーム内での即時反映が
    /// 不要（次の描画で反映されれば十分）なため、`render.rs`の`draw()`冒頭
    /// 1箇所でのみ消費すればよく、`.focus()`のような10箇所以上への配線は
    /// 不要（改修規模がずっと小さい）。
    pub pending_scroll_abs_y: Option<i32>,
    /// `window.scrollBy(x, y)`（丸ごと未対応だった。`dom_noop`のまま）。
    /// 複数回呼ばれた場合は加算し、次の描画で一括反映する。
    pub pending_scroll_by_y: Option<i32>,
    /// `element.onchange = fn`のような GlobalEventHandlers IDL 属性（関数値）の
    /// 永続的な保管先。以前は`Obj::dom(idx)`（呼び出す度に新規生成される使い捨ての
    /// ラッパーオブジェクト）自身の`.props`へ書き込んでいたため、代入直後に
    /// そのRcが破棄されると値ごと消え、`dispatchEvent`側が同じ`Obj::dom(idx)`を
    /// 新規生成して読み直しても常に見つからない（＝ハンドラが一切発火しない）
    /// 静かなバグだった。`listeners`（addEventListener系）と同じくDOM構造体側に
    /// 持たせることで、どの`Obj::dom(idx)`インスタンス経由でも一貫して読み書き
    /// できるようにする。キーは`(node_idx, "onchange"等のプロパティ名)`。
    pub on_handlers: BTreeMap<(usize, String), Value>,
}

impl Default for DomBridge {
    fn default() -> Self {
        Self::new()
    }
}

/// `ValidityState`（HTML5 制約検証）の個別フラグ。以前は `element.validity` が
/// `valid`/`valueMissing`/`customError` の3つしか公開せず、`input.validity.
/// patternMismatch`/`.typeMismatch`/`.rangeOverflow` 等、特定の制約だけを狙い撃ちして
/// カスタムエラーメッセージを出し分ける定番パターンが常に `undefined`（falsy）に
/// なっていた。
#[derive(Default)]
pub struct ValidityFlags {
    pub value_missing: bool,
    pub type_mismatch: bool,
    pub pattern_mismatch: bool,
    pub too_long: bool,
    pub too_short: bool,
    pub range_overflow: bool,
    pub range_underflow: bool,
    pub step_mismatch: bool,
    pub bad_input: bool,
    pub custom_error: bool,
}
impl ValidityFlags {
    pub fn valid(&self) -> bool {
        !(self.value_missing
            || self.type_mismatch
            || self.pattern_mismatch
            || self.too_long
            || self.too_short
            || self.range_overflow
            || self.range_underflow
            || self.step_mismatch
            || self.bad_input
            || self.custom_error)
    }
}

// ===== セレクタパーサ（`matches`/`closest`/`querySelector(All)` 共通） =====
// タグ/`#id`/`.class`/`[attr...]` のコンパウンドセレクタと、空白（子孫）/`>`（子）/
// `+`（隣接兄弟）/`~`（一般兄弟）の結合子、`:not()`/`:is()`/`:where()`/
// `:first-child`/`:last-child`/`:only-child`/`:nth-child()`/`:nth-last-child()`/
// `:first-of-type`/`:last-of-type`/`:only-of-type`/`:nth-of-type()`/
// `:nth-last-of-type()` 疑似クラスをサポートする。`:hover`/`:has()`/`:scope` 等
// その他の疑似クラスは非対応（改修規模を絞るための意図的な割り切り）。

#[derive(Clone, Copy)]
enum AttrOp {
    Exists,
    Eq,
    Prefix,
    Suffix,
    Contains,
    Word,
}

struct AttrSel {
    name: String,
    op: AttrOp,
    value: String,
}

#[derive(Default)]
struct CompoundSel {
    tag: Option<String>,
    id: Option<String>,
    classes: Vec<String>,
    attrs: Vec<AttrSel>,
    /// `:not(sel1, sel2, ...)` の中身（コンパウンドセレクタのみ対応。結合子を含む
    /// 複雑なセレクタは非対応）。いずれか1つでも一致すれば不一致とする。
    not: Vec<CompoundSel>,
    /// `:is(sel1, sel2, ...)`/`:where(...)` の中身（コンパウンドセレクタのみ対応。
    /// 仕様上 `:where()` は詳細度の扱いのみ `:is()` と異なるが、この処理系は
    /// 詳細度を計算しないためマッチ判定は完全に同一として扱う）。いずれか1つでも
    /// 一致すれば一致とする（空なら制約なし = 常に一致）。
    is_list: Vec<CompoundSel>,
    /// `:first-child`/`:last-child`/`:only-child`/`:nth-child(...)`。
    pos: Vec<PosPseudo>,
    /// `:first-of-type`/`:last-of-type`/`:only-of-type`/`:nth-of-type(...)`
    /// （タグ名が同じ兄弟のみを数える点以外は `pos` と同じ規則）。
    pos_of_type: Vec<PosPseudo>,
    /// `:scope`（Selectors Level 4。丸ごと未対応だった）。マッチ時に呼び出し元が
    /// 渡す `scope_root`（`element.querySelectorAll`/`matches`/`closest` 等の
    /// 起点ノード）と一致する場合のみ真になる。詳細は `compound_matches` 参照。
    is_scope: bool,
}

#[derive(Clone, Copy)]
struct NthFormula {
    a: i32,
    b: i32,
}

#[derive(Clone, Copy)]
enum PosPseudo {
    First,
    Last,
    Only,
    Nth(NthFormula),
    /// `:nth-last-child()`/`:nth-last-of-type()`（末尾から数える版）。判定時に
    /// `count - position + 1`（末尾からの1始まり位置）を式へ渡す点のみ `Nth` と異なる。
    NthLast(NthFormula),
}

/// `:nth-child()` 引数（`odd`/`even`/`N`/`aN+b`/`aN-b`/`-aN+b`）を解析する。
fn parse_nth_formula(s: &str) -> Option<NthFormula> {
    let s: String = s.chars().filter(|c| !c.is_whitespace()).collect();
    let s = s.to_lowercase();
    if s == "odd" {
        return Some(NthFormula { a: 2, b: 1 });
    }
    if s == "even" {
        return Some(NthFormula { a: 2, b: 0 });
    }
    if let Some(n_pos) = s.find('n') {
        let a_part = s.get(..n_pos).unwrap_or("");
        let a = match a_part {
            "" | "+" => 1,
            "-" => -1,
            _ => a_part.parse::<i32>().ok()?,
        };
        let b_part = s.get(n_pos + 1..).unwrap_or("");
        let b = if b_part.is_empty() {
            0
        } else {
            b_part.parse::<i32>().ok()?
        };
        return Some(NthFormula { a, b });
    }
    let n = s.parse::<i32>().ok()?;
    Some(NthFormula { a: 0, b: n })
}

/// `position`（1始まり）が `an+b` 式（`n` は 0,1,2,...）のいずれかの `n` で
/// 表せるか判定する。
fn nth_formula_matches(f: NthFormula, position: usize) -> bool {
    let p = position as i32;
    if f.a == 0 {
        return p == f.b;
    }
    let diff = p - f.b;
    diff % f.a == 0 && diff / f.a >= 0
}

#[derive(Clone, Copy)]
enum Combinator {
    Descendant,
    Child,
    Adjacent,
    General,
}

struct SelStep {
    compound: CompoundSel,
    /// 直前のステップとの結合子（先頭ステップは `None`）。
    combinator: Option<Combinator>,
}

/// `[attr...]` 1件を解析する（`name`/`name=val`/`name^=val`/`name$=val`/`name*=val`/
/// `name~=val`。値の前後のクォートは剥がす）。
fn parse_attr_sel(inner: &str) -> Option<AttrSel> {
    let inner = inner.trim();
    for (token, op) in [
        ("^=", AttrOp::Prefix),
        ("$=", AttrOp::Suffix),
        ("*=", AttrOp::Contains),
        ("~=", AttrOp::Word),
        ("=", AttrOp::Eq),
    ] {
        if let Some((name, val)) = inner.split_once(token) {
            let val = val.trim().trim_matches(|c| c == '"' || c == '\'');
            return Some(AttrSel {
                name: name.trim().to_string(),
                op,
                value: val.to_string(),
            });
        }
    }
    if inner.is_empty() {
        return None;
    }
    Some(AttrSel {
        name: inner.to_string(),
        op: AttrOp::Exists,
        value: String::new(),
    })
}

/// コンビネータを含まない単一コンパウンドセレクタ（`div.active#foo[data-x=y]`）を解析する。
/// `*`（ユニバーサルセレクタ）は制約が何も無い `CompoundSel::default()` になるが、
/// 末尾の「制約が空なら無効」判定に引っかかって `None` に潰れてしまい、
/// `querySelectorAll('*')` が常に0件になる回帰があった（自己検証で発見）。
/// `*` はここで即座に有効な（＝全ノードにマッチする）セレクタとして扱う。
fn parse_compound(s: &str) -> Option<CompoundSel> {
    let s = s.trim();
    if s.is_empty() {
        return None;
    }
    if s == "*" {
        return Some(CompoundSel::default());
    }
    let mut c = CompoundSel::default();
    let mut cur = String::new();
    let mut mode = ' '; // ' '=tag, '#'=id, '.'=class, '['=attr
    let chars: Vec<char> = s.chars().collect();
    let mut i = 0;
    let flush = |mode: char, cur: &mut String, c: &mut CompoundSel| {
        if cur.is_empty() {
            return;
        }
        match mode {
            ' ' => {
                if cur.as_str() != "*" {
                    c.tag = Some(cur.to_lowercase());
                }
            }
            '#' => c.id = Some(cur.clone()),
            '.' => c.classes.push(cur.clone()),
            _ => {}
        }
        cur.clear();
    };
    while i < chars.len() {
        let ch = chars[i];
        match ch {
            '#' | '.' => {
                flush(mode, &mut cur, &mut c);
                mode = ch;
            }
            '[' => {
                flush(mode, &mut cur, &mut c);
                let start = i + 1;
                let mut depth = 1;
                let mut j = start;
                while j < chars.len() && depth > 0 {
                    match chars[j] {
                        '[' => depth += 1,
                        ']' => depth -= 1,
                        _ => {}
                    }
                    if depth > 0 {
                        j += 1;
                    }
                }
                let inner: String = chars[start..j.min(chars.len())].iter().collect();
                if let Some(attr) = parse_attr_sel(&inner) {
                    c.attrs.push(attr);
                }
                i = j;
                mode = ' ';
            }
            ':' => {
                // `:pseudo` / `:pseudo(...)`。`:not(sel1, sel2, ...)`/`:nth-child(...)`/
                // `:first-child`/`:last-child`/`:only-child` に対応。その他の疑似クラス
                // （`:is()`/`:where()`/`:hover` 等）は改修規模を絞るため静かに無視する
                // （マッチ条件には影響しない = 常にスキップ扱い）。
                flush(mode, &mut cur, &mut c);
                let mut j = i + 1;
                let name_start = j;
                while j < chars.len() && (chars[j].is_alphanumeric() || chars[j] == '-') {
                    j += 1;
                }
                let name: String = chars[name_start..j].iter().collect::<String>().to_lowercase();
                if j < chars.len() && chars[j] == '(' {
                    let paren_start = j + 1;
                    let mut depth = 1;
                    let mut k = paren_start;
                    while k < chars.len() && depth > 0 {
                        match chars[k] {
                            '(' => depth += 1,
                            ')' => depth -= 1,
                            _ => {}
                        }
                        if depth > 0 {
                            k += 1;
                        }
                    }
                    if name == "not" {
                        let inner: String = chars[paren_start..k.min(chars.len())].iter().collect();
                        for part in inner.split(',') {
                            if let Some(inner_compound) = parse_compound(part.trim()) {
                                c.not.push(inner_compound);
                            }
                        }
                    } else if name == "nth-child" {
                        let inner: String = chars[paren_start..k.min(chars.len())].iter().collect();
                        if let Some(formula) = parse_nth_formula(&inner) {
                            c.pos.push(PosPseudo::Nth(formula));
                        }
                    } else if name == "nth-of-type" {
                        let inner: String = chars[paren_start..k.min(chars.len())].iter().collect();
                        if let Some(formula) = parse_nth_formula(&inner) {
                            c.pos_of_type.push(PosPseudo::Nth(formula));
                        }
                    } else if name == "nth-last-child" {
                        let inner: String = chars[paren_start..k.min(chars.len())].iter().collect();
                        if let Some(formula) = parse_nth_formula(&inner) {
                            c.pos.push(PosPseudo::NthLast(formula));
                        }
                    } else if name == "nth-last-of-type" {
                        let inner: String = chars[paren_start..k.min(chars.len())].iter().collect();
                        if let Some(formula) = parse_nth_formula(&inner) {
                            c.pos_of_type.push(PosPseudo::NthLast(formula));
                        }
                    } else if name == "is" || name == "where" {
                        let inner: String = chars[paren_start..k.min(chars.len())].iter().collect();
                        for part in inner.split(',') {
                            if let Some(inner_compound) = parse_compound(part.trim()) {
                                c.is_list.push(inner_compound);
                            }
                        }
                    }
                    j = k;
                } else {
                    match name.as_str() {
                        "first-child" => c.pos.push(PosPseudo::First),
                        "last-child" => c.pos.push(PosPseudo::Last),
                        "only-child" => c.pos.push(PosPseudo::Only),
                        "first-of-type" => c.pos_of_type.push(PosPseudo::First),
                        "last-of-type" => c.pos_of_type.push(PosPseudo::Last),
                        "only-of-type" => c.pos_of_type.push(PosPseudo::Only),
                        // `:scope`（Selectors Level 4。丸ごと未対応だった）。
                        "scope" => c.is_scope = true,
                        _ => {}
                    }
                }
                i = j;
                mode = ' ';
            }
            _ => cur.push(ch),
        }
        i += 1;
    }
    flush(mode, &mut cur, &mut c);
    if c.tag.is_none()
        && c.id.is_none()
        && c.classes.is_empty()
        && c.attrs.is_empty()
        && c.not.is_empty()
        && c.is_list.is_empty()
        && c.pos.is_empty()
        && c.pos_of_type.is_empty()
        && !c.is_scope
    {
        return None;
    }
    Some(c)
}

/// セレクタ文字列全体を、トップレベル（`[...]`/`(...)` の外側）のカンマだけで
/// 分割する（`selector.split(',')` を単純に使うと `:is(.a, .b)` の中のカンマも
/// セレクタグループの区切りと誤認識し、`:is(.a` / ` .b)` という壊れた2グループに
/// 分解されてしまうバグがあった。`node_matches`/`query_all` の「カンマ区切りは
/// OR」処理の入口はここを必ず経由すること）。
fn split_top_level_commas(s: &str) -> Vec<String> {
    let mut parts = Vec::new();
    let mut cur = String::new();
    let mut depth = 0i32;
    for ch in s.chars() {
        match ch {
            '[' | '(' => {
                depth += 1;
                cur.push(ch);
            }
            ']' | ')' => {
                depth -= 1;
                cur.push(ch);
            }
            ',' if depth == 0 => {
                parts.push(core::mem::take(&mut cur));
            }
            _ => cur.push(ch),
        }
    }
    parts.push(cur);
    parts
}

/// カンマで区切られた1グループ分のセレクタ文字列を、結合子記号（`>`/`+`/`~`）と
/// 空白区切りのコンパウンドセレクタ文字列トークンへ分割する（`[...]`/`(...)` 内の
/// 空白は区切りとして扱わない）。
fn tokenize_selector_group(s: &str) -> Vec<String> {
    let mut tokens = Vec::new();
    let mut cur = String::new();
    let mut depth = 0i32;
    for ch in s.chars() {
        match ch {
            '[' | '(' => {
                depth += 1;
                cur.push(ch);
            }
            ']' | ')' => {
                depth -= 1;
                cur.push(ch);
            }
            '>' | '+' | '~' if depth == 0 => {
                if !cur.trim().is_empty() {
                    tokens.push(cur.trim().to_string());
                    cur.clear();
                }
                tokens.push(ch.to_string());
            }
            c if c.is_whitespace() && depth == 0 => {
                if !cur.trim().is_empty() {
                    tokens.push(cur.trim().to_string());
                    cur.clear();
                }
            }
            _ => cur.push(ch),
        }
    }
    if !cur.trim().is_empty() {
        tokens.push(cur.trim().to_string());
    }
    tokens
}

/// トークン列（コンパウンド文字列と結合子記号が混在）から `SelStep` 列を組み立てる。
fn build_steps(tokens: &[String]) -> Vec<SelStep> {
    let mut steps: Vec<SelStep> = Vec::new();
    let mut pending: Option<Combinator> = None;
    for tok in tokens {
        match tok.as_str() {
            ">" => pending = Some(Combinator::Child),
            "+" => pending = Some(Combinator::Adjacent),
            "~" => pending = Some(Combinator::General),
            _ => {
                let combinator = if steps.is_empty() {
                    None
                } else {
                    Some(pending.take().unwrap_or(Combinator::Descendant))
                };
                if let Some(compound) = parse_compound(tok) {
                    steps.push(SelStep { compound, combinator });
                }
            }
        }
    }
    steps
}

impl DomBridge {
    pub fn new() -> Self {
        DomBridge {
            nodes: Vec::new(),
            listeners: Vec::new(),
            dirty: false,
            built: false,
            rects: BTreeMap::new(),
            border_widths: BTreeMap::new(),
            computed_styles: BTreeMap::new(),
            scroll_tops: BTreeMap::new(),
            scroll_heights: BTreeMap::new(),
            next_listener_id: 1,
            mut_observers: Vec::new(),
            mut_records: Vec::new(),
            next_mut_obs_id: 1,
            pointer_captures: BTreeSet::new(),
            focused_idx: None,
            pending_scroll_abs_y: None,
            pending_scroll_by_y: None,
            on_handlers: BTreeMap::new(),
        }
    }

    /// `element.onXXX = fn`（関数値）の永続的な書き込み。
    pub fn set_on_handler(&mut self, node: usize, key: &str, val: Value) {
        self.on_handlers.insert((node, key.to_string()), val);
    }
    /// `element.onXXX`の読み出し。未設定なら`None`。
    pub fn get_on_handler(&self, node: usize, key: &str) -> Option<Value> {
        self.on_handlers.get(&(node, key.to_string())).cloned()
    }

    /// `element.setPointerCapture(pointerId)`。
    pub fn set_pointer_capture(&mut self, idx: usize, pointer_id: i32) {
        self.pointer_captures.insert((idx, pointer_id));
    }
    /// `element.releasePointerCapture(pointerId)`。
    pub fn release_pointer_capture(&mut self, idx: usize, pointer_id: i32) {
        self.pointer_captures.remove(&(idx, pointer_id));
    }
    /// `element.hasPointerCapture(pointerId)`。
    pub fn has_pointer_capture(&self, idx: usize, pointer_id: i32) -> bool {
        self.pointer_captures.contains(&(idx, pointer_id))
    }

    /// MutationObserver: childList 変化を記録するヘルパ。
    fn notify_child_list(&mut self, parent_idx: usize, added: Vec<usize>, removed: Vec<usize>) {
        for obs in &self.mut_observers {
            let watches = obs.child_list
                && (obs.target_idx == parent_idx
                    || (obs.subtree && self.is_ancestor_of(obs.target_idx, parent_idx)));
            if watches {
                self.mut_records.push((
                    obs.id,
                    MutRec {
                        type_: "childList",
                        target_idx: parent_idx,
                        added: added.clone(),
                        removed: removed.clone(),
                        attribute_name: None,
                        old_value: None,
                    },
                ));
            }
        }
    }

    /// MutationObserver: 属性変化を記録するヘルパ。`attributeFilter` が指定された
    /// 観察者はその一覧に無い属性名を無視し、`attributeOldValue` が指定された
    /// 観察者にのみ変更前の値をレコードへ積む（以前はどちらのオプションも
    /// 読み取られておらず、`attributeFilter` 指定時も無関係な属性の変化まで
    /// 全て通知され、`oldValue` は常に `null` 固定だった）。
    fn notify_attribute(&mut self, idx: usize, attr_name: &str, old_value: Option<&str>) {
        for obs in &self.mut_observers {
            let watches = obs.attributes
                && (obs.target_idx == idx
                    || (obs.subtree && self.is_ancestor_of(obs.target_idx, idx)))
                && obs
                    .attribute_filter
                    .as_ref()
                    .is_none_or(|f| f.iter().any(|n| n == attr_name));
            if watches {
                self.mut_records.push((
                    obs.id,
                    MutRec {
                        type_: "attributes",
                        target_idx: idx,
                        added: Vec::new(),
                        removed: Vec::new(),
                        attribute_name: Some(String::from(attr_name)),
                        old_value: if obs.attribute_old_value {
                            Some(old_value.unwrap_or("").to_string())
                        } else {
                            None
                        },
                    },
                ));
            }
        }
    }

    /// MutationObserver: テキストノードの内容変化を記録するヘルパ（丸ごと
    /// 未対応だった。`notify_attribute`と対になる`characterData`版。
    /// `idx`は変化した**テキストノード自身**のインデックス〔仕様上
    /// `CharacterData`のmutationはテキストノード自身がtargetになる〕。
    /// 2026-07-17 発見・実装）。
    fn notify_character_data(&mut self, idx: usize, old_value: Option<&str>) {
        for obs in &self.mut_observers {
            let watches = obs.character_data
                && (obs.target_idx == idx
                    || (obs.subtree && self.is_ancestor_of(obs.target_idx, idx)));
            if watches {
                self.mut_records.push((
                    obs.id,
                    MutRec {
                        type_: "characterData",
                        target_idx: idx,
                        added: Vec::new(),
                        removed: Vec::new(),
                        attribute_name: None,
                        old_value: if obs.character_data_old_value {
                            Some(old_value.unwrap_or("").to_string())
                        } else {
                            None
                        },
                    },
                ));
            }
        }
    }

    /// レンダラがレイアウト後に要素矩形を登録する（getBoundingClientRect 等が参照）。
    pub fn set_rect(&mut self, idx: usize, x: i32, y: i32, w: i32, h: i32) {
        self.rects.insert(idx, (x, y, w, h));
    }
    pub fn get_rect(&self, idx: usize) -> Option<(i32, i32, i32, i32)> {
        self.rects.get(&idx).copied()
    }
    pub fn set_border_widths(&mut self, idx: usize, top: i32, right: i32, bottom: i32, left: i32) {
        self.border_widths.insert(idx, (top, right, bottom, left));
    }
    pub fn get_border_widths(&self, idx: usize) -> (i32, i32, i32, i32) {
        self.border_widths.get(&idx).copied().unwrap_or((0, 0, 0, 0))
    }
    pub fn clear_rects(&mut self) {
        self.rects.clear();
        self.border_widths.clear();
    }

    /// 算出スタイルを登録（kebab-case プロパティ→値）。
    pub fn set_computed_style(&mut self, idx: usize, prop: &str, val: &str) {
        self.computed_styles
            .entry(idx)
            .or_default()
            .insert(String::from(prop), String::from(val));
    }
    /// 算出スタイルを取得（無ければインライン style → 空）。
    pub fn get_computed(&self, idx: usize, prop: &str) -> String {
        if let Some(m) = self.computed_styles.get(&idx) {
            if let Some(v) = m.get(prop) {
                return v.clone();
            }
        }
        self.nodes
            .get(idx)
            .and_then(|n| n.style.get(prop))
            .cloned()
            .unwrap_or_default()
    }
    pub fn clear_computed(&mut self) {
        self.computed_styles.clear();
    }

    /// 新しいページの DOM 木からブリッジを再構築する（リスナはクリア）。
    pub fn build_from(&mut self, root: &Node) {
        self.nodes.clear();
        self.listeners.clear();
        self.dirty = false;
        self.built = true;
        Self::collect(root, None, &mut self.nodes);
        // 各要素の initial_text をドキュメント順走査で集約。
        let n = self.nodes.len();
        for i in 0..n {
            if !self.nodes[i].is_text {
                let t = self.collect_text(i);
                self.nodes[i].initial_text = t;
            }
        }
        // `<details name="...">`排他グループの初期状態正規化（HTML5。丸ごと
        // 未対応だった）。クリック操作時の排他挙動は`render.rs`側で対応
        // 済みだが、HTML記述時点で同じ`name`を持つ複数の`<details open>`が
        // 並んでいた場合、仕様上は文書順で最後の1つだけが開いた状態のまま
        // 残り、それより前のものは自動的に閉じられる必要がある。この
        // パース直後の正規化が漏れていた。2026-07-18 発見・実装）。
        {
            let mut last_open_by_name: alloc::collections::BTreeMap<String, usize> = alloc::collections::BTreeMap::new();
            for i in 0..n {
                let node = &self.nodes[i];
                if node.tag == "details" && node.attrs.contains_key("open") {
                    if let Some(name) = node.attrs.get("name").filter(|s| !s.is_empty()) {
                        last_open_by_name.insert(name.clone(), i);
                    }
                }
            }
            for i in 0..n {
                let node = &self.nodes[i];
                if node.tag == "details" && node.attrs.contains_key("open") {
                    if let Some(name) = node.attrs.get("name").filter(|s| !s.is_empty()) {
                        if last_open_by_name.get(name) != Some(&i) {
                            self.nodes[i].attrs.remove("open");
                        }
                    }
                }
            }
        }
    }

    /// 木をドキュメント順（プリオーダ）に再帰収集。子インデックスを記録する。
    fn collect(node: &Node, parent: Option<usize>, out: &mut Vec<DomNode>) -> usize {
        let idx = out.len();
        let dn = match &node.node_type {
            NodeType::Text(t) => DomNode {
                tag: String::new(),
                is_text: true,
                id: String::new(),
                classes: Vec::new(),
                style: BTreeMap::new(),
                attrs: BTreeMap::new(),
                text_override: None,
                initial_text: t.clone(),
                parent,
                children: Vec::new(),
                classes_dirty: false,
                style_dirty: false,
            },
            NodeType::Element {
                tag_name,
                attributes,
                classes,
                id,
            } => {
                let style =
                    parse_inline_style(attributes.get("style").map(|s| s.as_str()).unwrap_or(""));
                DomNode {
                    tag: tag_name.clone(),
                    is_text: false,
                    id: id.clone().unwrap_or_default(),
                    classes: classes.clone(),
                    style,
                    attrs: attributes.clone(),
                    text_override: None,
                    initial_text: String::new(),
                    parent,
                    children: Vec::new(),
                    classes_dirty: false,
                    style_dirty: false,
                }
            }
        };
        out.push(dn);
        let mut kids = Vec::new();
        for c in &node.children {
            kids.push(Self::collect(c, Some(idx), out));
        }
        out[idx].children = kids;
        idx
    }

    /// 部分木のテキストを連結（textContent 相当）。現在値（override 優先）で集約。
    fn collect_text(&self, idx: usize) -> String {
        let node = &self.nodes[idx];
        if node.tag == "#comment" {
            return node.text_override.clone().unwrap_or_else(|| node.initial_text.clone());
        }
        let mut s = String::new();
        self.collect_text_into(idx, &mut s);
        s
    }
    fn collect_text_into(&self, idx: usize, out: &mut String) {
        let node = &self.nodes[idx];
        if node.is_text {
            out.push_str(node.text_override.as_deref().unwrap_or(&node.initial_text));
            return;
        }
        for &c in &node.children {
            self.collect_text_into(c, out);
        }
    }

    // ---- 参照系 ----

    /// id → ノード添字の対応表を 1 回で作る。
    ///
    /// 【2026-08-05】`get_element_by_id` は全ノードの線形走査で、
    /// しかも各ノードで `is_attached` が親を辿る。
    /// レイアウト後の矩形反映では**要素 1 個ごとに**これを呼んでおり、
    /// O(要素 × ノード × 深さ) になっていた（実測で要素・ノードとも約 369）。
    ///
    /// 走査 1 回で表を作れば、引く側は O(log N) で済む。
    /// 条件（テキストノードでない・id が空でない・ルートから到達可能）は
    /// `get_element_by_id` と揃えてある。同じ id が複数あれば先勝ち
    /// （`find` と同じ）。
    ///
    /// 計算量: **O(N × D)**（N はノード数、D は木の深さ）。
    pub fn build_id_index(&self) -> alloc::collections::BTreeMap<&str, usize> {
        let mut map: alloc::collections::BTreeMap<&str, usize> =
            alloc::collections::BTreeMap::new();
        if !self.built {
            return map;
        }
        for i in 0..self.nodes.len() {
            let n = &self.nodes[i];
            if n.is_text || n.id.is_empty() {
                continue;
            }
            if !self.is_attached(i) {
                continue;
            }
            map.entry(n.id.as_str()).or_insert(i);
        }
        map
    }

    pub fn get_element_by_id(&self, id: &str) -> Option<usize> {
        if !self.built {
            return None;
        }
        if let Some(rest) = id.strip_prefix("_node_idx_") {
            if let Ok(idx) = rest.parse::<usize>() {
                if idx < self.nodes.len() && !self.nodes[idx].is_text && self.is_attached(idx) {
                    return Some(idx);
                }
            }
        }
        (0..self.nodes.len())
            .find(|&i| !self.nodes[i].is_text && self.nodes[i].id == id && self.is_attached(i))
    }

    /// node[0]（ルート）から到達可能か。createElement 直後や remove 済みは false。
    /// `node.isConnected`（丸ごと未対応だった）向けに公開する。
    pub fn is_attached(&self, idx: usize) -> bool {
        let mut cur = idx;
        let mut guard = 0;
        loop {
            if cur == 0 {
                return true;
            }
            match self.nodes.get(cur).and_then(|n| n.parent) {
                Some(p) => {
                    cur = p;
                    guard += 1;
                    if guard > self.nodes.len() {
                        return false;
                    }
                }
                None => return false,
            }
        }
    }

    /// 単純セレクタ（`#id` / `.class` / `tag`、先頭一致）にマッチする最初のノード。
    pub fn query(&self, selector: &str) -> Option<usize> {
        self.query_all(selector).into_iter().next()
    }

    /// セレクタにマッチする全ノード（ドキュメント順）。以前は `node_matches` と同じ
    /// 単純セレクタ限定の簡略実装が独立に重複しており、`querySelectorAll('div.active')`
    /// 等のコンパウンドセレクタが常に空になる同型のバグだった。`node_matches` と
    /// 共通の `compound_matches`/`match_selector_chain` に統一して解消する。
    pub fn query_all(&self, selector: &str) -> Vec<usize> {
        self.query_all_scoped(selector, None)
    }

    /// `query_all` の `:scope` 対応版。`element.querySelectorAll`/`querySelector`
    /// の起点要素を `scope_root` として渡すと、セレクタ中の `:scope` 疑似クラス
    /// （Selectors Level 4。丸ごと未対応だった）がそのノードにのみ一致するように
    /// なる（詳細は `node_matches_scoped` 参照）。
    pub fn query_all_scoped(&self, selector: &str, scope_root: Option<usize>) -> Vec<usize> {
        let sel = selector.trim();
        let mut out = Vec::new();
        if !self.built || sel.is_empty() {
            return out;
        }
        for i in 0..self.nodes.len() {
            if !self.is_attached(i) {
                continue;
            }
            if self.node_matches_scoped(i, sel, scope_root) {
                out.push(i);
            }
        }
        out
    }

    // ---- 変更系 ----

    /// 要素の textContent を設定。子孫テキストノードがあれば最初に値を入れ残りを空に、
    /// 無ければ既存の子を捨てて単一テキスト子を作る（createElement したノード等）。
    pub fn set_text_content(&mut self, idx: usize, val: &str) {
        if idx >= self.nodes.len() {
            return;
        }
        if self.nodes[idx].tag == "#comment" {
            let old_val = self.nodes[idx]
                .text_override
                .as_deref()
                .unwrap_or(&self.nodes[idx].initial_text)
                .to_string();
            self.nodes[idx].text_override = Some(val.to_string());
            if old_val != val {
                self.notify_character_data(idx, Some(&old_val));
            }
            self.dirty = true;
            return;
        }
        let text_nodes = self.descendant_text_nodes(idx);
        if text_nodes.is_empty() && !self.nodes[idx].is_text {
            // テキスト子を新設（子が1件も無かった場合のみ通る経路。この childList
            // 変化も他の子ノード追加経路と同様に MutationObserver へ通知する）。
            let t = self.new_text_node(val);
            self.nodes[idx].children.clear();
            self.nodes[t].parent = Some(idx);
            self.nodes[idx].children.push(t);
            self.notify_child_list(idx, alloc::vec![t], Vec::new());
        } else {
            for (k, t) in text_nodes.iter().enumerate() {
                let new_val = if k == 0 { val.to_string() } else { String::new() };
                // `characterData`監視（丸ごと未対応だった。テキストノードの
                // 内容が実際に変わった場合のみ通知する。詳細は
                // `notify_character_data`のdocコメント参照。2026-07-17
                // 発見・実装）。
                let old_val = self.nodes[*t]
                    .text_override
                    .as_deref()
                    .unwrap_or(&self.nodes[*t].initial_text)
                    .to_string();
                self.nodes[*t].text_override = Some(new_val.clone());
                if old_val != new_val {
                    self.notify_character_data(*t, Some(&old_val));
                }
            }
        }
        self.dirty = true;
    }

    /// `node.normalize()`（丸ごと未対応だった。DOM 標準メソッドで、連続する隣接テキスト
    /// ノードを1つに連結し、空のテキストノードを取り除く。`textContent` を何度も
    /// 部分的に書き換えた後などに呼ばれる定番の掃除用メソッド）。子孫を再帰的に処理する。
    pub fn normalize_node(&mut self, idx: usize) {
        if idx >= self.nodes.len() || self.nodes[idx].is_text {
            return;
        }
        let children = self.nodes[idx].children.clone();
        let mut run_start: Option<usize> = None;
        let mut to_remove: Vec<usize> = Vec::new();
        for &c in &children {
            if self.nodes[c].is_text {
                match run_start {
                    None => run_start = Some(c),
                    Some(first) => {
                        let more = self.text_of(c);
                        let mut cur = self.text_of(first);
                        cur.push_str(&more);
                        self.nodes[first].text_override = Some(cur);
                        to_remove.push(c);
                    }
                }
            } else {
                run_start = None;
                self.normalize_node(c);
            }
        }
        for &c in &children {
            if self.nodes.get(c).map(|n| n.is_text).unwrap_or(false)
                && !to_remove.contains(&c)
                && self.text_of(c).is_empty()
            {
                to_remove.push(c);
            }
        }
        for r in to_remove {
            self.remove_node(r);
        }
    }
    /// テキストノードの実効テキスト（`text_override` があればそれ、無ければ
    /// `initial_text`）。`collect_text_into` と同じ参照パターン。
    fn text_of(&self, idx: usize) -> String {
        let n = &self.nodes[idx];
        n.text_override.as_deref().unwrap_or(&n.initial_text).to_string()
    }

    // ---- 構造変更（createElement / appendChild / removeChild / innerHTML） ----

    fn new_element_node(&mut self, tag: &str) -> usize {
        let idx = self.nodes.len();
        self.nodes.push(DomNode {
            tag: tag.to_lowercase(),
            is_text: false,
            id: String::new(),
            classes: Vec::new(),
            style: BTreeMap::new(),
            attrs: BTreeMap::new(),
            text_override: None,
            initial_text: String::new(),
            parent: None,
            children: Vec::new(),
            classes_dirty: false,
            style_dirty: false,
        });
        idx
    }

    fn new_text_node(&mut self, text: &str) -> usize {
        let idx = self.nodes.len();
        self.nodes.push(DomNode {
            tag: String::new(),
            is_text: true,
            id: String::new(),
            classes: Vec::new(),
            style: BTreeMap::new(),
            attrs: BTreeMap::new(),
            text_override: Some(text.to_string()),
            initial_text: text.to_string(),
            parent: None,
            children: Vec::new(),
            classes_dirty: false,
            style_dirty: false,
        });
        idx
    }

    /// `document.createElement(tag)`。デタッチ状態のノードを返す。
    pub fn create_element(&mut self, tag: &str) -> usize {
        self.new_element_node(tag)
    }

    /// `document.createTextNode(text)`。
    pub fn create_text_node(&mut self, text: &str) -> usize {
        self.new_text_node(text)
    }

    /// `document.createComment(text)`。
    pub fn create_comment(&mut self, text: &str) -> usize {
        let idx = self.nodes.len();
        self.nodes.push(DomNode {
            tag: String::from("#comment"),
            is_text: false,
            id: String::new(),
            classes: Vec::new(),
            style: BTreeMap::new(),
            attrs: BTreeMap::new(),
            text_override: Some(text.to_string()),
            initial_text: text.to_string(),
            parent: None,
            children: Vec::new(),
            classes_dirty: false,
            style_dirty: false,
        });
        idx
    }

    /// `document.createDocumentFragment()`（丸ごと未対応だった）。仕様どおり、
    /// `#fragment` という特殊タグの要素として表現する。この要素自身は決して
    /// `root` から到達可能（`is_attached`）にならず、`append_child`/`insert_before`
    /// に渡されると自身ではなく子要素群がそのまま挿入先へ移動し、自身は空になる
    /// （実 DOM の DocumentFragment の「挿入すると中身だけが移動する」挙動を再現）。
    pub fn create_document_fragment(&mut self) -> usize {
        self.new_element_node("#fragment")
    }

    /// `template.content`（`<template>` が丸ごと未対応だった）。仕様上 `<template>`
    /// の子は「不活性」で通常の DOM ツリーには存在せず、代わりに `.content`
    /// （`DocumentFragment`）経由でのみアクセスできる。この処理系は HTML パース時に
    /// `template` を特別扱いしないため子が普通にライブツリーへ入ってしまうが、
    /// 初回アクセス時にその子を `#fragment` ノードへ移し替え（内部専用属性
    /// `_content_frag` にフラグメントの index をキャッシュ）、以後は同じフラグメントを
    /// 返すことで「以後 `<template>` 自身は空、`.content` だけが中身を持つ」という
    /// 仕様どおりの見た目に近づける。
    pub fn template_content(&mut self, idx: usize) -> usize {
        if let Some(f) = self
            .get_attr(idx, "_content_frag")
            .and_then(|s| s.parse::<usize>().ok())
        {
            return f;
        }
        let f = self.create_document_fragment();
        let kids = core::mem::take(&mut self.nodes[idx].children);
        for &k in &kids {
            self.nodes[k].parent = Some(f);
        }
        self.nodes[f].children = kids;
        self.set_attr(idx, "_content_frag", &f.to_string());
        f
    }

    /// `child` が DocumentFragment（`#fragment` タグ）なら、その子要素群を
    /// 親から切り離して返し、フラグメント自身は空にする。それ以外は `[child]` を
    /// そのまま返す（`append_child`/`insert_before` の共通前処理）。
    fn expand_fragment(&mut self, child: usize) -> Vec<usize> {
        if self.nodes.get(child).map(|n| n.tag == "#fragment" || n.tag == "#document-fragment").unwrap_or(false) {
            let kids = core::mem::take(&mut self.nodes[child].children);
            for &k in &kids {
                self.nodes[k].parent = None;
            }
            kids
        } else {
            alloc::vec![child]
        }
    }

    /// `parent.appendChild(child)`。既存の親から外して付け替える。`child` が
    /// DocumentFragment の場合は仕様どおりその子要素群を代わりに追加する。
    pub fn append_child(&mut self, parent: usize, child: usize) {
        if parent >= self.nodes.len() || child >= self.nodes.len() || parent == child {
            return;
        }
        let kids = self.expand_fragment(child);
        if kids.is_empty() {
            return;
        }
        for &k in &kids {
            self.detach(k);
            self.nodes[k].parent = Some(parent);
            self.nodes[parent].children.push(k);
        }
        self.dirty = true;
        self.notify_child_list(parent, kids, Vec::new());
    }

    /// `parent.removeChild(child)` / `child.remove()`。
    pub fn remove_child(&mut self, parent: usize, child: usize) {
        let p = if parent < self.nodes.len() { Some(parent) } else { self.nodes.get(child).and_then(|n| n.parent) };
        self.detach(child);
        self.dirty = true;
        if let Some(p) = p { self.notify_child_list(p, Vec::new(), alloc::vec![child]); }
    }
    pub fn remove_node(&mut self, idx: usize) {
        let p = self.nodes.get(idx).and_then(|n| n.parent);
        self.detach(idx);
        self.dirty = true;
        if let Some(p) = p { self.notify_child_list(p, Vec::new(), alloc::vec![idx]); }
    }

    /// `parent.insertBefore(new_child, ref_child)`。ref が None/不在なら末尾に追加。
    /// `new_child` が DocumentFragment の場合は仕様どおりその子要素群を代わりに挿入する。
    pub fn insert_before(&mut self, parent: usize, new_child: usize, ref_child: Option<usize>) {
        if parent >= self.nodes.len() || new_child >= self.nodes.len() || parent == new_child {
            return;
        }
        let kids = self.expand_fragment(new_child);
        if kids.is_empty() {
            return;
        }
        let pos = ref_child.and_then(|r| self.nodes[parent].children.iter().position(|&c| c == r));
        for (i, &k) in kids.iter().enumerate() {
            self.detach(k);
            self.nodes[k].parent = Some(parent);
            match pos {
                Some(p) => self.nodes[parent].children.insert(p + i, k),
                None => self.nodes[parent].children.push(k),
            }
        }
        self.dirty = true;
        self.notify_child_list(parent, kids, Vec::new());
    }

    /// `parent.replaceChild(new_child, old_child)`。old を new で置換。
    pub fn replace_child(&mut self, parent: usize, new_child: usize, old_child: usize) {
        if parent >= self.nodes.len() || new_child >= self.nodes.len() {
            return;
        }
        if !self.nodes[parent].children.contains(&old_child) {
            return;
        }
        self.detach(new_child); // どこかに属していれば外す（位置が変わりうる）
        if let Some(p) = self.nodes[parent]
            .children
            .iter()
            .position(|&c| c == old_child)
        {
            self.nodes[old_child].parent = None;
            self.nodes[parent].children[p] = new_child;
            self.nodes[new_child].parent = Some(parent);
            self.dirty = true;
            self.notify_child_list(parent, alloc::vec![new_child], alloc::vec![old_child]);
        }
    }

    /// `node.cloneNode(deep)`。属性/テキストをコピーした新ノードを作る（親なし）。deep なら子も再帰。
    pub fn clone_node(&mut self, idx: usize, deep: bool) -> usize {
        if idx >= self.nodes.len() {
            return idx;
        }
        let (is_text, tag, id, classes, style, attrs, text_override, initial_text, children) = {
            let n = &self.nodes[idx];
            (
                n.is_text,
                n.tag.clone(),
                n.id.clone(),
                n.classes.clone(),
                n.style.clone(),
                n.attrs.clone(),
                n.text_override.clone(),
                n.initial_text.clone(),
                n.children.clone(),
            )
        };
        let new_idx = self.nodes.len();
        self.nodes.push(DomNode {
            tag,
            is_text,
            id,
            classes,
            style,
            attrs,
            text_override,
            initial_text,
            parent: None,
            children: Vec::new(),
            classes_dirty: false,
            style_dirty: false,
        });
        if deep && !is_text {
            for c in children {
                let cc = self.clone_node(c, true);
                self.nodes[cc].parent = Some(new_idx);
                self.nodes[new_idx].children.push(cc);
            }
        }
        // `<template>.content` は通常の `children` ではなく `_content_frag` 属性
        // 経由で参照される遅延切り出し済み `#fragment` のため、上の通常の
        // children クローンでは複製されない。属性は他の属性と同様に文字列と
        // してそのままコピーされるので、対処しないとクローン先の
        // `template.content` が元の（同じ）フラグメントを指したまま共有されて
        // しまうバグだった（`.content` に一度でもアクセス済みの `<template>` を
        // `cloneNode()` した場合にのみ顕在化する）。仕様上 `<template>` の
        // content クローンは `deep` フラグに関わらず常に行われる特殊規則のため、
        // `if deep` の外で無条件に複製する。
        let frag_attr = self.nodes[new_idx]
            .attrs
            .get("_template_content_idx")
            .or_else(|| self.nodes[new_idx].attrs.get("_content_frag"))
            .cloned();
        if let Some(frag_idx) = frag_attr.and_then(|s| s.parse::<usize>().ok()) {
            let new_frag = self.clone_node(frag_idx, true);
            self.nodes[new_idx]
                .attrs
                .insert("_template_content_idx".to_string(), new_frag.to_string());
        }
        self.dirty = true;
        new_idx
    }

    /// 親の children から idx を外す。
    fn detach(&mut self, idx: usize) {
        if idx >= self.nodes.len() {
            return;
        }
        if let Some(p) = self.nodes[idx].parent {
            if let Some(pos) = self.nodes[p].children.iter().position(|&c| c == idx) {
                self.nodes[p].children.remove(pos);
            }
        }
        self.nodes[idx].parent = None;
    }

    /// 単一ノードを基準ノード idx の相対位置へ挿入（insertAdjacent* 共通）。
    pub fn insert_adjacent_node(&mut self, idx: usize, position: &str, node: usize) {
        match position {
            "beforeend" => self.append_child(idx, node),
            "afterbegin" => {
                let first = self
                    .nodes
                    .get(idx)
                    .and_then(|n| n.children.first().copied());
                self.insert_before(idx, node, first);
            }
            "beforebegin" => {
                if let Some(p) = self.nodes.get(idx).and_then(|n| n.parent) {
                    self.insert_before(p, node, Some(idx));
                }
            }
            "afterend" => {
                if let Some(p) = self.nodes.get(idx).and_then(|n| n.parent) {
                    let next = self.nodes.get(p).and_then(|n| {
                        n.children
                            .iter()
                            .position(|&c| c == idx)
                            .and_then(|i| n.children.get(i + 1).copied())
                    });
                    self.insert_before(p, node, next);
                }
            }
            _ => {}
        }
    }

    /// `element.insertAdjacentHTML(position, html)`。html をパースして相対位置へ挿入。
    pub fn insert_adjacent_html(&mut self, idx: usize, position: &str, html: &str) {
        let root = crate::os_lib::dom::parse_html(html);
        let imported: Vec<usize> = root.children.iter().map(|c| self.import_node(c)).collect();
        if position == "afterbegin" {
            // 基準（元の先頭子）を一度だけ捕捉して順序保持で前挿入。
            let first = self
                .nodes
                .get(idx)
                .and_then(|n| n.children.first().copied());
            for node in imported {
                self.insert_before(idx, node, first);
            }
        } else {
            for node in imported {
                self.insert_adjacent_node(idx, position, node);
            }
        }
        self.dirty = true;
    }

    /// `element.innerHTML = html`。フラグメントをパースして子を置換する。
    /// `appendChild`/`removeChild`/`insertBefore`/`replaceChild` は全て
    /// `notify_child_list` 経由で MutationObserver に通知していたが、
    /// `innerHTML` 代入だけがこの呼び出しを欠いており、最も頻繁に使われる
    /// DOM 書き換え手段にもかかわらず childList 変化が一切観察できなかった。
    pub fn set_inner_html(&mut self, idx: usize, html: &str) {
        if idx >= self.nodes.len() || self.nodes[idx].is_text {
            return;
        }
        let root = crate::os_lib::dom::parse_html(html);
        // 既存の子を切り離す。
        let old: Vec<usize> = self.nodes[idx].children.clone();
        for &c in &old {
            self.nodes[c].parent = None;
        }
        self.nodes[idx].children.clear();
        // パース結果（合成ルートの子）を import して付ける。
        let mut new_children = Vec::new();
        for child in &root.children {
            let ci = self.import_node(child);
            self.nodes[ci].parent = Some(idx);
            new_children.push(ci);
        }
        self.nodes[idx].children = new_children.clone();
        self.dirty = true;
        self.notify_child_list(idx, new_children, old);
    }

    /// `element.outerHTML = html`。自ノードを HTML パース結果のノード群で置き換える。
    pub fn set_outer_html(&mut self, idx: usize, html: &str) {
        if idx >= self.nodes.len() {
            return;
        }
        let parent = match self.nodes[idx].parent {
            Some(p) => p,
            None => return,
        };
        let pos = match self.nodes[parent].children.iter().position(|&c| c == idx) {
            Some(p) => p,
            None => return,
        };
        let root = crate::os_lib::dom::parse_html(html);
        let mut new_inserted = Vec::new();
        for child in &root.children {
            let ci = self.import_node(child);
            self.nodes[ci].parent = Some(parent);
            new_inserted.push(ci);
        }
        self.nodes[idx].parent = None;
        self.nodes[parent].children.remove(pos);
        for (i, &ci) in new_inserted.iter().enumerate() {
            self.nodes[parent].children.insert(pos + i, ci);
        }
        self.dirty = true;
        self.notify_child_list(parent, new_inserted, alloc::vec![idx]);
    }

    /// `dom::Node` 部分木をブリッジへ取り込み、ルート idx を返す。
    fn import_node(&mut self, node: &Node) -> usize {
        match &node.node_type {
            NodeType::Text(t) => self.new_text_node(t),
            NodeType::Element {
                tag_name,
                attributes,
                classes,
                id,
            } => {
                let idx = self.new_element_node(tag_name);
                {
                    let style = parse_inline_style(
                        attributes.get("style").map(|s| s.as_str()).unwrap_or(""),
                    );
                    let n = &mut self.nodes[idx];
                    n.id = id.clone().unwrap_or_default();
                    n.classes = classes.clone();
                    n.style = style;
                    n.attrs = attributes.clone();
                }
                let mut kids = Vec::new();
                for c in &node.children {
                    let ci = self.import_node(c);
                    self.nodes[ci].parent = Some(idx);
                    kids.push(ci);
                }
                self.nodes[idx].children = kids;
                idx
            }
        }
    }

    /// ブリッジツリー（node[0] をルート）を `dom::Node` へ変換する。
    /// JS の変更（textContent/style/class/動的ノード）が反映された描画用ツリー。
    pub fn to_dom_node(&self) -> Node {
        if self.nodes.is_empty() {
            return Node::new_text(String::new());
        }
        self.build_node(0)
    }

    fn build_node(&self, idx: usize) -> Node {
        let n = &self.nodes[idx];
        if n.is_text {
            return Node::new_text(
                n.text_override
                    .clone()
                    .unwrap_or_else(|| n.initial_text.clone()),
            );
        }
        let mut attrs = n.attrs.clone();
        let id = if n.id.is_empty() {
            let gen_id = alloc::format!("_node_idx_{}", idx);
            attrs.insert("id".to_string(), gen_id.clone());
            Some(gen_id)
        } else {
            attrs.insert("id".to_string(), n.id.clone());
            Some(n.id.clone())
        };
        if n.classes.is_empty() {
            attrs.remove("class");
        } else {
            attrs.insert("class".to_string(), n.classes.join(" "));
        }
        if n.style.is_empty() {
            attrs.remove("style");
        } else {
            attrs.insert("style".to_string(), serialize_inline_style(&n.style));
        }
        let mut node = Node::new_element_direct(n.tag.clone(), attrs, id, n.classes.clone());
        for &c in &n.children {
            node.children.push(self.build_node(c));
        }
        node
    }

    /// 要素の textContent（現在値）を取得。
    pub fn get_text_content(&self, idx: usize) -> String {
        if idx >= self.nodes.len() {
            return String::new();
        }
        self.collect_text(idx)
    }

    fn descendant_text_nodes(&self, idx: usize) -> Vec<usize> {
        let mut out = Vec::new();
        self.descendant_text_into(idx, &mut out);
        out
    }
    fn descendant_text_into(&self, idx: usize, out: &mut Vec<usize>) {
        let node = &self.nodes[idx];
        if node.is_text {
            out.push(idx);
            return;
        }
        for &c in &node.children {
            self.descendant_text_into(c, out);
        }
    }

    // `style.xxx = ...`/`style.cssText = ...` は `class`/他の属性と同じく
    // `MutationObserver`（`attributes:true` + `attributeFilter:['style']` 等）が
    // 観察できるべき「style」属性の変化にもかかわらず、`class_add`/`class_remove`
    // と同型で `notify_attribute` を一切呼んでいなかった非対称バグ。
    pub fn set_style(&mut self, idx: usize, prop: &str, val: &str) {
        let old_value = {
            let Some(n) = self.nodes.get_mut(idx) else {
                return;
            };
            let old_value = serialize_inline_style(&n.style);
            let key = css_prop_from_camel(prop);
            if val.is_empty() {
                n.style.remove(&key);
            } else {
                n.style.insert(key, val.to_string());
            }
            n.style_dirty = true;
            old_value
        };
        self.dirty = true;
        self.notify_attribute(idx, "style", Some(&old_value));
    }

    pub fn get_style(&self, idx: usize, prop: &str) -> String {
        let raw = self
            .nodes
            .get(idx)
            .and_then(|n| n.style.get(&css_prop_from_camel(prop)).cloned())
            .unwrap_or_default();
        strip_style_priority(&raw).0.to_string()
    }

    /// `element.style.getPropertyPriority(name)`（丸ごと未対応だった。
    /// 2026-07-16 発見）。`!important` は生の値文字列末尾にそのまま保持
    /// されている（`set_style`/`css_prop_from_camel` 参照）ため、
    /// `strip_style_priority` で判定するだけで済む。
    pub fn get_style_priority(&self, idx: usize, prop: &str) -> String {
        let raw = self
            .nodes
            .get(idx)
            .and_then(|n| n.style.get(&css_prop_from_camel(prop)).cloned())
            .unwrap_or_default();
        if strip_style_priority(&raw).1 {
            "important".to_string()
        } else {
            String::new()
        }
    }

    /// `element.style.cssText` の読み出し。以前は丸ごと未対応で、`cssText` を単なる
    /// 通常の CSS プロパティ名として扱う既存の汎用経路（`get_style`）に落ちてしまい、
    /// 常に空文字列を返していた（`serialize_inline_style` 自体は属性文字列の再構築で
    /// 既に使われていたが、JS からの読み出しには配線されていなかった）。
    pub fn get_css_text(&self, idx: usize) -> String {
        self.nodes
            .get(idx)
            .map(|n| serialize_inline_style(&n.style))
            .unwrap_or_default()
    }
    /// `element.style.cssText = "..."` の書き込み。単一プロパティとして扱われ常に
    /// 無視されていたのを、既存のスタイル属性パーサ（`parse_inline_style`）で丸ごと
    /// 置き換えるよう実装する。
    pub fn set_css_text(&mut self, idx: usize, text: &str) {
        let old_value = {
            let Some(n) = self.nodes.get_mut(idx) else {
                return;
            };
            let old_value = serialize_inline_style(&n.style);
            n.style = parse_inline_style(text);
            n.style_dirty = true;
            old_value
        };
        self.dirty = true;
        self.notify_attribute(idx, "style", Some(&old_value));
    }

    /// `element.outerHTML`（読み出し専用。書き込み側は要素の親子関係の組み替えが
    /// 必要で改修規模が大きいため今回は見送り）が丸ごと未対応だった。自身のタグ・属性
    /// （id/class/style を含む）・子孫を再帰的に HTML 文字列へ直列化する。
    pub fn get_outer_html(&self, idx: usize) -> String {
        let mut out = String::new();
        self.serialize_node_html(idx, &mut out);
        out
    }
    /// `element.innerHTML` の読み出しが、実際にはマークアップ（子要素タグ）を含めず
    /// `textContent` と同じ「全テキストを連結しただけ」の値を返してしまっていたバグ。
    /// `<div>a<b>bold</b></div>` の `innerHTML` が仕様どおりの `"a<b>bold</b>"` ではなく
    /// `"abold"` になっていた。自身のタグは含めず、子ノードだけを直列化する。
    pub fn get_inner_html(&self, idx: usize) -> String {
        let mut out = String::new();
        if let Some(n) = self.nodes.get(idx) {
            for &c in &n.children {
                self.serialize_node_html(c, &mut out);
            }
        }
        out
    }
    fn serialize_node_html(&self, idx: usize, out: &mut String) {
        let Some(n) = self.nodes.get(idx) else { return };
        if n.is_text {
            out.push_str(&html_escape_text(
                n.text_override.as_deref().unwrap_or(&n.initial_text),
            ));
            return;
        }
        if n.tag == "#comment" {
            out.push_str("<!--");
            out.push_str(n.text_override.as_deref().unwrap_or(&n.initial_text));
            out.push_str("-->");
            return;
        }
        out.push('<');
        out.push_str(&n.tag);
        if !n.id.is_empty() {
            out.push_str(&format!(" id=\"{}\"", html_escape_attr(&n.id)));
        }
        if !n.classes.is_empty() {
            out.push_str(&format!(" class=\"{}\"", html_escape_attr(&n.classes.join(" "))));
        }
        if !n.style.is_empty() {
            out.push_str(&format!(
                " style=\"{}\"",
                html_escape_attr(&serialize_inline_style(&n.style))
            ));
        }
        // `n.attrs` には HTML パース時の生の `id`/`class` もそのまま残っている場合が
        // あり（`n.id`/`n.classes` は別途専用フィールドとして持つ）、除外しないと
        // `id="t" id="t"` のように重複出力してしまう。`_` 始まりの内部専用属性
        // （`_content_frag`/`_return_value`/`_custom_validity` 等、実装詳細を
        // `set_attr`/`get_attr` 経由で持ち回るための housekeeping 用の値）も
        // 除外しないと `outerHTML`/`innerHTML` にそのまま漏れて見えてしまう
        // バグだった。
        for (k, v) in &n.attrs {
            if k == "id" || k == "class" || k == "style" || k.starts_with('_') {
                continue;
            }
            out.push(' ');
            out.push_str(k);
            out.push_str("=\"");
            out.push_str(&html_escape_attr(v));
            out.push('"');
        }
        out.push('>');
        // void 要素（自身終了タグを持たない）。
        if matches!(
            n.tag.as_str(),
            "br" | "img" | "input" | "hr" | "meta" | "link" | "area" | "base" | "col"
                | "embed" | "param" | "source" | "track" | "wbr"
        ) {
            return;
        }
        for &c in &n.children {
            self.serialize_node_html(c, out);
        }
        out.push_str("</");
        out.push_str(&n.tag);
        out.push('>');
    }

    // `classList.add`/`.remove` は `class` 属性を書き換えるにもかかわらず、
    // `setAttribute('class', ...)`/`removeAttribute()` と違って `notify_attribute`
    // を一切呼んでおらず、`MutationObserver` に「class」の変化が通知されない
    // 非対称バグだった（`set_attr`/`remove_attr` は既に通知していた）。
    pub fn class_add(&mut self, idx: usize, cls: &str) {
        let old_value = {
            let Some(n) = self.nodes.get_mut(idx) else {
                return;
            };
            if n.classes.iter().any(|c| c == cls) {
                return;
            }
            let old_value = n.classes.join(" ");
            n.classes.push(cls.to_string());
            n.classes_dirty = true;
            old_value
        };
        self.dirty = true;
        self.notify_attribute(idx, "class", Some(&old_value));
    }
    pub fn class_remove(&mut self, idx: usize, cls: &str) {
        let old_value = {
            let Some(n) = self.nodes.get_mut(idx) else {
                return;
            };
            let before = n.classes.len();
            let old_value = n.classes.join(" ");
            n.classes.retain(|c| c != cls);
            if n.classes.len() == before {
                return;
            }
            n.classes_dirty = true;
            old_value
        };
        self.dirty = true;
        self.notify_attribute(idx, "class", Some(&old_value));
    }
    pub fn class_toggle(&mut self, idx: usize, cls: &str) -> bool {
        if self.class_contains(idx, cls) {
            self.class_remove(idx, cls);
            false
        } else {
            self.class_add(idx, cls);
            true
        }
    }
    pub fn class_contains(&self, idx: usize, cls: &str) -> bool {
        self.nodes
            .get(idx)
            .map(|n| n.classes.iter().any(|c| c == cls))
            .unwrap_or(false)
    }

    /// `<select>`配下の`<option>`要素を全て集める（`<optgroup>`でグループ化
    /// された`<option>`も含む再帰探索。丸ごと未対応だった。以前は直接の子
    /// のみを見る実装だったため、`<select><optgroup label="Fruits">
    /// <option>Apple</option></optgroup></select>`という非常によく使われる
    /// カテゴリ分けパターンで、`<optgroup>`配下の`<option>`が`select.
    /// options`/フォーム送信のどちらからも一切見えなくなる実害のある
    /// バグだった。`<option>`要素自身は子に更に`<option>`を持たない
    /// （仕様上そのような入れ子は無意味）ため、`<option>`に達したら
    /// そこで再帰を打ち切る。2026-07-17 発見・実装）。
    fn collect_descendant_options(&self, idx: usize, out: &mut Vec<usize>) {
        let Some(n) = self.nodes.get(idx) else { return };
        for &c in &n.children {
            let Some(cn) = self.nodes.get(c) else { continue };
            if cn.tag == "option" {
                out.push(c);
            } else {
                self.collect_descendant_options(c, out);
            }
        }
    }
    /// `<select>` の option 子要素一覧（`<optgroup>`配下も含む）。`select.
    /// options`（丸ごと未対応だった。動的にドロップダウンを構築する定番
    /// イディオムで使われる）向けに公開する。
    pub fn select_options(&self, idx: usize) -> Vec<usize> {
        let mut out = Vec::new();
        self.collect_descendant_options(idx, &mut out);
        out
    }
    /// option 要素の実効値: `value` 属性があればそれ、無ければテキスト内容
    /// （仕様どおり。`collect_form_data` の select フォールバックと同じ規則）。
    fn option_value(&self, opt_idx: usize) -> String {
        self.get_attr(opt_idx, "value").unwrap_or_else(|| {
            self.nodes
                .get(opt_idx)
                .map(|n| n.text_override.clone().unwrap_or_else(|| n.initial_text.clone()))
                .unwrap_or_default()
        })
    }
    /// `select.selectedOptions`（`<select multiple>` で選択中の option 一覧を得る
    /// 定番イディオム。`FormData` の multi-select 対応と同じく `selected` 属性を
    /// 真実源とする）。単一選択の `<select>` でも仕様どおり動作する
    /// （`selected` が無ければ既定選択の最初の option を1件返す）。
    pub fn selected_option_indices(&self, idx: usize) -> Vec<usize> {
        let options = self.select_options(idx);
        let selected: Vec<usize> = options.iter().copied().filter(|&o| self.has_attr(o, "selected")).collect();
        if !selected.is_empty() {
            selected
        } else {
            options.first().copied().into_iter().collect()
        }
    }
    /// `select.value`（丸ごと未対応だった。`<select>` 自身に `value` 属性は無く、
    /// 選択状態は子の `<option selected>` が持つため、汎用の属性直結 getter では
    /// 常に空文字列になっていた）。`selected` な option を優先し、無ければ
    /// HTML の既定選択どおり最初の option にフォールバックする。
    pub fn select_effective_value(&self, idx: usize) -> String {
        let options = self.select_options(idx);
        let target = options
            .iter()
            .copied()
            .find(|&o| self.has_attr(o, "selected"))
            .or_else(|| options.first().copied());
        match target {
            Some(o) => self.option_value(o),
            None => String::new(),
        }
    }
    /// フォーム系コントロールの「現在の実効値」を文字列で解決する。
    /// `checkValidity()`/`.validationMessage`/`.validity`が素朴に
    /// `get_attr(idx,"value")`だけを見ており、`value`属性を持たない
    /// `<select>`（選択状態は子`<option selected>`が持つ）や、初期値が
    /// `value`属性ではなくテキストノードで表現される`<textarea>`では
    /// 常に空文字列として（＝未入力として）誤って検証されてしまうバグの
    /// 共通修正用。`.value`ゲッター（`dom_props.rs`）と同じフォールバック
    /// 規則をここに一本化する。
    pub fn effective_form_value(&self, idx: usize) -> String {
        let tag = self.nodes.get(idx).map(|n| n.tag.as_str()).unwrap_or("");
        if tag == "select" {
            self.select_effective_value(idx)
        } else if tag == "textarea" {
            self.get_attr(idx, "value").unwrap_or_else(|| {
                self.nodes
                    .get(idx)
                    .map(|n| n.initial_text.clone())
                    .unwrap_or_default()
            })
        } else {
            self.get_attr(idx, "value").unwrap_or_default()
        }
    }
    /// `select.value = v`（丸ごと未対応だった）。value が一致する最初の option へ
    /// 選択を移す（他の option の `selected` は解除。仕様どおり単一選択）。
    pub fn set_select_value(&mut self, idx: usize, val: &str) {
        let options = self.select_options(idx);
        for &o in &options {
            if self.option_value(o) == val {
                self.set_attr(o, "selected", "selected");
            } else {
                self.remove_attr(o, "selected");
            }
        }
        self.dirty = true;
    }
    /// `select.selectedIndex`（丸ごと未対応だった）。`selected` な option の位置、
    /// 無ければ option が1つ以上あれば `0`（既定選択）、無ければ `-1`。
    pub fn select_selected_index(&self, idx: usize) -> i32 {
        let options = self.select_options(idx);
        match options.iter().position(|&o| self.has_attr(o, "selected")) {
            Some(p) => p as i32,
            None if !options.is_empty() => 0,
            None => -1,
        }
    }
    /// `select.selectedIndex = n`。
    pub fn set_select_selected_index(&mut self, idx: usize, n: i32) {
        let options = self.select_options(idx);
        for (i, &o) in options.iter().enumerate() {
            if i as i32 == n {
                self.set_attr(o, "selected", "selected");
            } else {
                self.remove_attr(o, "selected");
            }
        }
        self.dirty = true;
    }
    /// `select.length = n`（HTML5。`select.options.length`と同じ値を返す
    /// ゲッター兼、`n`より末尾のoptionを切り捨てる／不足分を空の`<option>`で
    /// 埋めるセッター。丸ごと未対応だった）。仕様どおり、新しい長さが現在より
    /// 小さければ末尾から削除、大きければ空の`<option>`を追加する。
    pub fn set_select_length(&mut self, idx: usize, n: usize) {
        let options = self.select_options(idx);
        if n < options.len() {
            for &o in &options[n..] {
                if let Some(parent) = self.nodes.get(o).and_then(|node| node.parent) {
                    self.remove_child(parent, o);
                }
            }
        } else {
            for _ in options.len()..n {
                let opt = self.create_element("option");
                self.append_child(idx, opt);
            }
        }
        self.dirty = true;
    }
    /// `option.index`（HTML5。自身が属する`<select>`内での0始まりの位置。
    /// `select.selectedIndex`の対になる、`<option>`側のIDL属性だが丸ごと
    /// 未対応だった）。`<select>`祖先が無い場合は仕様どおり`0`（要素が
    /// 「optionのリスト」に属さない場合の既定値。`<datalist>`配下は
    /// 対象外の簡略実装）。
    pub fn option_index(&self, idx: usize) -> i32 {
        match self.closest_tag(idx, "select") {
            Some(sel) => self
                .select_options(sel)
                .iter()
                .position(|&o| o == idx)
                .map(|p| p as i32)
                .unwrap_or(0),
            None => 0,
        }
    }

    pub fn get_attr(&self, idx: usize, name: &str) -> Option<String> {
        let n = self.nodes.get(idx)?;
        match name {
            "id" => Some(n.id.clone()),
            "class" => Some(n.classes.join(" ")),
            _ => n.attrs.get(name).cloned(),
        }
    }
    pub fn set_attr(&mut self, idx: usize, name: &str, val: &str) {
        let old_value = self.get_attr(idx, name);
        if let Some(n) = self.nodes.get_mut(idx) {
            match name {
                "id" => n.id = val.to_string(),
                "class" => {
                    n.classes = val.split_whitespace().map(String::from).collect();
                    n.classes_dirty = true;
                }
                _ => {
                    n.attrs.insert(name.to_string(), val.to_string());
                }
            }
            self.dirty = true;
        }
        self.notify_attribute(idx, name, old_value.as_deref());
    }

    /// 属性が存在するか（空値の boolean 属性も存在として true。id/class は専用フィールド）。
    pub fn has_attr(&self, idx: usize, name: &str) -> bool {
        match self.nodes.get(idx) {
            Some(n) => match name {
                "id" => !n.id.is_empty(),
                "class" => !n.classes.is_empty(),
                _ => n.attrs.contains_key(name),
            },
            None => false,
        }
    }

    /// 属性を削除（id/class フィールドも同期）。
    pub fn remove_attr(&mut self, idx: usize, name: &str) {
        // `set_attr` は属性変化を MutationObserver へ通知していたが、`remove_attr`
        // だけこの通知呼び出しが漏れていた非対称ペア（`removeAttribute()` も仕様上
        // "attributes" タイプの MutationRecord を発行すべき）。
        let old_value = self.get_attr(idx, name);
        if let Some(n) = self.nodes.get_mut(idx) {
            match name {
                "id" => n.id = String::new(),
                "class" => {
                    n.classes.clear();
                    n.classes_dirty = true;
                }
                _ => {
                    n.attrs.remove(name);
                }
            }
            self.dirty = true;
        }
        self.notify_attribute(idx, name, old_value.as_deref());
    }

    /// `<input type="radio">` の排他選択（同じ `name` を持つグループ内で1つだけが
    /// `checked` になる、というラジオボタンの最も基本的な仕様上の挙動）。`idx` を
    /// checked にする際、同じ `name` を持つ他の radio 全ての `checked` 属性を外す。
    /// フォーム所有者（`<form>` 単位のスコープ）は区別せず、同じ `name` を持つ
    /// document 内の全 radio を対象にする簡略実装。
    /// `<details name="...">`（HTML5。同じ`name`を持つ`<details>`同士は
    /// ラジオボタングループのように排他的に開閉する——1つを開くと同じ
    /// グループの他の`<details>`は自動的に閉じる——仕様が丸ごと未対応
    /// だった。`uncheck_radio_group_siblings`と同じ「`name`属性が一致する
    /// 兄弟（ドキュメント全体、DOM上の兄弟関係は問わない）を探して状態を
    /// 揃える」パターンをそのまま適用する。2026-07-18 発見・実装）。
    pub fn close_details_group_siblings(&mut self, idx: usize) -> alloc::vec::Vec<usize> {
        let name = match self.nodes.get(idx).and_then(|n| n.attrs.get("name")) {
            Some(n) if !n.is_empty() => n.clone(),
            _ => return alloc::vec::Vec::new(),
        };
        let siblings: alloc::vec::Vec<usize> = self
            .nodes
            .iter()
            .enumerate()
            .filter(|(i, n)| {
                *i != idx
                    && n.tag == "details"
                    && n.attrs.get("name").map(|s| s.as_str()) == Some(name.as_str())
                    && n.attrs.contains_key("open")
            })
            .map(|(i, _)| i)
            .collect();
        for &i in &siblings {
            self.remove_attr(i, "open");
        }
        siblings
    }

    pub fn uncheck_radio_group_siblings(&mut self, idx: usize) {
        let name = match self.nodes.get(idx).and_then(|n| n.attrs.get("name")) {
            Some(n) if !n.is_empty() => n.clone(),
            _ => return,
        };
        let siblings: Vec<usize> = self
            .nodes
            .iter()
            .enumerate()
            .filter(|(i, n)| {
                *i != idx
                    && n.tag == "input"
                    && n.attrs.get("type").map(|t| t.as_str()) == Some("radio")
                    && n.attrs.get("name").map(|s| s.as_str()) == Some(name.as_str())
            })
            .map(|(i, _)| i)
            .collect();
        for i in siblings {
            self.remove_attr(i, "checked");
            self.set_attr(i, "_live_checked", "false");
        }
    }

    /// 単一ノードがセレクタ（コンパウンド + 結合子、カンマ区切りは OR）にマッチするか。
    /// `matches()`/`closest()`/`querySelector(All)` 共通の実装本体。以前は `#id`/`.class`/
    /// `tag`/`*` の単純セレクタしか認識せず、`div.active`（コンパウンド）や `[data-x]`
    /// （属性セレクタ）、`.a > .b`（結合子）を渡すと文字列全体を tag 名として比較する
    /// 分岐に落ち、常に false になる静かな破壊バグだった（`:not()`/`:nth-child()`/
    /// `:is()`/`:where()` 等の疑似クラスは引き続き非対応。改修規模を絞るための
    /// 意図的な割り切り）。
    pub fn node_matches(&self, idx: usize, selector: &str) -> bool {
        self.node_matches_scoped(idx, selector, None)
    }

    /// `node_matches` の `:scope` 対応版。`scope_root` に `element.
    /// querySelectorAll`/`matches`/`closest` 等の起点ノードを渡すと、セレクタ中の
    /// `:scope` 疑似クラス（Selectors Level 4。丸ごと未対応だった）がそのノードに
    /// のみ一致するようになる。`scope_root` が `None`（`document.querySelectorAll`
    /// 等、起点を持たない文脈）の場合は `:scope` は常に不一致として扱う簡略実装。
    pub fn node_matches_scoped(&self, idx: usize, selector: &str, scope_root: Option<usize>) -> bool {
        if self.nodes.get(idx).map(|n| n.is_text).unwrap_or(true) {
            return false;
        }
        for part in split_top_level_commas(selector) {
            let steps = build_steps(&tokenize_selector_group(part.trim()));
            if steps.is_empty() {
                continue;
            }
            let last = steps.len() - 1;
            if self.compound_matches(idx, &steps[last].compound, scope_root)
                && self.match_selector_chain(idx, &steps, last, scope_root)
            {
                return true;
            }
        }
        false
    }

    /// `idx` がコンパウンドセレクタ（タグ/`#id`/`.class`/`[attr...]`）に一致するか。
    fn compound_matches(&self, idx: usize, c: &CompoundSel, scope_root: Option<usize>) -> bool {
        if c.is_scope && Some(idx) != scope_root {
            return false;
        }
        let n = match self.nodes.get(idx) {
            Some(n) if !n.is_text => n,
            _ => return false,
        };
        if let Some(tag) = &c.tag {
            if &n.tag != tag {
                return false;
            }
        }
        if let Some(id) = &c.id {
            if &n.id != id {
                return false;
            }
        }
        if !c.classes.iter().all(|cls| n.classes.iter().any(|nc| nc == cls)) {
            return false;
        }
        for attr in &c.attrs {
            let val = match n.attrs.get(&attr.name) {
                Some(v) => v,
                None => return false,
            };
            let ok = match attr.op {
                AttrOp::Exists => true,
                AttrOp::Eq => val == &attr.value,
                AttrOp::Prefix => val.starts_with(attr.value.as_str()),
                AttrOp::Suffix => val.ends_with(attr.value.as_str()),
                AttrOp::Contains => !attr.value.is_empty() && val.contains(attr.value.as_str()),
                AttrOp::Word => val.split_whitespace().any(|w| w == attr.value),
            };
            if !ok {
                return false;
            }
        }
        for not_sel in &c.not {
            if self.compound_matches(idx, not_sel, scope_root) {
                return false;
            }
        }
        if !c.is_list.is_empty()
            && !c.is_list.iter().any(|s| self.compound_matches(idx, s, scope_root))
        {
            return false;
        }
        if !c.pos.is_empty() {
            let (position, count) = self.element_sibling_position(idx);
            for p in &c.pos {
                let ok = match p {
                    PosPseudo::First => position == 1,
                    PosPseudo::Last => position == count,
                    PosPseudo::Only => position == 1 && count == 1,
                    PosPseudo::Nth(f) => nth_formula_matches(*f, position),
                    PosPseudo::NthLast(f) => nth_formula_matches(*f, count - position + 1),
                };
                if !ok {
                    return false;
                }
            }
        }
        if !c.pos_of_type.is_empty() {
            let (position, count) = self.element_type_sibling_position(idx);
            for p in &c.pos_of_type {
                let ok = match p {
                    PosPseudo::First => position == 1,
                    PosPseudo::Last => position == count,
                    PosPseudo::Only => position == 1 && count == 1,
                    PosPseudo::Nth(f) => nth_formula_matches(*f, position),
                    PosPseudo::NthLast(f) => nth_formula_matches(*f, count - position + 1),
                };
                if !ok {
                    return false;
                }
            }
        }
        true
    }

    /// `idx` の「要素兄弟のみを数えた」1始まりの位置と、要素兄弟の総数を返す
    /// （テキストノードは数えない。CSS の `:nth-child()` 等と同じ規則）。
    fn element_sibling_position(&self, idx: usize) -> (usize, usize) {
        let parent = match self.nodes.get(idx).and_then(|n| n.parent) {
            Some(p) => p,
            None => return (1, 1),
        };
        let siblings = match self.nodes.get(parent) {
            Some(n) => &n.children,
            None => return (1, 1),
        };
        let elements: Vec<usize> = siblings
            .iter()
            .filter(|&&c| !self.nodes.get(c).map(|n| n.is_text).unwrap_or(true))
            .copied()
            .collect();
        let count = elements.len();
        let position = elements.iter().position(|&c| c == idx).map(|p| p + 1).unwrap_or(0);
        (position, count)
    }

    /// `element_sibling_position` と同じだが、同じタグ名の兄弟のみを数える
    /// （`:first-of-type`/`:last-of-type`/`:nth-of-type()` 用）。
    fn element_type_sibling_position(&self, idx: usize) -> (usize, usize) {
        let tag = match self.nodes.get(idx) {
            Some(n) => n.tag.clone(),
            None => return (1, 1),
        };
        let parent = match self.nodes.get(idx).and_then(|n| n.parent) {
            Some(p) => p,
            None => return (1, 1),
        };
        let siblings = match self.nodes.get(parent) {
            Some(n) => &n.children,
            None => return (1, 1),
        };
        let same_type: Vec<usize> = siblings
            .iter()
            .filter(|&&c| self.nodes.get(c).map(|n| !n.is_text && n.tag == tag).unwrap_or(false))
            .copied()
            .collect();
        let count = same_type.len();
        let position = same_type.iter().position(|&c| c == idx).map(|p| p + 1).unwrap_or(0);
        (position, count)
    }

    /// `idx` は `steps[step_i]` に既に一致した状態で呼ばれる。`steps[0..step_i]` を
    /// 結合子に従って祖先/兄弟方向へ再帰的に検証する。
    fn match_selector_chain(
        &self,
        idx: usize,
        steps: &[SelStep],
        step_i: usize,
        scope_root: Option<usize>,
    ) -> bool {
        if step_i == 0 {
            return true;
        }
        let combinator = match steps[step_i].combinator {
            Some(c) => c,
            None => return true,
        };
        match combinator {
            Combinator::Descendant => {
                let mut cur = self.nodes.get(idx).and_then(|n| n.parent);
                let mut guard = 0;
                while let Some(p) = cur {
                    if self.compound_matches(p, &steps[step_i - 1].compound, scope_root)
                        && self.match_selector_chain(p, steps, step_i - 1, scope_root)
                    {
                        return true;
                    }
                    cur = self.nodes.get(p).and_then(|n| n.parent);
                    guard += 1;
                    if guard > self.nodes.len() {
                        break;
                    }
                }
                false
            }
            Combinator::Child => match self.nodes.get(idx).and_then(|n| n.parent) {
                Some(p) => {
                    self.compound_matches(p, &steps[step_i - 1].compound, scope_root)
                        && self.match_selector_chain(p, steps, step_i - 1, scope_root)
                }
                None => false,
            },
            Combinator::Adjacent => match self.prev_element_sibling(idx) {
                Some(p) => {
                    self.compound_matches(p, &steps[step_i - 1].compound, scope_root)
                        && self.match_selector_chain(p, steps, step_i - 1, scope_root)
                }
                None => false,
            },
            Combinator::General => {
                for p in self.preceding_element_siblings(idx) {
                    if self.compound_matches(p, &steps[step_i - 1].compound, scope_root)
                        && self.match_selector_chain(p, steps, step_i - 1, scope_root)
                    {
                        return true;
                    }
                }
                false
            }
        }
    }

    /// `idx` の直前の要素兄弟（テキストノードは飛ばす）。
    fn prev_element_sibling(&self, idx: usize) -> Option<usize> {
        let parent = self.nodes.get(idx)?.parent?;
        let siblings = &self.nodes.get(parent)?.children;
        let pos = siblings.iter().position(|&c| c == idx)?;
        siblings[..pos].iter().rev().find(|&&c| !self.nodes.get(c).map(|n| n.is_text).unwrap_or(true)).copied()
    }

    /// `idx` より前にある全ての要素兄弟（テキストノードは飛ばす、ドキュメント順）。
    fn preceding_element_siblings(&self, idx: usize) -> Vec<usize> {
        let parent = match self.nodes.get(idx).and_then(|n| n.parent) {
            Some(p) => p,
            None => return Vec::new(),
        };
        let siblings = match self.nodes.get(parent) {
            Some(n) => &n.children,
            None => return Vec::new(),
        };
        let pos = match siblings.iter().position(|&c| c == idx) {
            Some(p) => p,
            None => return Vec::new(),
        };
        siblings[..pos]
            .iter()
            .filter(|&&c| !self.nodes.get(c).map(|n| n.is_text).unwrap_or(true))
            .copied()
            .collect()
    }

    /// anc が idx の祖先か（idx 自身は含まない）。
    pub fn is_ancestor_of(&self, anc: usize, idx: usize) -> bool {
        let mut cur = idx;
        let mut guard = 0;
        while let Some(p) = self.nodes.get(cur).and_then(|n| n.parent) {
            if p == anc {
                return true;
            }
            cur = p;
            guard += 1;
            if guard > self.nodes.len() {
                break;
            }
        }
        false
    }

    /// `Node.compareDocumentPosition(other)`（DOM標準）が丸ごと未対応だった。
    /// `this_idx`（reference node）から見た `other_idx` の位置関係をビットマスクで返す
    /// （`DOCUMENT_POSITION_*` 定数は呼び出し側 `builtins.rs` で定義）。祖先/子孫関係は
    /// 既存の `is_ancestor_of` で判定し、それ以外（兄弟や別分岐）は両者の祖先鎖を根まで
    /// 辿って最も近い共通祖先（LCA）の子リスト内での順序を比較する。根が異なる
    /// （disconnected）場合、仕様上 PRECEDING/FOLLOWING の割当ては実装依存でよいため
    /// ノードindexの大小で決定的に決める。
    pub fn document_position(&self, this_idx: usize, other_idx: usize) -> u32 {
        const DISCONNECTED: u32 = 0x01;
        const PRECEDING: u32 = 0x02;
        const FOLLOWING: u32 = 0x04;
        const CONTAINS: u32 = 0x08;
        const CONTAINED_BY: u32 = 0x10;
        const IMPLEMENTATION_SPECIFIC: u32 = 0x20;

        if this_idx == other_idx {
            return 0;
        }
        if self.is_ancestor_of(other_idx, this_idx) {
            // other は this の祖先（other が this を含む）。
            return CONTAINS | PRECEDING;
        }
        if self.is_ancestor_of(this_idx, other_idx) {
            // other は this の子孫（this が other を含む）。
            return CONTAINED_BY | FOLLOWING;
        }
        let chain_of = |start: usize| -> Vec<usize> {
            let mut chain = alloc::vec![start];
            let mut cur = start;
            let mut guard = 0;
            while let Some(p) = self.nodes.get(cur).and_then(|n| n.parent) {
                chain.push(p);
                cur = p;
                guard += 1;
                if guard > self.nodes.len() {
                    break;
                }
            }
            chain.reverse(); // ルート→自身の順に。
            chain
        };
        let chain_a = chain_of(this_idx);
        let chain_b = chain_of(other_idx);
        if chain_a.first() != chain_b.first() {
            // 根が異なる = disconnected。順序は実装依存でよいので index で決定的に決める。
            let order = if this_idx < other_idx { FOLLOWING } else { PRECEDING };
            return DISCONNECTED | IMPLEMENTATION_SPECIFIC | order;
        }
        let mut i = 0;
        while i < chain_a.len() && i < chain_b.len() && chain_a[i] == chain_b[i] {
            i += 1;
        }
        if i == 0 || i >= chain_a.len() || i >= chain_b.len() {
            // 分岐点が見つからない（理論上到達しないはずだが防御的に）。
            return DISCONNECTED | IMPLEMENTATION_SPECIFIC;
        }
        let lca = chain_a[i - 1];
        let child_a = chain_a[i];
        let child_b = chain_b[i];
        let siblings = match self.nodes.get(lca) {
            Some(n) => &n.children,
            None => return DISCONNECTED | IMPLEMENTATION_SPECIFIC,
        };
        let pos_a = siblings.iter().position(|&c| c == child_a);
        let pos_b = siblings.iter().position(|&c| c == child_b);
        match (pos_a, pos_b) {
            (Some(pa), Some(pb)) if pa < pb => FOLLOWING,
            (Some(pa), Some(pb)) if pa > pb => PRECEDING,
            _ => DISCONNECTED | IMPLEMENTATION_SPECIFIC,
        }
    }

    /// idx 自身を含め祖先方向へ、指定タグの最初の要素を返す（`<form>` 解決等）。
    /// `element.offsetParent`（HTML5。丸ごと未対応だった）。祖先を遡り、算出
    /// `position` が `static` 以外の最初の要素を返す。無ければ `<body>`
    /// （見つからなければ `None` = 仕様どおり `null`）。
    pub fn offset_parent(&self, idx: usize) -> Option<usize> {
        let mut cur = self.nodes.get(idx).and_then(|n| n.parent);
        let mut body_idx = None;
        let mut guard = 0;
        while let Some(c) = cur {
            if self.nodes.get(c).map(|n| !n.is_text && n.tag == "body").unwrap_or(false) {
                body_idx = Some(c);
            }
            let pos = self.get_computed(c, "position");
            if pos == "absolute" || pos == "relative" || pos == "fixed" || pos == "sticky" {
                return Some(c);
            }
            cur = self.nodes.get(c).and_then(|n| n.parent);
            guard += 1;
            if guard > self.nodes.len() {
                break;
            }
        }
        body_idx
    }

    pub fn closest_tag(&self, idx: usize, tag: &str) -> Option<usize> {
        let mut cur = Some(idx);
        let mut guard = 0;
        while let Some(c) = cur {
            if self
                .nodes
                .get(c)
                .map(|n| !n.is_text && n.tag == tag)
                .unwrap_or(false)
            {
                return Some(c);
            }
            cur = self.nodes.get(c).and_then(|n| n.parent);
            guard += 1;
            if guard > self.nodes.len() {
                break;
            }
        }
        None
    }

    /// フォーム系コントロールが実際に属する`<form>`を解決する。HTML5仕様では
    /// `form="formId"`属性（`<form>`の子孫でなくても、その`id`で明示的に関連付ける
    /// 「form owner」機構）が祖先探索より優先される。以前は`closest_tag(idx,
    /// "form")`（祖先探索のみ）しか実装されておらず、`<form id="f1">`の外に置かれた
    /// `<input form="f1">`（フォーム外配置は`<form>`の視覚レイアウトを変えずに
    /// コントロールだけ離れた場所に置きたい場合の定番パターン）が
    /// `element.form`で`null`になり、`<form>.checkValidity()`/送信データ収集からも
    /// 漏れる、という兄弟ギャップだった。
    pub fn associated_form(&self, idx: usize) -> Option<usize> {
        if let Some(form_id) = self.get_attr(idx, "form") {
            if let Some(fi) = self.get_element_by_id(&form_id) {
                if self.nodes.get(fi).map(|n| n.tag == "form").unwrap_or(false) {
                    return Some(fi);
                }
            }
        }
        self.closest_tag(idx, "form")
    }

    /// `<form id="f1">`に属する`tags`に含まれるタグの全フォームコントロールを
    /// 収集する。子孫に加えて、`form="f1"`属性でフォーム外から明示的に関連付けられた
    /// コントロール（`associated_form`と対になる「form owner」機構）も含む。
    /// `checkValidity()`/`FormData`収集/`form.elements`の各`<form>`祖先ループが
    /// フォーム外配置のコントロールを見落としていた兄弟ギャップの修正に使う
    /// （呼び出し側ごとに対象タグが異なる: `checkValidity`/`FormData`は
    /// `input`/`select`/`textarea`のみ、`form.elements`はそれに`button`も含む）。
    pub fn form_associated_controls(&self, form_idx: usize, tags: &[&str]) -> Vec<usize> {
        let mut out = self.descendants_by_tags(form_idx, tags);
        if let Some(form_id) = self.get_attr(form_idx, "id") {
            if !form_id.is_empty() {
                for (i, n) in self.nodes.iter().enumerate() {
                    if n.is_text || out.contains(&i) {
                        continue;
                    }
                    if !tags.contains(&n.tag.as_str()) {
                        continue;
                    }
                    if n.attrs.get("form").map(|v| v == &form_id).unwrap_or(false) {
                        out.push(i);
                    }
                }
            }
        }
        out
    }

    /// ドキュメント順で最初の指定タグ要素。
    pub fn first_by_tag(&self, tag: &str) -> Option<usize> {
        (0..self.nodes.len())
            .find(|&i| !self.nodes[i].is_text && self.nodes[i].tag == tag && self.is_attached(i))
    }

    /// 子のうち要素（非テキスト）ノードの index 一覧。
    pub fn element_children(&self, idx: usize) -> Vec<usize> {
        self.nodes
            .get(idx)
            .map(|n| {
                n.children
                    .iter()
                    .copied()
                    .filter(|c| self.nodes.get(*c).map(|cn| !cn.is_text).unwrap_or(false))
                    .collect()
            })
            .unwrap_or_default()
    }

    /// `root` 以下（自身は含まない）の子孫のうち、tag が `tags` のいずれかに一致するものを
    /// 文書順で収集する。フォーム配下の入力欄列挙（バリデーション）に使用。
    /// `element.getElementsByTagName(tag)` 用の子孫走査。`tag` が `"*"` なら全要素。
    ///
    /// # なぜ文書全体の検索を使わないか
    ///
    /// `query_all` は `is_attached` で**文書に繋がっていないノードを除外**する。
    /// 仕様では `getElementsByTagName` は**文書への接続に関係なく**自分の子孫を
    /// 返すので、切り離した要素（`createElement` した直後など）では結果が
    /// 空になってしまう。
    ///
    /// jQuery 1.8.2 の機能検出はまさにこれをやる:
    /// 切り離した `<div>` に `innerHTML` を入れ、`getElementsByTagName("a")[0]`
    /// の `style` を触る。空が返ると `undefined` の `style` を読んで落ち、
    /// **jQuery 全体が初期化できなくなっていた**。
    ///
    /// なお `is_attached` は根（索引 0）まで遡る実装のため、**空の DOM では
    /// 最初に作った要素自身が索引 0 になり偶然「接続済み」になる**。
    /// 単体試験を空のランタイムで書くとこの不具合を再現できない
    /// （実際に 5 回取り逃がした）。試験は実ページの DOM で確かめること。
    pub fn descendants_by_tag_name(&self, root: usize, tag: &str) -> Vec<usize> {
        let want_all = tag == "*";
        let lower = tag.to_ascii_lowercase();
        let mut out = Vec::new();
        let mut stack: Vec<usize> = self.element_children(root);
        let mut i = 0;
        while i < stack.len() {
            let idx = stack[i];
            i += 1;
            if let Some(n) = self.nodes.get(idx) {
                if !n.is_text && (want_all || n.tag.eq_ignore_ascii_case(&lower)) {
                    out.push(idx);
                }
                for &c in &n.children {
                    if self.nodes.get(c).map(|cn| !cn.is_text).unwrap_or(false) {
                        stack.push(c);
                    }
                }
            }
        }
        out
    }

    pub fn descendants_by_tags(&self, root: usize, tags: &[&str]) -> Vec<usize> {
        let mut out = Vec::new();
        let mut stack: Vec<usize> = self.element_children(root);
        // element_children は逆順処理だと順序が崩れるため、明示的に前順走査する。
        let mut i = 0;
        while i < stack.len() {
            let idx = stack[i];
            i += 1;
            if let Some(n) = self.nodes.get(idx) {
                if !n.is_text && tags.iter().any(|t| n.tag == *t) {
                    out.push(idx);
                }
                // 子をその場に展開（文書順を保つため idx の直後ではなく末尾へ）。
                for &c in &n.children {
                    if self.nodes.get(c).map(|cn| !cn.is_text).unwrap_or(false) {
                        stack.push(c);
                    }
                }
            }
        }
        out
    }

    /// `<fieldset disabled>`の子孫コントロールは、自身に`disabled`属性が無くても
    /// 暗黙に無効化される（HTML5仕様の「fieldset disabling」）。以前は要素自身の
    /// `disabled`属性の有無しか見ておらず、`<fieldset disabled>`配下の`<input>`は
    /// `.disabled`が常に`false`、制約バリデーションも無効化されずに常に対象内の
    /// ままになっていた。祖先を`parent`で遡り`<fieldset disabled>`が1つでも
    /// あれば無効とみなす（`<fieldset>`の最初の子`<legend>`直下のコントロールは
    /// 無効化対象外という仕様上の例外は、この処理系のフォーム系テストでは実用上
    /// ほぼ現れないため今回は簡略化して見送る）。
    pub fn is_disabled(&self, idx: usize) -> bool {
        let n = match self.nodes.get(idx) {
            Some(n) => n,
            None => return false,
        };
        if n.attrs.contains_key("disabled") {
            return true;
        }
        let mut cur = n.parent;
        while let Some(i) = cur {
            let anc = match self.nodes.get(i) {
                Some(a) => a,
                None => break,
            };
            if anc.tag == "fieldset" && anc.attrs.contains_key("disabled") {
                return true;
            }
            cur = anc.parent;
        }
        false
    }

    /// `ValidityState` の各フラグを個別に計算する（`validate_field` は最初に見つかった
    /// 違反のメッセージ1件しか返さないため、`.validity.patternMismatch` のような特定
    /// 制約の狙い撃ちには使えなかった）。`validate_field` と同じ規則を、短絡させずに
    /// 全項目評価する。
    pub fn validity_flags(&self, idx: usize, value: &str) -> ValidityFlags {
        let mut f = ValidityFlags::default();
        let n = match self.nodes.get(idx) {
            Some(n) => n,
            None => return f,
        };
        // 仕様上「制約検証の対象候補」になれるのは`button`/`input`/`select`/
        // `textarea`の4タグのみ（`output`は明示的に対象外、`fieldset`/
        // `object`等の非フォームコントロールも対象外）。以前はタグを一切
        // チェックしていなかったため、`<output>`/`<div>`のような要素に
        // 誤って`required`属性を付けると`valueMissing`が立ってしまう
        // バグだった（`willValidate`側で発見・修正した同根のバグ。
        // 2026-07-18 発見・修正）。
        if n.is_text
            || self.is_disabled(idx)
            || !matches!(n.tag.as_str(), "button" | "input" | "select" | "textarea")
        {
            return f;
        }
        let input_type = n
            .attrs
            .get("type")
            .map(|s| s.trim().to_lowercase())
            .unwrap_or_default();
        if matches!(
            input_type.as_str(),
            "submit" | "button" | "reset" | "hidden" | "image"
        ) {
            return f;
        }
        f.custom_error = n
            .attrs
            .get("_custom_validity")
            .map(|s| !s.is_empty())
            .unwrap_or(false);
        let trimmed = value.trim();
        // checkbox/radio は「値」でなく「チェック状態」で required を判定する
        // （`validate_field` と同じ規則。詳細はそちらのコメント参照）。
        f.value_missing = n.attrs.contains_key("required") && !self.required_satisfied(n, &input_type, trimmed);
        if matches!(input_type.as_str(), "checkbox" | "radio") || value.is_empty() {
            return f; // checkbox/radio、または空値は required 以外のチェックを適用しない（仕様どおり）。
        }
        let char_len = value.chars().count();
        if let Some(ml) = n.attrs.get("minlength").and_then(|v| v.trim().parse::<usize>().ok()) {
            f.too_short = char_len < ml;
        }
        if let Some(ml) = n.attrs.get("maxlength").and_then(|v| v.trim().parse::<usize>().ok()) {
            f.too_long = char_len > ml;
        }
        match input_type.as_str() {
            "email" => f.type_mismatch = !Self::is_valid_email_value(n, value),
            "url" => {
                f.type_mismatch = !(value.starts_with("http://") || value.starts_with("https://"))
            }
            // `type="date"`/`type="month"`の形式チェックが丸ごと未対応だった
            // （`input.valueAsDate`は既に`input_value_as_date_ms()`で`YYYY-MM-DD`/
            // `YYYY-MM`の妥当性を判定していたのに、`validity.typeMismatch`は
            // `email`/`url`だけしか見ておらず、不正な日付文字列を代入しても
            // 常に`typeMismatch: false`だった）。新規パーサは書かず既存関数を
            // そのまま再利用する。
            // `min`/`max`（日付の範囲制約。HTML5仕様上`type="date"`/`type="month"`も
            // `type="number"`同様に`min`/`max`属性で範囲を制約できるが、
            // `range_overflow`/`range_underflow`は元々`number`/`range`型でしか
            // 計算されておらず、日付型には丸ごと存在しなかった）は
            // `input_value_as_date_ms()`でms値に変換して比較するだけで、
            // 文字列比較用の新規ロジックは不要（ISO 8601形式は辞書式順序と
            // 時系列順序が一致するが、あえて数値のms比較で仕様どおりに扱う）。
            // `type="datetime-local"`も`input_value_as_date_ms()`が既に
            // `YYYY-MM-DDTHH:MM`形式をサポートしているため、`date`/`month`と
            // 同じ扱いに含めるだけで対応できる（`week`/`time`はこの関数自体が
            // 対応していないため対象外のまま）。
            "date" | "month" | "datetime-local" => match super::builtins::input_value_as_date_ms(&input_type, value) {
                Some(ms) => {
                    if let Some(min) = n
                        .attrs
                        .get("min")
                        .and_then(|v| super::builtins::input_value_as_date_ms(&input_type, v))
                    {
                        f.range_underflow = ms < min;
                    }
                    if let Some(max) = n
                        .attrs
                        .get("max")
                        .and_then(|v| super::builtins::input_value_as_date_ms(&input_type, v))
                    {
                        f.range_overflow = ms > max;
                    }
                }
                None => f.type_mismatch = true,
            },
            // `type="range"`もmin/max/stepの数値制約検証は`type="number"`と全く同じ
            // （`input.stepUp()`/`.stepDown()`/`.valueAsNumber`は既に両方を同列に
            // 扱っていたのに、`validity.rangeOverflow`等の制約検証だけ`number`のみに
            // 限定されており、range型ではJSから範囲外の値を代入しても常に
            // `range_overflow`/`range_underflow`/`step_mismatch`が`false`固定になる
            // 兄弟ギャップだった）。
            "number" | "range" => match value.trim().parse::<f64>() {
                Ok(num) => {
                    if let Some(min) = n.attrs.get("min").and_then(|v| v.trim().parse::<f64>().ok()) {
                        f.range_underflow = num < min;
                    }
                    if let Some(max) = n.attrs.get("max").and_then(|v| v.trim().parse::<f64>().ok()) {
                        f.range_overflow = num > max;
                    }
                    let step_attr = n.attrs.get("step").map(|s| s.trim());
                    if step_attr != Some("any") {
                        let step = step_attr
                            .and_then(|s| s.parse::<f64>().ok())
                            .filter(|s| *s > 0.0)
                            .unwrap_or(1.0);
                        let base = n
                            .attrs
                            .get("min")
                            .and_then(|v| v.trim().parse::<f64>().ok())
                            .unwrap_or(0.0);
                        let steps = (num - base) / step;
                        f.step_mismatch = libm::fabs(steps - libm::round(steps)) > 1e-9;
                    }
                }
                Err(_) => f.bad_input = true,
            },
            _ => {}
        }
        if let Some(pat) = n.attrs.get("pattern") {
            if !pat.is_empty() {
                f.pattern_mismatch = !Self::pattern_matches(pat, value);
            }
        }
        f
    }

    /// `required`制約が充足されているかを判定する。`checkbox`は自身の`checked`、
    /// `radio`は同じ`name`グループ内のいずれかが`checked`であれば充足（HTML5
    /// 仕様どおり）。それ以外の`input`/`select`/`textarea`は`value`（trim後）が
    /// 空でなければ充足。`validate_field`/`validity_flags`の両方から共通で使う。
    fn required_satisfied(&self, n: &DomNode, input_type: &str, trimmed_value: &str) -> bool {
        let is_checked = |node: &DomNode| {
            if let Some(lc) = node.attrs.get("_live_checked") {
                lc == "true"
            } else {
                node.attrs.contains_key("checked")
            }
        };
        match input_type {
            "checkbox" => is_checked(n),
            "radio" => {
                let name = n.attrs.get("name").cloned().unwrap_or_default();
                if name.is_empty() {
                    is_checked(n)
                } else {
                    self.nodes.iter().any(|other| {
                        other.tag == "input"
                            && other
                                .attrs
                                .get("type")
                                .map(|t| t.eq_ignore_ascii_case("radio"))
                                .unwrap_or(false)
                            && other.attrs.get("name").map(|nm| nm == &name).unwrap_or(false)
                            && is_checked(other)
                    })
                }
            }
            _ => !trimmed_value.is_empty(),
        }
    }

    /// HTML5 制約バリデーション。フィールド要素 `idx` と現在値 `value` を検査し、
    /// 違反があればユーザー向けメッセージを返す（None = 妥当）。
    /// 対応: setCustomValidity(_custom_validity) / required / minlength / maxlength /
    /// pattern / type=email / type=url / type=number,range(min,max,step)。
    /// disabled/readonly や type=submit/button/hidden は検証対象外。
    pub fn validate_field(&self, idx: usize, value: &str) -> Option<String> {
        let n = self.nodes.get(idx)?;
        if n.is_text {
            return None;
        }
        // 無効・隠し要素はスキップ（`<fieldset disabled>`祖先による暗黙の無効化も
        // 含む。詳細は`is_disabled`のコメント参照）。
        if self.is_disabled(idx) {
            return None;
        }
        // `validity_flags`で発見・修正したのと同根のバグ：制約検証の対象候補に
        // なれるのは`button`/`input`/`select`/`textarea`の4タグのみだが、タグを
        // 一切チェックしていなかった。`form.checkValidity()`側は`form_associated_
        // controls`で事前に`input`/`textarea`/`select`へ絞り込んでいるため実害が
        // 無かったが、`element.checkValidity()`を非候補要素（`<output>`/`<div>`
        // 等）へ直接呼ぶ経路はこのガードが無いまま`validate_field`へ落ちており、
        // 誤って`required`属性を付けると本来検証対象外のはずが invalid 扱いに
        // なる実害のあるバグだった。2026-07-18 発見・修正）。
        if !matches!(n.tag.as_str(), "button" | "input" | "select" | "textarea") {
            return None;
        }
        let input_type = n
            .attrs
            .get("type")
            .map(|s| s.trim().to_lowercase())
            .unwrap_or_default();
        if matches!(
            input_type.as_str(),
            "submit" | "button" | "reset" | "hidden" | "image"
        ) {
            return None;
        }
        // 1) setCustomValidity で設定されたカスタムメッセージが最優先。
        if let Some(cv) = n.attrs.get("_custom_validity") {
            if !cv.is_empty() {
                return Some(cv.clone());
            }
        }
        let trimmed = value.trim();
        // 2) required: 空なら違反。ただし checkbox/radio は「値」ではなく
        // 「チェック状態」で判定する別のセマンティクス（HTML5仕様: checkbox は
        // 自身の checked、radio は同じ name グループ内のいずれかが checked で
        // あれば充足）のため `required_satisfied` に委譲する。以前は
        // checkbox/radio も他の input と同じ「value 属性が空か」で判定しており、
        // `value` 属性を明示しない（＝チェック済みでも常に空文字列扱いになる）
        // チェックボックスは常に required 違反、逆に `value="yes"` だけ設定して
        // 未チェックのチェックボックスは常に妥当、というチェック状態と無関係な
        // 結果になっていた。
        if n.attrs.contains_key("required") && !self.required_satisfied(n, &input_type, trimmed) {
            return Some(match input_type.as_str() {
                "checkbox" => String::from("このフィールドをオンにしてください。"),
                "radio" => String::from("いずれかを選択してください。"),
                _ => String::from("このフィールドを入力してください。"),
            });
        }
        if matches!(input_type.as_str(), "checkbox" | "radio") {
            return None;
        }
        // 空かつ非required なら以降の形式チェックは不要。
        if value.is_empty() {
            return None;
        }
        // 3) minlength / maxlength（文字数）。
        let char_len = value.chars().count();
        if let Some(ml) = n
            .attrs
            .get("minlength")
            .and_then(|v| v.trim().parse::<usize>().ok())
        {
            if char_len < ml {
                return Some(alloc::format!(
                    "{}文字以上で入力してください（現在{}文字）。",
                    ml,
                    char_len
                ));
            }
        }
        if let Some(ml) = n
            .attrs
            .get("maxlength")
            .and_then(|v| v.trim().parse::<usize>().ok())
        {
            if char_len > ml {
                return Some(alloc::format!(
                    "{}文字以下で入力してください（現在{}文字）。",
                    ml,
                    char_len
                ));
            }
        }
        // 4) type 別の形式チェック。
        match input_type.as_str() {
            "email" if !Self::is_valid_email_value(n, value) => {
                return Some(String::from("メールアドレスを入力してください。"));
            }
            "url" if !(value.starts_with("http://") || value.starts_with("https://")) => {
                return Some(String::from("URL を入力してください。"));
            }
            // `type="date"`/`type="month"`の形式・min/max範囲チェック（詳細は
            // `validity_flags`側の同種コメント参照。既存の`input_value_as_date_ms()`を
            // そのまま再利用）。
            // `type="datetime-local"`も`input_value_as_date_ms()`が既に
            // `YYYY-MM-DDTHH:MM`形式をサポートしているため、`date`/`month`と
            // 同じ扱いに含めるだけで対応できる（`week`/`time`はこの関数自体が
            // 対応していないため対象外のまま）。
            "date" | "month" | "datetime-local" => match super::builtins::input_value_as_date_ms(&input_type, value) {
                Some(ms) => {
                    if let Some(min) = n
                        .attrs
                        .get("min")
                        .and_then(|v| super::builtins::input_value_as_date_ms(&input_type, v))
                    {
                        if ms < min {
                            return Some(alloc::format!(
                                "{}以降の日付を入力してください。",
                                n.attrs.get("min").cloned().unwrap_or_default()
                            ));
                        }
                    }
                    if let Some(max) = n
                        .attrs
                        .get("max")
                        .and_then(|v| super::builtins::input_value_as_date_ms(&input_type, v))
                    {
                        if ms > max {
                            return Some(alloc::format!(
                                "{}以前の日付を入力してください。",
                                n.attrs.get("max").cloned().unwrap_or_default()
                            ));
                        }
                    }
                }
                None => return Some(String::from("正しい日付を入力してください。")),
            },
            // `type="range"`も`type="number"`と同じ min/max/step 検証規則を適用する
            // （詳細は`validity_flags`側の同種コメント参照。以前は`range`型だけ
            // 検証が丸ごと欠けていた）。
            "number" | "range" => match value.trim().parse::<f64>() {
                Ok(num) => {
                    if let Some(min) = n
                        .attrs
                        .get("min")
                        .and_then(|v| v.trim().parse::<f64>().ok())
                    {
                        if num < min {
                            return Some(alloc::format!("{}以上の値を入力してください。", min));
                        }
                    }
                    if let Some(max) = n
                        .attrs
                        .get("max")
                        .and_then(|v| v.trim().parse::<f64>().ok())
                    {
                        if num > max {
                            return Some(alloc::format!("{}以下の値を入力してください。", max));
                        }
                    }
                    // `stepMismatch`（HTML5 制約検証。min/max はあったが step が丸ごと
                    // 未対応だった）。`step="any"` は制約無し。既定 step は 1、step の
                    // 基準点（仕様上の「step base」）は `min` があればそれ、無ければ 0。
                    let step_attr = n.attrs.get("step").map(|s| s.trim());
                    if step_attr != Some("any") {
                        let step = step_attr
                            .and_then(|s| s.parse::<f64>().ok())
                            .filter(|s| *s > 0.0)
                            .unwrap_or(1.0);
                        let base = n
                            .attrs
                            .get("min")
                            .and_then(|v| v.trim().parse::<f64>().ok())
                            .unwrap_or(0.0);
                        let steps = (num - base) / step;
                        if libm::fabs(steps - libm::round(steps)) > 1e-9 {
                            return Some(alloc::format!(
                                "{} の倍数（基準値 {}）で入力してください。",
                                step,
                                base
                            ));
                        }
                    }
                }
                Err(_) => return Some(String::from("数値を入力してください。")),
            },
            _ => {}
        }
        // 5) pattern（簡易: 完全一致のリテラル比較、ワイルドカードのみ対応）。
        if let Some(pat) = n.attrs.get("pattern") {
            if !pat.is_empty() && !Self::pattern_matches(pat, value) {
                return Some(String::from("要求された形式で入力してください。"));
            }
        }
        None
    }

    /// 簡易メールアドレス検証（完全な RFC ではなく実用的な近似）。
    fn is_valid_email(s: &str) -> bool {
        let (local, domain) = match s.split_once('@') {
            Some(v) => v,
            None => return false,
        };
        if local.is_empty() || domain.is_empty() {
            return false;
        }
        if domain.contains('@') {
            return false;
        }
        // ドメインに '.' があり、前後が非空。
        match domain.split_once('.') {
            Some((a, b)) => !a.is_empty() && !b.is_empty(),
            None => false,
        }
    }

    /// `<input type="email" multiple>`（HTML5。`multiple`属性がある email input は
    /// カンマ区切りで複数アドレスを入力できる仕様だが、以前は`is_valid_email(value)`
    /// を値全体にそのまま適用しており、2件目以降のアドレスやカンマ自体を含む文字列は
    /// 単一アドレスとして常に不正と誤判定されていた（逆に`multiple`が無いのに
    /// カンマ区切りを入力した場合はこのメソッドを経由しないため今までどおり単一
    /// アドレスとして正しく不正判定される）。空要素（`"a@b.com,"`のような末尾カンマ）
    /// は仕様上不正。
    fn is_valid_email_value(n: &DomNode, value: &str) -> bool {
        if n.attrs.contains_key("multiple") {
            value.split(',').all(|part| Self::is_valid_email(part.trim()))
        } else {
            Self::is_valid_email(value)
        }
    }

    /// `<input pattern="...">`（HTML Living Standard の制約検証。仕様上は値全体を
    /// `^(?:pattern)$` として完全一致させる）が、以前はメタ文字を含む複雑なパターンを
    /// 「誤検知で送信を妨げないため」全て無条件で通過させる簡易近似だった。この
    /// エンジンには既に本物の正規表現実装（`js::regex::Regex`）があるため、それを
    /// そのまま使えば近似ではなく正しく検証できる（`\d`/`[...]`/`+`/`.*` 等、
    /// HTML pattern で使われる構文は通常の JS RegExp と同じ）。
    fn pattern_matches(pat: &str, val: &str) -> bool {
        let anchored = format!("^(?:{})$", pat);
        let re = super::regex::Regex::new(&anchored, "");
        let chars: alloc::vec::Vec<char> = val.chars().collect();
        re.find_at(&chars, 0).is_some()
    }

    /// 属性名の一覧（id/class を先頭に、続いてその他属性）。
    pub fn attr_names(&self, idx: usize) -> Vec<String> {
        let mut out = Vec::new();
        if let Some(n) = self.nodes.get(idx) {
            if !n.id.is_empty() {
                out.push(String::from("id"));
            }
            if !n.classes.is_empty() {
                out.push(String::from("class"));
            }
            // id/class は専用フィールドで既に出力済みなので attrs 側では除外。
            // `_` 始まりの内部専用属性（`_content_frag` 等）も
            // `serialize_node_html` と同じ理由で除外する（以前は
            // `getAttributeNames()`/`hasAttributes()` にそのまま漏れていた）。
            for k in n.attrs.keys() {
                if k != "id" && k != "class" && !k.starts_with('_') {
                    out.push(k.clone());
                }
            }
        }
        out
    }

    pub fn add_listener(&mut self, node: usize, event: &str, func: Value) {
        self.add_listener_opts(node, event, func, false, false);
    }

    /// capture / once オプション付きでリスナを登録する。重複（同一 node+event+func+capture）
    /// は DOM 仕様どおり無視する。戻り値は発番した ID。
    pub fn add_listener_opts(
        &mut self,
        node: usize,
        event: &str,
        func: Value,
        capture: bool,
        once: bool,
    ) -> u64 {
        self.add_listener_opts_signal(node, event, func, capture, once, None)
    }

    /// `add_listener_opts` の `{signal}` 対応版。`signal` が既に abort 済みなら
    /// 仕様どおり登録自体を行わない。
    pub fn add_listener_opts_signal(
        &mut self,
        node: usize,
        event: &str,
        func: Value,
        capture: bool,
        once: bool,
        signal: Option<Value>,
    ) -> u64 {
        if signal.as_ref().is_some_and(is_signal_aborted) {
            return 0;
        }
        // 同一 (node, event, func, capture) の重複登録は無視（DOM 仕様）。
        if self.listeners.iter().any(|l| {
            l.node == node && l.event == event && l.capture == capture && l.func.same_ref(&func)
        }) {
            return 0;
        }
        let id = self.next_listener_id;
        self.next_listener_id += 1;
        self.listeners.push(Listener {
            node,
            event: event.to_string(),
            func,
            capture,
            once,
            id,
            signal,
        });
        id
    }

    /// removeEventListener: 同一 (node, event, func, capture) のリスナを削除する。
    pub fn remove_listener(&mut self, node: usize, event: &str, func: &Value, capture: bool) {
        self.listeners.retain(|l| {
            !(l.node == node && l.event == event && l.capture == capture && l.func.same_ref(func))
        });
    }

    /// ID 指定でリスナを削除する（once 発火後の自動削除に使う）。
    pub fn remove_listener_by_id(&mut self, id: u64) {
        self.listeners.retain(|l| l.id != id);
    }

    /// 指定イベント型のリスナがページ内に1つでも登録されているか（ホバー判定の省略用）。
    pub fn has_listener(&self, event: &str) -> bool {
        self.listeners.iter().any(|l| l.event == event)
    }

    /// 指定ノードに登録された指定イベントのリスナ関数を返す（呼び出しは呼び元で）。
    /// バブリングフェーズ用（capture=false のみ）。`{signal}` が abort 済みの
    /// リスナは除外する。
    pub fn listeners_for(&self, node: usize, event: &str) -> Vec<Value> {
        self.listeners
            .iter()
            .filter(|l| l.node == node && l.event == event && !l.capture && !is_listener_aborted(l))
            .map(|l| l.func.clone())
            .collect()
    }

    /// 指定ノード・イベントのリスナを (func, capture, once, id) 付きで返す。
    /// `want_capture` でキャプチャ/バブルのどちらのフェーズかを絞り込む。
    /// `{signal}` が abort 済みのリスナは除外する。
    pub fn listeners_phase(
        &self,
        node: usize,
        event: &str,
        want_capture: bool,
    ) -> Vec<(Value, bool, u64)> {
        self.listeners
            .iter()
            .filter(|l| l.node == node && l.event == event && l.capture == want_capture && !is_listener_aborted(l))
            .map(|l| (l.func.clone(), l.once, l.id))
            .collect()
    }

    /// 指定ノードに当該イベントのリスナ（フェーズ問わず）が在るか。
    pub fn has_listener_on(&self, node: usize, event: &str) -> bool {
        self.listeners
            .iter()
            .any(|l| l.node == node && l.event == event)
    }

    /// 再パースした DOM 木へ JS の変更を焼き戻す。木はビルド時と同一ドキュメント順前提。
    pub fn apply_overrides(&self, root: &mut Node) {
        let mut counter = 0usize;
        self.apply_node(root, &mut counter);
    }
    fn apply_node(&self, node: &mut Node, counter: &mut usize) {
        let idx = *counter;
        *counter += 1;
        if let Some(dn) = self.nodes.get(idx) {
            match &mut node.node_type {
                NodeType::Text(t) => {
                    if let Some(ov) = &dn.text_override {
                        *t = ov.clone();
                    }
                }
                NodeType::Element {
                    attributes,
                    classes,
                    ..
                } => {
                    if dn.classes_dirty {
                        *classes = dn.classes.clone();
                        attributes.insert("class".to_string(), dn.classes.join(" "));
                    }
                    if dn.style_dirty {
                        attributes.insert("style".to_string(), serialize_inline_style(&dn.style));
                    }
                }
            }
        }
        for c in &mut node.children {
            self.apply_node(c, counter);
        }
    }
}

/// `outerHTML` 直列化用の最小限の HTML エスケープ（テキストノード本文）。
fn html_escape_text(s: &str) -> String {
    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
}
/// `outerHTML` 直列化用の最小限の HTML エスケープ（属性値。`"` も escape する）。
fn html_escape_attr(s: &str) -> String {
    s.replace('&', "&amp;").replace('"', "&quot;")
}

/// 生の宣言値末尾の `!important`（大小文字・空白ゆれ許容）を切り離す。
/// `(値本体, important か)` を返す。CSS カスケード側（`css.rs`）の
/// `!important` パーサとは別実装だが、`element.style.getPropertyValue`/
/// `.getPropertyPriority`（丸ごと未対応だった。2026-07-16 発見）専用の
/// 軽量版。
fn strip_style_priority(raw: &str) -> (&str, bool) {
    let trimmed = raw.trim_end();
    if let Some(pos) = trimmed.to_ascii_lowercase().rfind("!important") {
        if trimmed.get(pos..).unwrap_or("").eq_ignore_ascii_case("!important") {
            let before = trimmed.get(..pos).unwrap_or("").trim_end();
            return (before, true);
        }
    }
    (raw, false)
}

/// `color: red; font-size: 12px` → マップ。
fn parse_inline_style(s: &str) -> BTreeMap<String, String> {
    let mut m = BTreeMap::new();
    for decl in s.split(';') {
        let decl = decl.trim();
        if decl.is_empty() {
            continue;
        }
        if let Some(colon) = decl.find(':') {
            let k = decl.get(..colon).unwrap_or("").trim().to_lowercase();
            let v = decl.get(colon + 1..).unwrap_or("").trim().to_string();
            if !k.is_empty() {
                m.insert(k, v);
            }
        }
    }
    m
}

fn serialize_inline_style(m: &BTreeMap<String, String>) -> String {
    let mut parts = Vec::new();
    for (k, v) in m {
        parts.push(format!("{}: {}", k, v));
    }
    parts.join("; ")
}

/// `backgroundColor` → `background-color`。既にケバブならそのまま。
fn css_prop_from_camel(prop: &str) -> String {
    if prop.contains('-') || !prop.chars().any(|c| c.is_ascii_uppercase()) {
        return prop.to_lowercase();
    }
    let mut out = String::new();
    for c in prop.chars() {
        if c.is_ascii_uppercase() {
            out.push('-');
            out.push(c.to_ascii_lowercase());
        } else {
            out.push(c);
        }
    }
    out
}