atmos/os_lib/js/builtins/

dom.rs

// 分割: builtins.rs より機械的に移動（2026-07-16 リファクタ フェーズ2）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

// ============ DOM ネイティブ ============

/// 無害な no-op（未対応 API 用）。
pub fn dom_noop(_: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}

/// `new XMLSerializer()`（丸ごと未対応だった。`.serializeToString(node)`
/// という定番パターン）。
pub(crate) fn xml_serializer_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let o = Obj::plain();
    o.borrow_mut().props.insert(
        "serializeToString".into(),
        nv("serializeToString", xml_serializer_serialize_to_string),
    );
    Ok(Value::Object(o))
}
/// `serializer.serializeToString(node)`。既存の `element.outerHTML` ゲッター
/// （`interp.rs`）と同じ `DomBridge::get_outer_html` を再利用する（DOM 要素
/// ハンドルでない値/未接続ノードは仕様の詳細な例外分岐を省略し空文字列を返す
/// 簡略実装）。
pub(crate) fn xml_serializer_serialize_to_string(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let node = arg(a, 0);
    match this_dom_idx(&node) {
        Some(idx) => Ok(Value::str(it.dom.borrow().get_outer_html(idx))),
        None => Ok(Value::str("")),
    }
}

/// `this`（DOM 要素ハンドル）からノード index を取り出す。
pub(crate) fn this_dom_idx(this: &Value) -> Option<usize> {
    if let Value::Object(o) = this {
        if let ObjKind::DomElement(i) = o.borrow().kind {
            return Some(i);
        }
    }
    None
}

/// `this`（Host("classList:N") など）から prefix を剥がして index を取り出す。
/// `element.style.setProperty(name, value)`/`getPropertyValue(name)`/`removeProperty(name)`
/// が丸ごと欠落していた（直接のプロパティ代入 `el.style.color = 'red'` と、
/// `getComputedStyle().getPropertyValue()` はあったが、インラインスタイルの
/// メソッド経由の読み書きが無かった）。特に CSS カスタムプロパティ（`--foo`）は
/// camelCase のプロパティアクセサ経由では設定できないため、`setProperty` の欠落は
/// カスタムプロパティを使う実用コードで特に影響が大きかった。
pub fn dom_style_set_property(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        let value = arg(a, 1).to_js_string();
        // `setProperty(name, value, priority)` の第3引数（丸ごと無視されて
        // いた。2026-07-16 発見）。生の値文字列末尾に `!important` を
        // 付加して保存すれば、`serialize_inline_style` 経由で再構築される
        // `style` 属性文字列を通じて既存のカスケード側 `!important` パーサ
        // （`css.rs`）にもそのまま伝わる。
        let priority = arg(a, 2).to_js_string();
        let stored = if !value.is_empty() && priority.eq_ignore_ascii_case("important") {
            alloc::format!("{} !important", value)
        } else {
            value
        };
        it.dom.borrow_mut().set_style(idx, &name, &stored);
    }
    Ok(Value::Undefined)
}
pub fn dom_style_get_property_priority(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        return Ok(Value::str(it.dom.borrow().get_style_priority(idx, &name)));
    }
    Ok(Value::str(""))
}
pub fn dom_style_get_property_value(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        return Ok(Value::str(it.dom.borrow().get_style(idx, &name)));
    }
    Ok(Value::str(""))
}
pub fn dom_style_remove_property(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        let prev = it.dom.borrow().get_style(idx, &name);
        it.dom.borrow_mut().set_style(idx, &name, "");
        return Ok(Value::str(prev));
    }
    Ok(Value::str(""))
}
/// `style.item(index)`（丸ごと未対応だった。`style.length`と対）。
/// `get_css_text`の直列化文字列を`;`で分割し直す簡略実装（`dom_props.rs`
/// の`length`ゲッターと同じロジック）。
pub fn dom_style_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let names: alloc::vec::Vec<String> = it
            .dom
            .borrow()
            .get_css_text(idx)
            .split(';')
            .filter_map(|d| d.split_once(':').map(|(k, _)| k.trim().to_string()))
            .filter(|k| !k.is_empty())
            .collect();
        let i = arg(a, 0).to_number();
        if i.is_finite() && i >= 0.0 {
            if let Some(name) = names.get(i as usize) {
                return Ok(Value::str(name.clone()));
            }
        }
    }
    Ok(Value::str(""))
}
pub(crate) fn this_host_idx(this: &Value, prefix: &str) -> Option<usize> {
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if let Some(rest) = t.strip_prefix(prefix) {
                return rest.parse().ok();
            }
        }
    }
    None
}

/// 要素ハンドルを Value にして返す。idx が無ければ null。
pub(crate) fn dom_handle(idx: Option<usize>) -> Value {
    match idx {
        Some(i) => Value::Object(Obj::dom(i)),
        None => Value::Null,
    }
}

pub(crate) fn document_get_element_by_id(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let id = arg(a, 0).to_js_string();
    let idx = it.dom.borrow().get_element_by_id(&id);
    Ok(dom_handle(idx))
}

pub(crate) fn document_query_selector(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let sel = arg(a, 0).to_js_string();
    let idx = it.dom.borrow().query(&sel);
    Ok(dom_handle(idx))
}

pub(crate) fn document_query_selector_all(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let sel = arg(a, 0).to_js_string();
    let indices = it.dom.borrow().query_all(&sel);
    let items: Vec<Value> = indices
        .into_iter()
        .map(|i| Value::Object(Obj::dom(i)))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}
/// 座標 `(x, y)` を含む矩形を持つ要素を、面積が小さい（＝最も深くネストした）
/// 順に列挙する共通ヘルパー。`elementFromPoint`/`elementsFromPoint` で共有。
pub(crate) fn dom_hit_test(it: &Interp, x: f64, y: f64) -> alloc::vec::Vec<(usize, i64)> {
    let dom = it.dom.borrow();
    let mut matches: alloc::vec::Vec<(usize, i64)> = alloc::vec::Vec::new();
    for (&idx, &(l, t, w, h)) in dom.rects.iter() {
        let (lf, tf, wf, hf) = (l as f64, t as f64, w as f64, h as f64);
        if x >= lf && x < lf + wf && y >= tf && y < tf + hf {
            matches.push((idx, (w as i64) * (h as i64)));
        }
    }
    matches.sort_by_key(|&(_, area)| area);
    matches
}
pub(crate) fn document_element_from_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let matches = dom_hit_test(it, x, y);
    Ok(match matches.first() {
        Some(&(idx, _)) => Value::Object(Obj::dom(idx)),
        None => Value::Null,
    })
}
pub(crate) fn document_elements_from_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let items: alloc::vec::Vec<Value> = dom_hit_test(it, x, y)
        .into_iter()
        .map(|(idx, _)| Value::Object(Obj::dom(idx)))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}

pub fn dom_add_event_listener(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let event = arg(a, 0).to_js_string();
        let func = arg(a, 1);
        let (capture, once) = parse_listener_opts(&arg(a, 2));
        let signal = parse_listener_signal(&arg(a, 2));
        if matches!(func, Value::Object(_)) {
            it.dom
                .borrow_mut()
                .add_listener_opts_signal(idx, &event, func, capture, once, signal);
        }
    }
    Ok(Value::Undefined)
}

/// addEventListener / removeEventListener の第3引数を解釈する。
/// boolean なら capture フラグ、オブジェクトなら {capture, once} を読む。
pub(crate) fn parse_listener_opts(opt: &Value) -> (bool, bool) {
    match opt {
        Value::Bool(b) => (*b, false),
        Value::Object(o) => {
            let b = o.borrow();
            let capture = b.props.get("capture").map(|v| v.truthy()).unwrap_or(false);
            let once = b.props.get("once").map(|v| v.truthy()).unwrap_or(false);
            (capture, once)
        }
        _ => (false, false),
    }
}
/// `addEventListener(type, fn, {signal})`（丸ごと未対応だった）の `signal`
/// オプションを取り出す。`AbortSignal` らしきオブジェクト（`aborted` プロパティ
/// を持つ）以外は無視する。
pub(crate) fn parse_listener_signal(opt: &Value) -> Option<Value> {
    if let Value::Object(o) = opt {
        let s = o.borrow().props.get("signal").cloned();
        if let Some(sig @ Value::Object(so)) = &s {
            if so.borrow().props.contains_key("aborted") {
                return Some(sig.clone());
            }
        }
    }
    None
}

/// element.removeEventListener(type, fn, opts): 一致するリスナを削除する。
pub fn dom_remove_event_listener(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let event = arg(a, 0).to_js_string();
        let func = arg(a, 1);
        let (capture, _once) = parse_listener_opts(&arg(a, 2));
        if matches!(func, Value::Object(_)) {
            it.dom
                .borrow_mut()
                .remove_listener(idx, &event, &func, capture);
        }
    }
    Ok(Value::Undefined)
}

/// element.dispatchEvent(ev): ev.type のイベントを当該要素から発火する。
/// 戻り値は !defaultPrevented（DOM 仕様）。
pub fn dom_dispatch_event(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = match this_dom_idx(&this) {
        Some(i) => i,
        None => return Ok(Value::Bool(true)),
    };
    let ev = arg(a, 0);
    // ev.type を取得。bubbles など追加プロパティはそのまま渡す。
    let (etype, extra) = if let Value::Object(o) = &ev {
        let b = o.borrow();
        let t = b
            .props
            .get("type")
            .map(|v| v.to_js_string())
            .unwrap_or_default();
        // 既知の組み込みプロパティ以外を extra として転送（detail など）。`bubbles`
        // は以前ここで除外されており、コメント「bubbles など追加プロパティは
        // そのまま渡す」と矛盾していた（実際には常に除外され `dispatch_event_*`
        // 側で無条件 `true` 決め打ちに繋がっていた）。非バブリングイベントを
        // 正しく伝播させるため、`bubbles` は除外せず転送する。
        let mut extra: Vec<(String, Value)> = Vec::new();
        for (k, v) in b.props.iter() {
            if matches!(
                k.as_str(),
                "type"
                    | "target"
                    | "currentTarget"
                    | "eventPhase"
                    | "defaultPrevented"
                    | "preventDefault"
                    | "stopPropagation"
                    | "stopImmediatePropagation"
                    | "composedPath"
                    | "_composedPath"
                    | "_stop"
                    | "_stopImmediate"
            ) {
                continue;
            }
            extra.push((k.clone(), v.clone()));
        }
        (t, extra)
    } else {
        (ev.to_js_string(), Vec::new())
    };
    if etype.is_empty() {
        return Ok(Value::Bool(true));
    }
    let (_fired, prevented) = it.dispatch_event_in_interp(idx, &etype, &extra);
    Ok(Value::Bool(!prevented))
}

/// `node.hasChildNodes()`（丸ごと未対応だった。`node.childNodes.length > 0`
/// の定番の手間を省くメソッド）。
pub fn dom_has_child_nodes(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let has_kids = it
            .dom
            .borrow()
            .nodes
            .get(idx)
            .map(|n| !n.children.is_empty())
            .unwrap_or(false);
        return Ok(Value::Bool(has_kids));
    }
    Ok(Value::Bool(false))
}
pub fn dom_get_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        return Ok(match it.dom.borrow().get_attr(idx, &name) {
            Some(v) => Value::str(v),
            None => Value::Null,
        });
    }
    Ok(Value::Null)
}

pub fn dom_has_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        return Ok(Value::Bool(it.dom.borrow().has_attr(idx, &name)));
    }
    Ok(Value::Bool(false))
}

/// `element.attributes`（`NamedNodeMap`。`{name,value}` の簡略表現）と同じ
/// 形で `Attr` ノード相当のオブジェクトを作る。`ownerElement` も含める。
pub(crate) fn make_attr_node(name: &str, value: &str, owner: &Value) -> Value {
    let o = Obj::plain();
    let mut b = o.borrow_mut();
    b.props.insert("name".into(), Value::str(name));
    b.props.insert("value".into(), Value::str(value));
    b.props.insert("ownerElement".into(), owner.clone());
    drop(b);
    Value::Object(o)
}
/// `document.createAttribute(name)`（丸ごと未対応だった。`getAttributeNode`
/// と対になる、`Attr` ノードを新規に作ってから `setAttributeNode()` で
/// 要素へ取り付ける定番パターン）。HTML 文書のため仕様どおり名前を
/// 小文字化し、値は空文字列・`ownerElement` は `null`（未取り付け）で返す。
pub fn document_create_attribute(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string().to_lowercase();
    Ok(make_attr_node(&name, "", &Value::Null))
}
/// `element.getAttributeNode(name)`（丸ごと未対応だった。`getAttribute`
/// より古い/低レベルな `Attr` ノード経由の定番イディオム）。この処理系には
/// `Attr` 専用の内部表現が無いため、`element.attributes` と同じ
/// `{name, value, ownerElement}` の簡略オブジェクトを返す。
pub fn dom_get_attribute_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        if let Some(v) = it.dom.borrow().get_attr(idx, &name) {
            return Ok(make_attr_node(&name, &v, &this));
        }
    }
    Ok(Value::Null)
}
/// `element.setAttributeNode(attr)`。`attr.name`/`attr.value` を読み取って
/// 通常の `setAttribute` と同じストアへ反映する。戻り値は仕様上「置換された
/// 旧 Attr ノード（無ければ null）」。
pub fn dom_set_attribute_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let attr = arg(a, 0);
        if matches!(attr, Value::Object(_)) {
            let name = obj_prop(&attr, "name").map(|v| v.to_js_string()).unwrap_or_default();
            let value = obj_prop(&attr, "value").map(|v| v.to_js_string()).unwrap_or_default();
            let old = it.dom.borrow().get_attr(idx, &name);
            it.dom.borrow_mut().set_attr(idx, &name, &value);
            if let Some(old_v) = old {
                return Ok(make_attr_node(&name, &old_v, &this));
            }
        }
    }
    Ok(Value::Null)
}
/// `element.getAttributeNodeNS(namespace, localName)`（丸ごと未対応だった）。
/// 他の `*AttributeNS` と同じく `namespace` 引数は無視し `localName` で検索する。
pub fn dom_get_attribute_node_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = if a.len() >= 2 {
            arg(a, 1).to_js_string()
        } else {
            arg(a, 0).to_js_string()
        };
        if let Some(v) = it.dom.borrow().get_attr(idx, &name) {
            return Ok(make_attr_node(&name, &v, &this));
        }
    }
    Ok(Value::Null)
}
/// `element.removeAttributeNode(attr)`。`attr.name` の属性を削除し、削除した
/// `Attr` ノードを返す（仕様上、未存在なら `NotFoundError` だがこの処理系は
/// 例外機構が限定的なため簡略化し `null` を返す）。
pub fn dom_remove_attribute_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = obj_prop(&arg(a, 0), "name").map(|v| v.to_js_string()).unwrap_or_default();
        // `it.dom.borrow()` の一時 `Ref` を `if let` ブロック内で保持したまま
        // `borrow_mut()` すると panic する既知のバグ族（`select_options_remove`
        // で実際に発生した既知パターン。2026-07-14 の RefCell 二重借用横断監査で
        // この形自体は洗い出し済みだったが、同日の新規コードでまた作り込んで
        // しまった）。owned な値へ一度 materialize してから使う。
        let old = it.dom.borrow().get_attr(idx, &name);
        if let Some(v) = old {
            it.dom.borrow_mut().remove_attr(idx, &name);
            return Ok(make_attr_node(&name, &v, &this));
        }
    }
    Ok(Value::Null)
}

pub fn dom_remove_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        it.dom.borrow_mut().remove_attr(idx, &name);
    }
    Ok(Value::Undefined)
}

/// `getAttributeNS`/`setAttributeNS`/`hasAttributeNS`/`removeAttributeNS`
/// （丸ごと未対応だった。SVG 等で `setAttributeNS(null, 'viewBox', ...)` のように
/// 使われる定番イディオム）。この処理系は XML 名前空間を一切モデル化していないため、
/// 第1引数（namespace）は無視して非 NS 版と同じ属性ストアへ委譲する簡略実装
/// （多くの実用コードは namespace に `null` を渡すため実害は小さい）。
pub fn dom_get_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_get_attribute(it, this, &a[1.min(a.len())..])
}
pub fn dom_set_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_set_attribute(it, this, &a[1.min(a.len())..])
}
pub fn dom_has_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_has_attribute(it, this, &a[1.min(a.len())..])
}
pub fn dom_remove_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_remove_attribute(it, this, &a[1.min(a.len())..])
}

pub fn dom_get_attribute_names(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let names: Vec<Value> = it
            .dom
            .borrow()
            .attr_names(idx)
            .into_iter()
            .map(Value::str)
            .collect();
        return Ok(Value::Object(Obj::array(names)));
    }
    Ok(Value::Object(Obj::array(Vec::new())))
}
/// `element.hasAttributes()`（丸ごと未対応だった。単一属性の有無を見る `hasAttribute(name)`
/// は既に実装済みだったが、「1つでも属性を持つか」を見るこちらが漏れていた）。
pub fn dom_has_attributes(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        return Ok(Value::Bool(!it.dom.borrow().attr_names(idx).is_empty()));
    }
    Ok(Value::Bool(false))
}
/// `node.normalize()`（丸ごと未対応だった。連続する隣接テキストノードを1つに連結し、
/// 空のテキストノードを取り除く DOM 標準メソッド）。
pub fn dom_normalize(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom.borrow_mut().normalize_node(idx);
    }
    Ok(Value::Undefined)
}
/// `CharacterData.appendData`/`.deleteData`/`.insertData`/`.replaceData`/
/// `.substringData`（丸ごと未対応だった。2026-07-16 発見）。テキストノード
/// のみに意味を持つ（呼び出し元の interp.rs 側で `is_text` ガード済み）ため
/// ここでは無条件にテキスト内容を読み書きする。他の文字列系メソッド
/// （`str_slice`/`str_substring`）と同じ char 単位オフセットの簡略実装
/// （UTF-16 コード単位ではない）。
fn char_data_chars(it: &Interp, idx: usize) -> alloc::vec::Vec<char> {
    it.dom.borrow().get_text_content(idx).chars().collect()
}
pub fn dom_char_data_append(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let mut s = it.dom.borrow().get_text_content(idx);
        s.push_str(&arg(a, 0).to_js_string());
        it.dom.borrow_mut().set_text_content(idx, &s);
    }
    Ok(Value::Undefined)
}
/// `CharacterData`編集メソッド群（`deleteData`/`insertData`/`replaceData`/
/// `substringData`）は仕様上、`offset`が`length`を超える場合`IndexSizeError`を
/// 投げるべき（`count`側は超過分を自動的にクランプするだけで例外にはならない）
/// が、以前は`offset`も`len`へ黙ってクランプしてしまい、範囲外呼び出しが
/// 常に無害な no-op（`deleteData`/`substringData`）や末尾への追記
/// （`insertData`）として成立していた。`table.insertRow`等と同じ「範囲外
/// インデックスの黙殺」バグ族の一つ。
fn char_data_check_offset(offset_arg: Value, len: usize) -> Result<usize, Value> {
    let raw = offset_arg.to_number();
    let offset = if raw.is_finite() { raw.max(0.0) as usize } else { 0 };
    if offset > len {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The offset is greater than the length of the data",
        ));
    }
    Ok(offset)
}
pub fn dom_char_data_delete(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let count = (arg(a, 1).to_number().max(0.0) as usize).min(len - offset);
        let out: String = chars[..offset].iter().chain(chars[offset + count..].iter()).collect();
        it.dom.borrow_mut().set_text_content(idx, &out);
    }
    Ok(Value::Undefined)
}
pub fn dom_char_data_insert(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let insert = arg(a, 1).to_js_string();
        let out: String = chars[..offset]
            .iter()
            .collect::<String>()
            + &insert
            + &chars[offset..].iter().collect::<String>();
        it.dom.borrow_mut().set_text_content(idx, &out);
    }
    Ok(Value::Undefined)
}
pub fn dom_char_data_replace(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let count = (arg(a, 1).to_number().max(0.0) as usize).min(len - offset);
        let replacement = arg(a, 2).to_js_string();
        let out: String = chars[..offset]
            .iter()
            .collect::<String>()
            + &replacement
            + &chars[offset + count..].iter().collect::<String>();
        it.dom.borrow_mut().set_text_content(idx, &out);
    }
    Ok(Value::Undefined)
}
pub fn dom_char_data_substring(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let count = (arg(a, 1).to_number().max(0.0) as usize).min(len - offset);
        return Ok(Value::str(chars[offset..offset + count].iter().collect::<String>()));
    }
    Ok(Value::str(""))
}
/// `Text.splitText(offset)`（丸ごと未対応だった。2026-07-16 発見。
/// `CharacterData`編集メソッド群の隣で発見。テキストノードを`offset`位置で
/// 2つに分割し、後半を新しいテキストノードとして直後の兄弟に挿入して返す
/// 仕様どおりの動作。`char_data_chars`と同じ char 単位オフセットの簡略実装）。
pub fn dom_split_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let chars = char_data_chars(it, idx);
    let len = chars.len();
    // `deleteData`等と同じ仕様: `offset > length`は`IndexSizeError`（詳細は
    // `char_data_check_offset`のコメント参照）。
    let offset = char_data_check_offset(arg(a, 0), len)?;
    let before: String = chars[..offset].iter().collect();
    let after: String = chars[offset..].iter().collect();
    it.dom.borrow_mut().set_text_content(idx, &before);
    let new_idx = it.dom.borrow_mut().create_text_node(&after);
    let (parent, next_sibling) = {
        let dom = it.dom.borrow();
        match dom.nodes.get(idx).and_then(|n| n.parent) {
            Some(p) => {
                let pos = dom.nodes[p].children.iter().position(|&c| c == idx);
                let next = pos.and_then(|i| dom.nodes[p].children.get(i + 1)).copied();
                (Some(p), next)
            }
            None => (None, None),
        }
    };
    if let Some(p) = parent {
        it.dom.borrow_mut().insert_before(p, new_idx, next_sibling);
    }
    Ok(Value::Object(Obj::dom(new_idx)))
}

/// HTML5 Table DOM（`table.insertRow`/`.deleteRow`/`.rows`、`tr.insertCell`/
/// `.deleteCell`/`.cells`）が丸ごと未対応だった（2026-07-17 発見。`select.
/// options.add`/`.remove` と同じ「動的に構築する」定番イディオム）。`thead`/
/// `tbody`/`tfoot` を明示的にモデル化せず、常に文書順の `descendants_by_tags`
/// で `tr`/`td`/`th` を集約する簡略実装（新規行は「参照行の親」＝既存の
/// `tbody`があればその中、無ければ`table`直下へ挿入する）。
pub fn dom_table_insert_row(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(table_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let rows = it.dom.borrow().descendants_by_tags(table_idx, &["tr"]);
    let len = rows.len();
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // 仕様上 `insertRow(index)` の有効範囲は `-1 <= index <= rows.length`
    // （`-1`/`length`は末尾への追加を意味する）で、範囲外は`IndexSizeError`を
    // 投げるべきだが、以前は範囲外の値をすべて「末尾へ追加」として黙って
    // 受け入れてしまっていた（`table.insertRow(9999)`が例外にならず末尾追加
    // として成功していた）。`insertCell`/`deleteRow`/`deleteCell`にも同じ
    // パターンのバグがあり、まとめて修正した。
    if pos < -1 || pos > len as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of rows represented by this table",
        ));
    }
    let (parent, ref_child) = if pos >= 0 && (pos as usize) < len {
        let r = rows[pos as usize];
        (it.dom.borrow().nodes.get(r).and_then(|n| n.parent).unwrap_or(table_idx), Some(r))
    } else if let Some(&last) = rows.last() {
        (it.dom.borrow().nodes.get(last).and_then(|n| n.parent).unwrap_or(table_idx), None)
    } else {
        (table_idx, None)
    };
    let new_row = it.dom.borrow_mut().create_element("tr");
    it.dom.borrow_mut().insert_before(parent, new_row, ref_child);
    Ok(Value::Object(Obj::dom(new_row)))
}
pub fn dom_table_delete_row(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(table_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let rows = it.dom.borrow().descendants_by_tags(table_idx, &["tr"]);
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // 仕様上 `deleteRow(index)` の有効範囲は `-1 <= index < rows.length`
    // （`-1`は末尾行の削除を意味する）で、範囲外は`IndexSizeError`を投げる
    // べきだが、以前は範囲外の値をすべて「末尾行を削除」として黙って受け
    // 入れてしまっていた（詳細は`insertRow`側の同種コメント参照）。
    if pos < -1 || pos >= rows.len() as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of rows represented by this table",
        ));
    }
    let target = if pos >= 0 {
        Some(rows[pos as usize])
    } else {
        rows.last().copied()
    };
    if let Some(r) = target {
        it.dom.borrow_mut().remove_node(r);
    }
    Ok(Value::Undefined)
}
pub fn dom_table_insert_cell(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(row_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let cells = it.dom.borrow().descendants_by_tags(row_idx, &["td", "th"]);
    let len = cells.len();
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // `insertRow`と同じ仕様上の有効範囲チェック（`-1 <= index <= cells.length`）。
    // 詳細はそちらの同種コメント参照。
    if pos < -1 || pos > len as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of cells represented by this row",
        ));
    }
    let ref_child = if pos >= 0 && (pos as usize) < len { Some(cells[pos as usize]) } else { None };
    let new_cell = it.dom.borrow_mut().create_element("td");
    it.dom.borrow_mut().insert_before(row_idx, new_cell, ref_child);
    Ok(Value::Object(Obj::dom(new_cell)))
}
pub fn dom_table_delete_cell(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(row_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let cells = it.dom.borrow().descendants_by_tags(row_idx, &["td", "th"]);
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // `deleteRow`と同じ仕様上の有効範囲チェック（`-1 <= index < cells.length`）。
    // 詳細はそちらの同種コメント参照。
    if pos < -1 || pos >= cells.len() as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of cells represented by this row",
        ));
    }
    let target = if pos >= 0 {
        Some(cells[pos as usize])
    } else {
        cells.last().copied()
    };
    if let Some(c) = target {
        it.dom.borrow_mut().remove_node(c);
    }
    Ok(Value::Undefined)
}

/// `table.createTHead()`/`.createTFoot()`/`.createCaption()`（丸ごと未対応
/// だった。2026-07-17 発見。仕様上「既存の該当要素があればそれを返す、
/// 無ければ新規作成して挿入する」冪等な動作）。直接の子のみを対象とする
/// （`tHead`/`tFoot`/`caption`ゲッターと同じ制約）。`caption`は最初の子、
/// `thead`は最初の子（`caption`の後）、`tfoot`は最後の子として挿入する
/// 簡略実装（`colgroup`との相対位置関係は厳密には対象外）。
fn table_create_section(it: &mut Interp, table_idx: usize, tag: &str, append: bool) -> Value {
    let existing = {
        let dom = it.dom.borrow();
        dom.nodes[table_idx].children.iter().find(|&&c| dom.nodes[c].tag == tag).copied()
    };
    if let Some(i) = existing {
        return Value::Object(Obj::dom(i));
    }
    let new_idx = it.dom.borrow_mut().create_element(tag);
    let ref_child = if append {
        None
    } else {
        it.dom.borrow().nodes[table_idx].children.first().copied()
    };
    it.dom.borrow_mut().insert_before(table_idx, new_idx, ref_child);
    Value::Object(Obj::dom(new_idx))
}
fn table_delete_section(it: &mut Interp, table_idx: usize, tag: &str) {
    let existing = {
        let dom = it.dom.borrow();
        dom.nodes[table_idx].children.iter().find(|&&c| dom.nodes[c].tag == tag).copied()
    };
    if let Some(i) = existing {
        it.dom.borrow_mut().remove_node(i);
    }
}
pub fn dom_table_create_thead(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(match this_dom_idx(&this) {
        Some(idx) => table_create_section(it, idx, "thead", false),
        None => Value::Undefined,
    })
}
pub fn dom_table_create_tfoot(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(match this_dom_idx(&this) {
        Some(idx) => table_create_section(it, idx, "tfoot", true),
        None => Value::Undefined,
    })
}
pub fn dom_table_create_caption(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(match this_dom_idx(&this) {
        Some(idx) => table_create_section(it, idx, "caption", false),
        None => Value::Undefined,
    })
}
pub fn dom_table_delete_thead(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        table_delete_section(it, idx, "thead");
    }
    Ok(Value::Undefined)
}
pub fn dom_table_delete_tfoot(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        table_delete_section(it, idx, "tfoot");
    }
    Ok(Value::Undefined)
}
pub fn dom_table_delete_caption(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        table_delete_section(it, idx, "caption");
    }
    Ok(Value::Undefined)
}

/// `img.decode()`（丸ごと未対応だった。2026-07-17 発見）。実デコード成否を
/// 追跡する経路が無いため、`complete`ゲッターと同じ「`src`があれば
/// ロード試行済み」前提で、`src`があれば解決・無ければ`DOMException
/// ("EncodingError")`で拒否するPromiseを返す簡略実装。
pub fn dom_img_decode(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let has_src = this_dom_idx(&this)
        .map(|idx| it.dom.borrow().get_attr(idx, "src").map(|s| !s.is_empty()).unwrap_or(false))
        .unwrap_or(false);
    if has_src {
        Ok(resolved_promise(it, Value::Undefined))
    } else {
        let reason = make_dom_exception("EncodingError", "The source image cannot be decoded");
        Ok(rejected_promise(it, reason))
    }
}

/// 現在の`.value`文字列を読む（`textarea`は`value`属性優先、無ければ
/// `initial_text`にフォールバック。`interp/dom_props.rs`の`value`
/// ゲッターと同じロジック）。
fn current_field_value(it: &Interp, idx: usize) -> String {
    let dom = it.dom.borrow();
    let tag = dom.nodes.get(idx).map(|n| n.tag.as_str()).unwrap_or("");
    if tag == "textarea" {
        dom.get_attr(idx, "_live_value")
            .or_else(|| dom.get_attr(idx, "value"))
            .unwrap_or_else(|| dom.nodes.get(idx).map(|n| n.initial_text.clone()).unwrap_or_default())
    } else {
        dom.get_attr(idx, "_live_value")
            .or_else(|| dom.get_attr(idx, "value"))
            .unwrap_or_default()
    }
}
/// `input`/`textarea.setSelectionRange(start, end, direction?)`（丸ごと
/// 未対応だった。`selectionStart`/`.selectionEnd`/`.selectionDirection`
/// と対になる一括設定メソッド。2026-07-17 発見・実装）。3プロパティへの
/// 個別代入と同じ内部専用属性へまとめて保存する簡略実装。
pub fn dom_set_selection_range(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let start = arg(a, 0).to_number();
        let end = arg(a, 1).to_number();
        let direction = if matches!(arg(a, 2), Value::Undefined) {
            String::from("none")
        } else {
            arg(a, 2).to_js_string()
        };
        let mut dom = it.dom.borrow_mut();
        dom.set_attr(idx, "_selection_start", &Value::Number(start).to_js_string());
        dom.set_attr(idx, "_selection_end", &Value::Number(end).to_js_string());
        dom.set_attr(idx, "_selection_direction", &direction);
    }
    Ok(Value::Undefined)
}
/// `input`/`textarea.setRangeText(replacement, start?, end?, selectMode?)`
/// （丸ごと未対応だった。2026-07-17 発見・実装）。`start`/`end`省略時は
/// 現在の`selectionStart`/`.selectionEnd`を使う（仕様どおり）。
/// `selectMode`は`"select"`（置換後の範囲を選択）/`"start"`（キャレットを
/// 置換範囲の先頭へ）/`"end"`（末尾へ、既定）/`"preserve"`（元の選択位置を
/// 維持しようと試みる）に対応する簡略実装。
pub fn dom_set_range_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let replacement = arg(a, 0).to_js_string();
        let chars: alloc::vec::Vec<char> = current_field_value(it, idx).chars().collect();
        let len = chars.len();
        let cur_start = it
            .dom
            .borrow()
            .get_attr(idx, "_selection_start")
            .and_then(|v| v.parse::<f64>().ok())
            .unwrap_or(0.0);
        let cur_end = it
            .dom
            .borrow()
            .get_attr(idx, "_selection_end")
            .and_then(|v| v.parse::<f64>().ok())
            .unwrap_or(0.0);
        let start = if matches!(arg(a, 1), Value::Undefined) { cur_start } else { arg(a, 1).to_number() };
        let end = if matches!(arg(a, 2), Value::Undefined) { cur_end } else { arg(a, 2).to_number() };
        let start = (start.max(0.0) as usize).min(len);
        let end = (end.max(0.0) as usize).min(len).max(start);
        let select_mode = if matches!(arg(a, 3), Value::Undefined) { String::from("preserve") } else { arg(a, 3).to_js_string() };
        let new_value: String =
            chars[..start].iter().chain(replacement.chars().collect::<alloc::vec::Vec<_>>().iter()).chain(chars[end..].iter()).collect();
        let new_end = start + replacement.chars().count();
        let (sel_start, sel_end) = match select_mode.as_str() {
            "select" => (start, new_end),
            "start" => (start, start),
            "end" => (new_end, new_end),
            _ => (start, new_end), // "preserve" は簡略実装として置換範囲を返す
        };
        let mut dom = it.dom.borrow_mut();
        dom.set_attr(idx, "_live_value", &new_value);
        dom.set_attr(idx, "_selection_start", &Value::Number(sel_start as f64).to_js_string());
        dom.set_attr(idx, "_selection_end", &Value::Number(sel_end as f64).to_js_string());
    }
    Ok(Value::Undefined)
}
/// `node.isSameNode(other)`（丸ごと未対応だった。DOM 標準の参照同一性判定。`===` と
/// 同義だが、DOM ノードを扱うライブラリで明示的に使われる定番メソッド）。
pub fn dom_is_same_node(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let self_idx = this_dom_idx(&this);
    let other_idx = this_dom_idx(&arg(a, 0));
    Ok(Value::Bool(self_idx.is_some() && self_idx == other_idx))
}
/// `node.isEqualNode(other)`（丸ごと未対応だった。参照ではなく構造的な等価性
/// — タグ名/属性/子要素が全て一致するか — を見る DOM 標準メソッド）。既存の
/// `outerHTML` シリアライズを再利用し、文字列として一致するかで近似する
/// （属性は `BTreeMap` 由来で常に同じ順序にシリアライズされるため、挿入順序に
/// 依存しない安定した比較になる）。
pub fn dom_is_equal_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let self_idx = this_dom_idx(&this);
    let other_idx = this_dom_idx(&arg(a, 0));
    match (self_idx, other_idx) {
        (Some(ai), Some(bi)) => {
            let dom = it.dom.borrow();
            Ok(Value::Bool(dom.get_outer_html(ai) == dom.get_outer_html(bi)))
        }
        _ => Ok(Value::Bool(false)),
    }
}

/// element.getBoundingClientRect(): レイアウト後の矩形（DomBridge.rects、ページ座標）から
/// DOMRect 風オブジェクト {x,left,y,top,width,height,right,bottom} を返す。未登録なら 0。
/// `element.setPointerCapture(pointerId)`（Pointer Events。丸ごと未対応
/// だった。ドラッグ操作で `el.setPointerCapture(e.pointerId)` する定番
/// パターン）。
pub fn dom_set_pointer_capture(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom.borrow_mut().set_pointer_capture(idx, arg(a, 0).to_number() as i32);
    }
    Ok(Value::Undefined)
}
/// `element.releasePointerCapture(pointerId)`。
pub fn dom_release_pointer_capture(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom
            .borrow_mut()
            .release_pointer_capture(idx, arg(a, 0).to_number() as i32);
    }
    Ok(Value::Undefined)
}
/// `element.hasPointerCapture(pointerId)`。
pub fn dom_has_pointer_capture(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let has = this_dom_idx(&this)
        .map(|idx| it.dom.borrow().has_pointer_capture(idx, arg(a, 0).to_number() as i32))
        .unwrap_or(false);
    Ok(Value::Bool(has))
}

/// `(x,y,w,h)` から `DOMRect` 相当のプレーンオブジェクトを組み立てる。
/// `getBoundingClientRect`/`getClientRects` で共有する。
/// `new DOMRect(x, y, width, height)`（丸ごと未対応だった。手動で矩形を
/// 構築する定番パターン。2026-07-17 発見）。`getBoundingClientRect()`が
/// 返す`make_dom_rect`と同じプロパティ形状（`x`/`y`/`left`/`top`/
/// `width`/`height`/`right`/`bottom`）だが、引数は整数丸め無しの浮動小数
/// 点のまま保持する（手動構築ではサブピクセル値も仕様上有効なため）。
/// `DOMRectReadOnly`も同じ形状のため区別せず同一コンストラクタで代用する
/// 簡略実装（`fromRect`静的メソッド・書き込み可能プロパティの違いは
/// 対象外）。
pub(crate) fn dom_rect_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let w = arg(a, 2).to_number();
    let h = arg(a, 3).to_number();
    let x = if x.is_nan() { 0.0 } else { x };
    let y = if y.is_nan() { 0.0 } else { y };
    let w = if w.is_nan() { 0.0 } else { w };
    let h = if h.is_nan() { 0.0 } else { h };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("x".into(), Value::Number(x));
        b.props.insert("left".into(), Value::Number(x));
        b.props.insert("y".into(), Value::Number(y));
        b.props.insert("top".into(), Value::Number(y));
        b.props.insert("width".into(), Value::Number(w));
        b.props.insert("height".into(), Value::Number(h));
        b.props.insert("right".into(), Value::Number(x + w));
        b.props.insert("bottom".into(), Value::Number(y + h));
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}
fn get_num_prop(it: &mut Interp, val: &Value, name: &str, default: f64) -> f64 {
    it.get_property(val, name).map(|v| v.to_number()).unwrap_or(default)
}

pub fn dom_point_matrix_transform(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let px = get_num_prop(it, &this, "x", 0.0);
    let py = get_num_prop(it, &this, "y", 0.0);
    let pz = get_num_prop(it, &this, "z", 0.0);
    let pw = get_num_prop(it, &this, "w", 1.0);
    let m = arg(a, 0);

    let def_a = get_num_prop(it, &m, "a", 1.0);
    let m11 = get_num_prop(it, &m, "m11", def_a);
    let def_b = get_num_prop(it, &m, "b", 0.0);
    let m12 = get_num_prop(it, &m, "m12", def_b);
    let m13 = get_num_prop(it, &m, "m13", 0.0);
    let m14 = get_num_prop(it, &m, "m14", 0.0);

    let def_c = get_num_prop(it, &m, "c", 0.0);
    let m21 = get_num_prop(it, &m, "m21", def_c);
    let def_d = get_num_prop(it, &m, "d", 1.0);
    let m22 = get_num_prop(it, &m, "m22", def_d);
    let m23 = get_num_prop(it, &m, "m23", 0.0);
    let m24 = get_num_prop(it, &m, "m24", 0.0);

    let m31 = get_num_prop(it, &m, "m31", 0.0);
    let m32 = get_num_prop(it, &m, "m32", 0.0);
    let m33 = get_num_prop(it, &m, "m33", 1.0);
    let m34 = get_num_prop(it, &m, "m34", 0.0);

    let def_e = get_num_prop(it, &m, "e", 0.0);
    let m41 = get_num_prop(it, &m, "m41", def_e);
    let def_f = get_num_prop(it, &m, "f", 0.0);
    let m42 = get_num_prop(it, &m, "m42", def_f);
    let m43 = get_num_prop(it, &m, "m43", 0.0);
    let m44 = get_num_prop(it, &m, "m44", 1.0);

    let nx = m11 * px + m21 * py + m31 * pz + m41 * pw;
    let ny = m12 * px + m22 * py + m32 * pz + m42 * pw;
    let nz = m13 * px + m23 * py + m33 * pz + m43 * pw;
    let nw = m14 * px + m24 * py + m34 * pz + m44 * pw;
    dom_point_ctor(it, Value::Undefined, &[Value::Number(nx), Value::Number(ny), Value::Number(nz), Value::Number(nw)])
}

/// `new DOMPoint(x, y, z, w)`（幾何形体プリミティブ。2026-07-17 発見、2026-07-21 拡張）。
/// 仕様どおり `z`/`w` 省略時の既定値はそれぞれ `0`/`1`。`DOMPointReadOnly` も同形状で代用。
/// `matrixTransform(matrix)` で `DOMMatrix` による座標変換に対応。
pub(crate) fn dom_point_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let z = arg(a, 2).to_number();
    let w = arg(a, 3).to_number();
    let x = if x.is_nan() { 0.0 } else { x };
    let y = if y.is_nan() { 0.0 } else { y };
    let z = if z.is_nan() { 0.0 } else { z };
    let w = if matches!(arg(a, 3), Value::Undefined) || w.is_nan() { 1.0 } else { w };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("x".into(), Value::Number(x));
        b.props.insert("y".into(), Value::Number(y));
        b.props.insert("z".into(), Value::Number(z));
        b.props.insert("w".into(), Value::Number(w));
        b.props.insert(
            "matrixTransform".into(),
            nv("matrixTransform", dom_point_matrix_transform),
        );
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" && k != "matrixTransform" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}

pub(crate) fn dom_rect_from_rect(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let r = arg(a, 0);
    let x = get_num_prop(it, &r, "x", 0.0);
    let y = get_num_prop(it, &r, "y", 0.0);
    let w = get_num_prop(it, &r, "width", 0.0);
    let h = get_num_prop(it, &r, "height", 0.0);
    dom_rect_ctor(it, Value::Undefined, &[Value::Number(x), Value::Number(y), Value::Number(w), Value::Number(h)])
}

pub(crate) fn dom_point_from_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let p = arg(a, 0);
    let x = get_num_prop(it, &p, "x", 0.0);
    let y = get_num_prop(it, &p, "y", 0.0);
    let z = get_num_prop(it, &p, "z", 0.0);
    let w = get_num_prop(it, &p, "w", 1.0);
    dom_point_ctor(it, Value::Undefined, &[Value::Number(x), Value::Number(y), Value::Number(z), Value::Number(w)])
}

pub fn dom_matrix_to_string(it: &mut Interp, this: Value, _: &[Value]) -> Result<Value, Value> {
    let is_2d = it.get_property(&this, "is2D").map(|v| v.truthy()).unwrap_or(true);
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m13 = get_num_prop(it, &this, "m13", 0.0);
    let m14 = get_num_prop(it, &this, "m14", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m23 = get_num_prop(it, &this, "m23", 0.0);
    let m24 = get_num_prop(it, &this, "m24", 0.0);
    let m31 = get_num_prop(it, &this, "m31", 0.0);
    let m32 = get_num_prop(it, &this, "m32", 0.0);
    let m33 = get_num_prop(it, &this, "m33", 1.0);
    let m34 = get_num_prop(it, &this, "m34", 0.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);
    let m43 = get_num_prop(it, &this, "m43", 0.0);
    let m44 = get_num_prop(it, &this, "m44", 1.0);
    if is_2d {
        Ok(Value::str(alloc::format!("matrix({}, {}, {}, {}, {}, {})", m11, m12, m21, m22, m41, m42)))
    } else {
        Ok(Value::str(alloc::format!(
            "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
            m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44
        )))
    }
}

pub fn dom_matrix_multiply(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let other = arg(a, 0);
    let om11 = get_num_prop(it, &other, "m11", 1.0);
    let om12 = get_num_prop(it, &other, "m12", 0.0);
    let om21 = get_num_prop(it, &other, "m21", 0.0);
    let om22 = get_num_prop(it, &other, "m22", 1.0);
    let om41 = get_num_prop(it, &other, "m41", 0.0);
    let om42 = get_num_prop(it, &other, "m42", 0.0);

    let res_a = m11 * om11 + m21 * om12;
    let res_b = m12 * om11 + m22 * om12;
    let res_c = m11 * om21 + m21 * om22;
    let res_d = m12 * om21 + m22 * om22;
    let res_e = m11 * om41 + m21 * om42 + m41;
    let res_f = m12 * om41 + m22 * om42 + m42;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(res_a), Value::Number(res_b),
        Value::Number(res_c), Value::Number(res_d),
        Value::Number(res_e), Value::Number(res_f)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_translate(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let tx = arg(a, 0).to_number();
    let ty = arg(a, 1).to_number();
    let tx = if tx.is_nan() { 0.0 } else { tx };
    let ty = if ty.is_nan() { 0.0 } else { ty };

    let res_e = m11 * tx + m21 * ty + m41;
    let res_f = m12 * tx + m22 * ty + m42;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(m11), Value::Number(m12),
        Value::Number(m21), Value::Number(m22),
        Value::Number(res_e), Value::Number(res_f)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_scale(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let sx = arg(a, 0).to_number();
    let sy = arg(a, 1).to_number();
    let sx = if sx.is_nan() { 1.0 } else { sx };
    let sy = if matches!(arg(a, 1), Value::Undefined) || sy.is_nan() { sx } else { sy };

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(m11 * sx), Value::Number(m12 * sx),
        Value::Number(m21 * sy), Value::Number(m22 * sy),
        Value::Number(m41), Value::Number(m42)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_rotate(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let angle_deg = arg(a, 0).to_number();
    let angle_deg = if angle_deg.is_nan() { 0.0 } else { angle_deg };
    let rad = angle_deg * core::f64::consts::PI / 180.0;
    let cos_a = libm::cos(rad);
    let sin_a = libm::sin(rad);

    let res_a = m11 * cos_a + m21 * sin_a;
    let res_b = m12 * cos_a + m22 * sin_a;
    let res_c = m11 * (-sin_a) + m21 * cos_a;
    let res_d = m12 * (-sin_a) + m22 * cos_a;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(res_a), Value::Number(res_b),
        Value::Number(res_c), Value::Number(res_d),
        Value::Number(m41), Value::Number(m42)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_invert(it: &mut Interp, this: Value, _: &[Value]) -> Result<Value, Value> {
    let a = get_num_prop(it, &this, "m11", 1.0);
    let b = get_num_prop(it, &this, "m12", 0.0);
    let c = get_num_prop(it, &this, "m21", 0.0);
    let d = get_num_prop(it, &this, "m22", 1.0);
    let e = get_num_prop(it, &this, "m41", 0.0);
    let f = get_num_prop(it, &this, "m42", 0.0);

    let det = a * d - b * c;
    if det == 0.0 || det.is_nan() {
        let arr = Value::Object(Obj::array(alloc::vec![
            Value::Number(f64::NAN), Value::Number(f64::NAN),
            Value::Number(f64::NAN), Value::Number(f64::NAN),
            Value::Number(f64::NAN), Value::Number(f64::NAN)
        ]));
        return dom_matrix_ctor(it, Value::Undefined, &[arr]);
    }
    let inv_a = d / det;
    let inv_b = -b / det;
    let inv_c = -c / det;
    let inv_d = a / det;
    let inv_e = (c * f - d * e) / det;
    let inv_f = (b * e - a * f) / det;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(inv_a), Value::Number(inv_b),
        Value::Number(inv_c), Value::Number(inv_d),
        Value::Number(inv_e), Value::Number(inv_f)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

fn update_matrix_props(target: &Value, new_m: Value) {
    if let (Value::Object(to), Value::Object(from)) = (target, &new_m) {
        let from_props = from.borrow().props.clone();
        let mut b = to.borrow_mut();
        for (k, v) in from_props {
            if k != "toJSON" && k != "toString" && k != "multiply" && k != "translate" && k != "scale" && k != "rotate" && k != "invert"
                && k != "multiplySelf" && k != "translateSelf" && k != "scaleSelf" && k != "rotateSelf" && k != "invertSelf" {
                b.props.insert(k, v);
            }
        }
    }
}

pub fn dom_matrix_translate_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_translate(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_scale_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_scale(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_rotate_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_rotate(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_multiply_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_multiply(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_invert_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_invert(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_skew_x(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let deg = arg(a, 0).to_number();
    let rad = deg * core::f64::consts::PI / 180.0;
    let tan_val = libm::tan(rad);
    let skew_m = dom_matrix_ctor(
        it,
        Value::Undefined,
        &[
            Value::Number(1.0),
            Value::Number(0.0),
            Value::Number(tan_val),
            Value::Number(1.0),
            Value::Number(0.0),
            Value::Number(0.0),
        ],
    )?;
    dom_matrix_multiply(it, this, &[skew_m])
}

pub fn dom_matrix_skew_y(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let deg = arg(a, 0).to_number();
    let rad = deg * core::f64::consts::PI / 180.0;
    let tan_val = libm::tan(rad);
    let skew_m = dom_matrix_ctor(
        it,
        Value::Undefined,
        &[
            Value::Number(1.0),
            Value::Number(tan_val),
            Value::Number(0.0),
            Value::Number(1.0),
            Value::Number(0.0),
            Value::Number(0.0),
        ],
    )?;
    dom_matrix_multiply(it, this, &[skew_m])
}

pub fn dom_matrix_skew_x_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_skew_x(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_skew_y_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_skew_y(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_transform_point(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let pt = arg(a, 0);
    dom_point_matrix_transform(it, pt, &[this])
}

/// `new DOMMatrix([init])` / `DOMMatrixReadOnly` (Geometry Interfaces Module Level 1)
/// 2D / 3D 変換行列コンストラクタ。
pub(crate) fn dom_matrix_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut m11 = 1.0; let mut m12 = 0.0; let mut m13 = 0.0; let mut m14 = 0.0;
    let mut m21 = 0.0; let mut m22 = 1.0; let mut m23 = 0.0; let mut m24 = 0.0;
    let mut m31 = 0.0; let mut m32 = 0.0; let mut m33 = 1.0; let mut m34 = 0.0;
    let mut m41 = 0.0; let mut m42 = 0.0; let mut m43 = 0.0; let mut m44 = 1.0;

    let init = arg(a, 0);
    if let Value::Object(o) = &init {
        // `DOMMatrixInit`は仕様上「数値6/16個のシーケンス（配列/TypedArray、この
        // エンジンではどちらも`ObjKind::Array`）」か「`{a,b,c,d,e,f,...}`形式の
        // 平オブジェクト」のいずれか。以前は非配列オブジェクトも`it.iterate_values`
        // へ通していたが、この関数はプレーンオブジェクトに対しても（`Symbol.
        // iterator`を持たないにも関わらず）自身の列挙可能プロパティ値をそのまま
        // 返す簡略実装のため、`{a:2,d:3,e:5,f:10}`（4値）のような非配列dictでも
        // 空でないVecが返ってしまい、`arr.len()>=16`/`>=6`のどちらにも該当せず
        // 何も設定されないまま、本来読むべき`.a`/`.b`/`.c`/`.d`/`.e`/`.f`
        // プロパティ読み取りのelseブランチへ一切到達できないバグだった
        // （`DOMMatrix.fromMatrix({...})`が常に単位行列のまま返る）。
        // `ObjKind::Array`（TypedArrayもこの表現を流用）のときのみ数値シーケンス
        // として扱い、それ以外は無条件でプロパティ読み取り側へ回す。
        // 【2026-07-23続報】この修正自体だけでは`m2.a`/`m2.e`が期待値にならない
        // ことが判明しており、原因はこの関数の別の箇所（`.a`/`.e`プロパティの
        // 最終露出ロジック）に残っている可能性が高い。ロジックとしては正しい
        // 改善のため残すが、根本解決は未完了として記録する。
        let vals_opt = if let crate::os_lib::js::value::ObjKind::Array(ref arr) = o.borrow().kind {
            Some(arr.clone())
        } else {
            None
        };
        if let Some(arr) = vals_opt {
            if arr.len() >= 16 {
                m11 = arr[0].to_number(); m12 = arr[1].to_number(); m13 = arr[2].to_number(); m14 = arr[3].to_number();
                m21 = arr[4].to_number(); m22 = arr[5].to_number(); m23 = arr[6].to_number(); m24 = arr[7].to_number();
                m31 = arr[8].to_number(); m32 = arr[9].to_number(); m33 = arr[10].to_number(); m34 = arr[11].to_number();
                m41 = arr[12].to_number(); m42 = arr[13].to_number(); m43 = arr[14].to_number(); m44 = arr[15].to_number();
            } else if arr.len() >= 6 {
                m11 = arr[0].to_number(); m12 = arr[1].to_number();
                m21 = arr[2].to_number(); m22 = arr[3].to_number();
                m41 = arr[4].to_number(); m42 = arr[5].to_number();
            }
        } else {
            if let Ok(v) = it.get_property(&init, "a") { if !matches!(v, Value::Undefined) { m11 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "b") { if !matches!(v, Value::Undefined) { m12 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "c") { if !matches!(v, Value::Undefined) { m21 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "d") { if !matches!(v, Value::Undefined) { m22 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "e") { if !matches!(v, Value::Undefined) { m41 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "f") { if !matches!(v, Value::Undefined) { m42 = v.to_number(); } }

            if let Ok(v) = it.get_property(&init, "m11") { if !matches!(v, Value::Undefined) { m11 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m12") { if !matches!(v, Value::Undefined) { m12 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m13") { if !matches!(v, Value::Undefined) { m13 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m14") { if !matches!(v, Value::Undefined) { m14 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m21") { if !matches!(v, Value::Undefined) { m21 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m22") { if !matches!(v, Value::Undefined) { m22 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m23") { if !matches!(v, Value::Undefined) { m23 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m24") { if !matches!(v, Value::Undefined) { m24 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m31") { if !matches!(v, Value::Undefined) { m31 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m32") { if !matches!(v, Value::Undefined) { m32 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m33") { if !matches!(v, Value::Undefined) { m33 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m34") { if !matches!(v, Value::Undefined) { m34 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m41") { if !matches!(v, Value::Undefined) { m41 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m42") { if !matches!(v, Value::Undefined) { m42 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m43") { if !matches!(v, Value::Undefined) { m43 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m44") { if !matches!(v, Value::Undefined) { m44 = v.to_number(); } }
        }
    }

    let is_2d = m13 == 0.0 && m14 == 0.0 && m23 == 0.0 && m24 == 0.0 && m31 == 0.0 && m32 == 0.0 && m33 == 1.0 && m34 == 0.0 && m43 == 0.0;
    let is_identity = m11 == 1.0 && m12 == 0.0 && m13 == 0.0 && m14 == 0.0
        && m21 == 0.0 && m22 == 1.0 && m23 == 0.0 && m24 == 0.0
        && m31 == 0.0 && m32 == 0.0 && m33 == 1.0 && m34 == 0.0
        && m41 == 0.0 && m42 == 0.0 && m43 == 0.0 && m44 == 1.0;

    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("a".into(), Value::Number(m11));
        b.props.insert("b".into(), Value::Number(m12));
        b.props.insert("c".into(), Value::Number(m21));
        b.props.insert("d".into(), Value::Number(m22));
        b.props.insert("e".into(), Value::Number(m41));
        b.props.insert("f".into(), Value::Number(m42));

        b.props.insert("m11".into(), Value::Number(m11));
        b.props.insert("m12".into(), Value::Number(m12));
        b.props.insert("m13".into(), Value::Number(m13));
        b.props.insert("m14".into(), Value::Number(m14));
        b.props.insert("m21".into(), Value::Number(m21));
        b.props.insert("m22".into(), Value::Number(m22));
        b.props.insert("m23".into(), Value::Number(m23));
        b.props.insert("m24".into(), Value::Number(m24));
        b.props.insert("m31".into(), Value::Number(m31));
        b.props.insert("m32".into(), Value::Number(m32));
        b.props.insert("m33".into(), Value::Number(m33));
        b.props.insert("m34".into(), Value::Number(m34));
        b.props.insert("m41".into(), Value::Number(m41));
        b.props.insert("m42".into(), Value::Number(m42));
        b.props.insert("m43".into(), Value::Number(m43));
        b.props.insert("m44".into(), Value::Number(m44));

        b.props.insert("is2D".into(), Value::Bool(is_2d));
        b.props.insert("isIdentity".into(), Value::Bool(is_identity));

        b.props.insert("toString".into(), nv("toString", dom_matrix_to_string));
        b.props.insert("multiply".into(), nv("multiply", dom_matrix_multiply));
        b.props.insert("translate".into(), nv("translate", dom_matrix_translate));
        b.props.insert("scale".into(), nv("scale", dom_matrix_scale));
        b.props.insert("rotate".into(), nv("rotate", dom_matrix_rotate));
        b.props.insert("skewX".into(), nv("skewX", dom_matrix_skew_x));
        b.props.insert("skewY".into(), nv("skewY", dom_matrix_skew_y));
        b.props.insert("invert".into(), nv("invert", dom_matrix_invert));

        b.props.insert("multiplySelf".into(), nv("multiplySelf", dom_matrix_multiply_self));
        b.props.insert("translateSelf".into(), nv("translateSelf", dom_matrix_translate_self));
        b.props.insert("scaleSelf".into(), nv("scaleSelf", dom_matrix_scale_self));
        b.props.insert("rotateSelf".into(), nv("rotateSelf", dom_matrix_rotate_self));
        b.props.insert("skewXSelf".into(), nv("skewXSelf", dom_matrix_skew_x_self));
        b.props.insert("skewYSelf".into(), nv("skewYSelf", dom_matrix_skew_y_self));
        b.props.insert("invertSelf".into(), nv("invertSelf", dom_matrix_invert_self));

        b.props.insert("transformPoint".into(), nv("transformPoint", dom_matrix_transform_point));
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" && k != "toString" && k != "multiply" && k != "translate" && k != "scale" && k != "rotate" && k != "invert"
                            && k != "multiplySelf" && k != "translateSelf" && k != "scaleSelf" && k != "rotateSelf" && k != "invertSelf"
                            && k != "skewX" && k != "skewY" && k != "skewXSelf" && k != "skewYSelf" && k != "transformPoint" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}

pub fn dom_quad_get_bounds(it: &mut Interp, this: Value, _: &[Value]) -> Result<Value, Value> {
    let p1 = it.get_property(&this, "p1").unwrap_or(Value::Undefined);
    let p2 = it.get_property(&this, "p2").unwrap_or(Value::Undefined);
    let p3 = it.get_property(&this, "p3").unwrap_or(Value::Undefined);
    let p4 = it.get_property(&this, "p4").unwrap_or(Value::Undefined);

    let x1 = get_num_prop(it, &p1, "x", 0.0);
    let y1 = get_num_prop(it, &p1, "y", 0.0);
    let x2 = get_num_prop(it, &p2, "x", 0.0);
    let y2 = get_num_prop(it, &p2, "y", 0.0);
    let x3 = get_num_prop(it, &p3, "x", 0.0);
    let y3 = get_num_prop(it, &p3, "y", 0.0);
    let x4 = get_num_prop(it, &p4, "x", 0.0);
    let y4 = get_num_prop(it, &p4, "y", 0.0);

    let min_x = x1.min(x2).min(x3).min(x4);
    let max_x = x1.max(x2).max(x3).max(x4);
    let min_y = y1.min(y2).min(y3).min(y4);
    let max_y = y1.max(y2).max(y3).max(y4);

    let w = (max_x - min_x).max(0.0) as i32;
    let h = (max_y - min_y).max(0.0) as i32;
    Ok(Value::Object(make_dom_rect(min_x as i32, min_y as i32, w, h)))
}



/// `new DOMQuad(p1, p2, p3, p4)` (Geometry Interfaces Module Level 1)
pub(crate) fn dom_quad_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let p1 = if matches!(arg(a, 0), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 0) };
    let p2 = if matches!(arg(a, 1), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 1) };
    let p3 = if matches!(arg(a, 2), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 2) };
    let p4 = if matches!(arg(a, 3), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 3) };

    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("p1".into(), p1.clone());
        b.props.insert("p2".into(), p2.clone());
        b.props.insert("p3".into(), p3.clone());
        b.props.insert("p4".into(), p4.clone());

        b.props.insert("getBounds".into(), nv("getBounds", dom_quad_get_bounds));
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" && k != "getBounds" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}
pub(crate) fn make_dom_rect(x: i32, y: i32, w: i32, h: i32) -> ObjRef {
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("x".into(), Value::Number(x as f64));
        b.props.insert("left".into(), Value::Number(x as f64));
        b.props.insert("y".into(), Value::Number(y as f64));
        b.props.insert("top".into(), Value::Number(y as f64));
        b.props.insert("width".into(), Value::Number(w as f64));
        b.props.insert("height".into(), Value::Number(h as f64));
        b.props
            .insert("right".into(), Value::Number((x + w) as f64));
        b.props
            .insert("bottom".into(), Value::Number((y + h) as f64));
    }
    o
}

pub fn dom_get_bounding_client_rect(
    it: &mut Interp,
    this: Value,
    _a: &[Value],
) -> Result<Value, Value> {
    let (x, y, w, h) = this_dom_idx(&this)
        .and_then(|idx| it.dom.borrow().get_rect(idx))
        .unwrap_or((0, 0, 0, 0));
    Ok(Value::Object(make_dom_rect(x, y, w, h)))
}

/// `element.getClientRects()`（DOM 標準。丸ごと未対応だった。本来は行ボックス
/// 単位で複数の `DOMRect` を返すが、この処理系にはテキストの行フラグメント
/// モデル自体が無い（`text-overflow`/インライン折返し等と同じ既存の簡略化と
/// 同方針）ため、要素1つにつき `getBoundingClientRect()` と同じ矩形を0個
/// （未レンダリング）か1個だけ持つ配列として返す）。
pub fn dom_get_client_rects(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let rect = this_dom_idx(&this).and_then(|idx| it.dom.borrow().get_rect(idx));
    let items = match rect {
        Some((x, y, w, h)) => alloc::vec![Value::Object(make_dom_rect(x, y, w, h))],
        None => Vec::new(),
    };
    Ok(Value::Object(Obj::array(items)))
}

/// getComputedStyle(el): 算出スタイルを読む host プロキシ `computed:idx` を返す。
pub(crate) fn get_computed_style(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    match this_dom_idx(&arg(a, 0)) {
        Some(idx) => Ok(Value::Object(Obj::host(&format!("computed:{}", idx)))),
        None => Ok(Value::Object(Obj::host("computed:18446744073709551615"))), // 無効idx
    }
}

/// computedStyle.getPropertyValue(name): kebab-case のプロパティ値を返す。
pub fn computed_get_property_value(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "computed:") {
        let prop = arg(a, 0).to_js_string();
        return Ok(Value::str(it.dom.borrow().get_computed(idx, &prop)));
    }
    Ok(Value::str(""))
}

pub fn dom_matches(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        // `:scope`（丸ごと未対応だった）。`el.matches()` における `:scope` は
        // 呼び出し元の要素自身を指す。
        return Ok(Value::Bool(it.dom.borrow().node_matches_scoped(idx, &sel, Some(idx))));
    }
    Ok(Value::Bool(false))
}

/// closest(selector): 自身を含め祖先方向へ最初にマッチする要素。無ければ null。
pub fn dom_closest(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(start) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        let mut cur = Some(start);
        let mut guard = 0;
        while let Some(c) = cur {
            // `:scope`（丸ごと未対応だった）。`el.closest()` における `:scope` は
            // 探索中の祖先ではなく、呼び出し元の起点要素（`start`）を指す。
            if dom.node_matches_scoped(c, &sel, Some(start)) {
                return Ok(dom_handle(Some(c)));
            }
            cur = dom.nodes.get(c).and_then(|n| n.parent);
            guard += 1;
            if guard > dom.nodes.len() {
                break;
            }
        }
    }
    Ok(Value::Null)
}

/// element.querySelector: 子孫に限定して最初にマッチする要素。`:scope`
/// （Selectors Level 4。丸ごと未対応だった）は呼び出し元の要素自身を指す。
pub fn dom_element_query_selector(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        for c in dom.query_all_scoped(&sel, Some(idx)) {
            if dom.is_ancestor_of(idx, c) {
                return Ok(dom_handle(Some(c)));
            }
        }
    }
    Ok(Value::Null)
}

/// element.querySelectorAll: 子孫に限定してマッチする要素配列。`:scope`
/// （Selectors Level 4。丸ごと未対応だった）は呼び出し元の要素自身を指す。
pub fn dom_element_query_selector_all(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        for c in dom.query_all_scoped(&sel, Some(idx)) {
            if dom.is_ancestor_of(idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
    }
    Ok(Value::Object(Obj::array(items)))
}

/// `element.getElementsByClassName(name)`（`document.getElementsByClassName` は
/// 対応済みだったが、要素インスタンス版が丸ごと未対応だった。`querySelectorAll` と
/// 同じ「自身の子孫のみに絞り込む」ロジックを再利用する）。
pub fn dom_element_get_elements_by_class_name(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let raw = arg(a, 0).to_js_string();
        let sel_classes: Vec<String> = raw
            .split_whitespace()
            .map(|c| alloc::format!(".{}", c))
            .collect();
        let sel = if sel_classes.is_empty() {
            alloc::format!(".__invalid_class__")
        } else {
            sel_classes.concat()
        };
        let dom = it.dom.borrow();
        for c in dom.query_all(&sel) {
            if dom.is_ancestor_of(idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
    }
    Ok(Value::Object(Obj::array(items)))
}
/// `element.getElementsByTagName(tag)`（上記と同じ理由で丸ごと未対応だった）。
pub fn dom_element_get_elements_by_tag_name(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let tag = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        // 【2026-09-05 バグ修正】以前は文書全体を `query_all` で引いてから
        // 先祖関係で絞っていた。`query_all` は**文書に繋がっていないノードを
        // 除外する**ので、切り離した要素の子孫が一切返らなかった。
        // 仕様では接続の有無に関係なく自分の子孫を返す。詳細は
        // `dom_bridge::descendants_by_tag_name` の説明。
        for c in dom.descendants_by_tag_name(idx, &tag) {
            items.push(Value::Object(Obj::dom(c)));
        }
    }
    Ok(Value::Object(Obj::array(items)))
}
/// `element.getElementsByTagNameNS(namespace, localName)`（丸ごと未対応だった）。
pub fn dom_element_get_elements_by_tag_name_ns(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let tag = if a.len() >= 2 {
            arg(a, 1).to_js_string()
        } else {
            arg(a, 0).to_js_string()
        };
        let dom = it.dom.borrow();
        for c in dom.query_all(&tag) {
            if dom.is_ancestor_of(idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
    }
    Ok(Value::Object(Obj::array(items)))
}

pub fn dom_set_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        let val = arg(a, 1).to_js_string();
        it.dom.borrow_mut().set_attr(idx, &name, &val);
    }
    Ok(Value::Undefined)
}

/// element.checkValidity() / reportValidity(): 現在値で制約バリデーションを実行し、
/// 妥当なら true、違反があれば false を返す。
/// （invalid イベントはフォーム送信経路 submit_form 側で WebEngine が発火する。
///  Interp からは DOM イベント発火経路が無いため、ここでは bool 判定のみ。）
/// **重要**: `<form>` 自身に対する `checkValidity()` が、フォームの子孫コントロール
/// を一切見ず `validate_field(form_idx, ...)` を直接呼んでいたため、`<form>` タグは
/// `type` が email/url/number のいずれにも一致せず常に無条件で `true`（妥当）を
/// 返してしまうバグだった（`WebEngine::submit_form` 側は `descendants_by_tags` で
/// 子孫を正しく走査していたのに、JS から呼ぶ `checkValidity()` だけが非対称だった）。
pub fn dom_check_validity(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let tag = it.dom.borrow().nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        if tag == "form" {
            let dom = it.dom.borrow();
            // `form_associated_controls`は子孫に加え、`form="このformのid"`属性で
            // フォーム外から明示的に関連付けられたコントロール（HTML5仕様の
            // 「form owner」）も含む。以前は`descendants_by_tags`（子孫のみ）
            // だったため、`<form>`の外に置かれた`<input form="...">`が
            // `checkValidity()`の対象から漏れる兄弟ギャップだった。
            let fields = dom.form_associated_controls(idx, &["input", "textarea", "select"]);
            let all_valid = fields.iter().all(|&node| {
                let value = dom.effective_form_value(node);
                dom.validate_field(node, &value).is_none()
            });
            return Ok(Value::Bool(all_valid));
        }
        let value = it.dom.borrow().effective_form_value(idx);
        let valid = it.dom.borrow().validate_field(idx, &value).is_none();
        return Ok(Value::Bool(valid));
    }
    Ok(Value::Bool(true))
}

/// element.setCustomValidity(msg): カスタム検証メッセージを設定。空文字でクリア。
/// 内部的には隠し属性 `_custom_validity` に保存し、validate_field が最優先で参照する。
pub fn dom_set_custom_validity(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let msg = arg(a, 0).to_js_string();
        if msg.is_empty() {
            it.dom.borrow_mut().remove_attr(idx, "_custom_validity");
        } else {
            it.dom.borrow_mut().set_attr(idx, "_custom_validity", &msg);
        }
    }
    Ok(Value::Undefined)
}

/// `classList.forEach(fn)`（丸ごと未対応だった。`DOMTokenList` は仕様上イテラブル/
/// `forEach` を持つ配列風のオブジェクトだが、この処理系の `classList` は専用の
/// `Host("classList:N")` プロキシで表現されており、`Symbol.iterator`/`forEach` が
/// 一切配線されていなかった。`for (const c of el.classList)` も同じ理由で常に
/// 何も反復しない黙殺バグだった — `iterate_values()` 側の修正と対）。
pub fn dom_classlist_for_each(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let classes = it.dom.borrow().nodes.get(idx).map(|n| n.classes.clone()).unwrap_or_default();
        let cb = arg(a, 0);
        for (i, c) in classes.into_iter().enumerate() {
            it.call_value(&cb, Value::Undefined, &[Value::str(c), Value::Number(i as f64)])?;
        }
    }
    Ok(Value::Undefined)
}
pub fn dom_classlist_add(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        for v in a {
            it.dom
                .borrow_mut()
                .class_add(idx, &v.to_js_string());
        }
    }
    Ok(Value::Undefined)
}

pub fn dom_classlist_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        for v in a {
            it.dom
                .borrow_mut()
                .class_remove(idx, &v.to_js_string());
        }
    }
    Ok(Value::Undefined)
}

/// `classList.supports(token)`（DOM Standard §4.3）。
pub fn dom_classlist_supports(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(false))
}


/// `classList.toggle(name, force)`。以前は第2引数 `force`（真偽値を渡すと現在の状態に
/// 関係なく強制的に付与/除去する）を完全に無視し、常に単純なトグルだけを行っていた
/// （`el.classList.toggle('active', isActive)` という定番パターンが動かなかった）。
pub fn dom_classlist_toggle(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let cls = arg(a, 0).to_js_string();
        if matches!(arg(a, 1), Value::Undefined) {
            let on = it.dom.borrow_mut().class_toggle(idx, &cls);
            return Ok(Value::Bool(on));
        }
        let force = arg(a, 1).truthy();
        if force {
            it.dom.borrow_mut().class_add(idx, &cls);
        } else {
            it.dom.borrow_mut().class_remove(idx, &cls);
        }
        return Ok(Value::Bool(force));
    }
    Ok(Value::Bool(false))
}

pub fn dom_classlist_contains(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        return Ok(Value::Bool(
            it.dom
                .borrow()
                .class_contains(idx, &arg(a, 0).to_js_string()),
        ));
    }
    Ok(Value::Bool(false))
}

/// `classList.entries()`/`.keys()`/`.values()`（丸ごと未対応だった。`DOMTokenList`
/// は仕様上 `forEach`/`Symbol.iterator` に加えこの3メソッドも持つが、`forEach`と
/// for-of 反復（`iterable_values`）のみ配線され、これらの明示イテレータ取得
/// メソッドは未配線だった。`Array.prototype` の同名メソッドと同じく既存の
/// `make_iterator` ヘルパーへ委譲する薄い実装。
pub fn dom_classlist_entries(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let classes = it.dom.borrow().nodes.get(idx).map(|n| n.classes.clone()).unwrap_or_default();
        let out: Vec<Value> = classes
            .into_iter()
            .enumerate()
            .map(|(i, c)| Value::Object(Obj::array(alloc::vec![Value::Number(i as f64), Value::str(c)])))
            .collect();
        return Ok(Value::Object(make_iterator(out)));
    }
    Ok(Value::Object(make_iterator(alloc::vec![])))
}
pub fn dom_classlist_keys(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let n = it.dom.borrow().nodes.get(idx).map(|n| n.classes.len()).unwrap_or(0);
        return Ok(Value::Object(make_iterator(
            (0..n).map(|i| Value::Number(i as f64)).collect(),
        )));
    }
    Ok(Value::Object(make_iterator(alloc::vec![])))
}
pub fn dom_classlist_values(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let classes = it.dom.borrow().nodes.get(idx).map(|n| n.classes.clone()).unwrap_or_default();
        return Ok(Value::Object(make_iterator(
            classes.into_iter().map(Value::str).collect(),
        )));
    }
    Ok(Value::Object(make_iterator(alloc::vec![])))
}

pub(crate) fn document_create_element(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let tag = arg(a, 0).to_js_string();
    let idx = it.dom.borrow_mut().create_element(&tag);
    Ok(Value::Object(Obj::dom(idx)))
}
/// `document.createElementNS(namespaceURI, qualifiedName)`（丸ごと未対応
/// だった。SVG 要素（`document.createElementNS('http://www.w3.org/2000/svg',
/// 'circle')` 等）を JS から動的生成する標準的な定番パターン）。この処理系は
/// `*AttributeNS` 系と同じく XML 名前空間を一切モデル化していないため、
/// 第1引数（namespace）は無視して非 NS 版の `createElement` へ委譲する
/// 簡略実装（多くの実用コードは SVG 名前空間しか渡さないため実害は小さい）。
pub(crate) fn document_create_element_ns(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    document_create_element(it, t, &[arg(a, 1)])
}

/// `new Option(text?, value?, defaultSelected?, selected?)`（HTML5。丸ごと
/// 未対応だった）。`document.createElement('option')` を土台に組み立てる。
pub(crate) fn option_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = it.dom.borrow_mut().create_element("option");
    let text = arg(a, 0);
    if !matches!(text, Value::Undefined) {
        it.dom.borrow_mut().set_text_content(idx, &text.to_js_string());
    }
    let value = arg(a, 1);
    if !matches!(value, Value::Undefined) {
        it.dom.borrow_mut().set_attr(idx, "value", &value.to_js_string());
    }
    if arg(a, 2).truthy() || arg(a, 3).truthy() {
        it.dom.borrow_mut().set_attr(idx, "selected", "selected");
    }
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn document_create_text_node(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let text = arg(a, 0).to_js_string();
    let idx = it.dom.borrow_mut().create_text_node(&text);
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn document_create_comment(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let text = arg(a, 0).to_js_string();
    let idx = it.dom.borrow_mut().create_comment(&text);
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn document_create_document_fragment(it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let idx = it.dom.borrow_mut().create_document_fragment();
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn split_css_rules(css: &str) -> alloc::vec::Vec<String> {
    let mut rules = alloc::vec![];
    let mut current_rule = String::new();
    let mut depth = 0;
    for c in css.chars() {
        current_rule.push(c);
        if c == '{' {
            depth += 1;
        } else if c == '}' {
            if depth > 0 {
                depth -= 1;
            }
            if depth == 0 {
                let trimmed = current_rule.trim();
                if !trimmed.is_empty() {
                    rules.push(trimmed.to_string());
                }
                current_rule.clear();
            }
        }
    }
    let trimmed = current_rule.trim();
    if !trimmed.is_empty() {
        rules.push(trimmed.to_string());
    }
    rules
}

pub(crate) fn dom_stylesheet_insert_rule(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let rule_text = arg(a, 0).to_js_string();
    let insert_index = arg(a, 1).to_number() as usize;
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if let Some(rest) = t.strip_prefix("stylesheet:") {
                let idx: usize = rest.parse().unwrap_or(usize::MAX);
                let text = it.dom.borrow().get_text_content(idx);
                let mut rules = split_css_rules(&text);
                let actual_index = insert_index.min(rules.len());
                rules.insert(actual_index, rule_text);
                let new_css = rules.join("\n");
                it.dom.borrow_mut().set_text_content(idx, &new_css);
                return Ok(Value::Number(actual_index as f64));
            }
        }
    }
    Ok(Value::Number(0.0))
}

pub(crate) fn dom_stylesheet_delete_rule(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let delete_index = arg(a, 0).to_number() as usize;
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if let Some(rest) = t.strip_prefix("stylesheet:") {
                let idx: usize = rest.parse().unwrap_or(usize::MAX);
                let text = it.dom.borrow().get_text_content(idx);
                let mut rules = split_css_rules(&text);
                if delete_index < rules.len() {
                    rules.remove(delete_index);
                    let new_css = rules.join("\n");
                    it.dom.borrow_mut().set_text_content(idx, &new_css);
                }
            }
        }
    }
    Ok(Value::Undefined)
}

pub fn dom_append_child(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let child = arg(a, 0);
    if let (Some(p), Some(c)) = (this_dom_idx(&this), this_dom_idx(&child)) {
        it.dom.borrow_mut().append_child(p, c);
    }
    Ok(child) // appendChild は追加した子を返す。
}

/// parent.insertBefore(newChild, refChild)。ref が null/undefined なら末尾。
pub fn dom_insert_before(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_child = arg(a, 0);
    if let (Some(p), Some(nc)) = (this_dom_idx(&this), this_dom_idx(&new_child)) {
        let rc = this_dom_idx(&arg(a, 1)); // null/undefined → None
        if let Some(r) = rc {
            let is_child =
                it.dom.borrow().nodes.get(r).and_then(|n| n.parent) == Some(p);
            if !is_child {
                return Err(make_dom_exception(
                    "NotFoundError",
                    "The node before which the new node is to be inserted is not a child of this node",
                ));
            }
        }
        it.dom.borrow_mut().insert_before(p, nc, rc);
    }
    Ok(new_child)
}

/// `parent.moveBefore(movedNode, referenceNode)`（DOM。2025年にChromeへ
/// 実装が入った比較的新しいAPI。丸ごと未対応だった）。仕様上の主眼は
/// 「`remove()`してから`insertBefore()`する」場合と異なり、`<iframe>`の
/// 読み込み状態・`<video>`の再生状態・カスタム要素のライフサイクル
/// コールバック発火等を保持したまま木構造内を移動できる点にあるが、
/// この処理系にはそれらの「保持すべき生きた状態」自体が実装されて
/// いない（`<iframe>`は実際のナビゲーション状態を持たず、`<video>`は
/// 実再生をしない等）ため、実務上は`insertBefore`と同じ「detachしてから
/// 指定位置へ挿入」の`insert_before`（`dom_bridge.rs`。既に自動で元の
/// 親から外す実装）をそのまま再利用する誠実な簡略実装で十分に仕様どおり
/// 動作する。`referenceNode`（`null`可）が`this`の子でない場合は
/// `insertBefore`と同じ`NotFoundError`規則を踏襲。2026-07-18 発見・実装。
pub fn dom_move_before(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let moved_node = arg(a, 0);
    if let (Some(p), Some(mn)) = (this_dom_idx(&this), this_dom_idx(&moved_node)) {
        let rc = this_dom_idx(&arg(a, 1));
        if let Some(r) = rc {
            let is_child = it.dom.borrow().nodes.get(r).and_then(|n| n.parent) == Some(p);
            if !is_child {
                return Err(make_dom_exception(
                    "NotFoundError",
                    "The node before which the moved node is to be inserted is not a child of this node",
                ));
            }
        }
        it.dom.borrow_mut().insert_before(p, mn, rc);
    }
    Ok(moved_node)
}

/// `select.options.add(option, before?)`（HTML5 `HTMLOptionsCollection`。
/// 動的にドロップダウンを構築する `select.options.add(new Option(...))` という
/// 定番イディオムが、`options` が素の配列（メソッドを一切持たない）を返す
/// だけだったため丸ごと未対応（`TypeError: not a function`）だった。`options`
/// 取得時に配列オブジェクト自身へ `_select_idx`（隠しプロパティ。既存の
/// `_is_headers`/`_ta_kind` 等と同じ内部タグ付けパターン）を仕込んでおき、
/// この配列を経由して元の `<select>` を辿れるようにする。`before` は仕様どおり
/// 省略時は末尾追加、数値ならその位置の既存 option の前、`<option>` 要素
/// そのものでもよい。
pub fn select_options_add(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let select_idx = match &this {
        Value::Object(o) => o.borrow().props.get("_select_idx").map(|v| v.to_number() as usize),
        _ => None,
    };
    let (Some(select_idx), Some(opt_idx)) = (select_idx, this_dom_idx(&arg(a, 0))) else {
        return Ok(Value::Undefined);
    };
    let before = arg(a, 1);
    let ref_idx = match &before {
        Value::Number(n) => it.dom.borrow().select_options(select_idx).get(*n as usize).copied(),
        Value::Object(_) => this_dom_idx(&before),
        _ => None,
    };
    it.dom.borrow_mut().insert_before(select_idx, opt_idx, ref_idx);
    Ok(Value::Undefined)
}
/// `select.add(element, before)`（`HTMLSelectElement`直下の便利メソッド。
/// `select.options.add`と全く同じ意味だが、`this`が`options`コレクション
/// 配列ではなく`<select>`要素自身になる点だけが違う。丸ごと未対応
/// だった。`select_options_add`とほぼ同じロジックだが、`_select_idx`
/// 隠しプロパティ経由ではなく`this_dom_idx`で直接`<select>`のインデックス
/// を取る。2026-07-18 発見・実装）。
pub fn dom_select_add(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let (Some(select_idx), Some(opt_idx)) = (this_dom_idx(&this), this_dom_idx(&arg(a, 0))) else {
        return Ok(Value::Undefined);
    };
    let before = arg(a, 1);
    let ref_idx = match &before {
        Value::Number(n) => it.dom.borrow().select_options(select_idx).get(*n as usize).copied(),
        Value::Object(_) => this_dom_idx(&before),
        _ => None,
    };
    it.dom.borrow_mut().insert_before(select_idx, opt_idx, ref_idx);
    Ok(Value::Undefined)
}
/// `select.options.remove(index)`（`HTMLOptionsCollection`。上記 `add` と対に
/// なる、指定インデックスの `<option>` を取り除く定番メソッド）。
pub fn select_options_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let select_idx = match &this {
        Value::Object(o) => o.borrow().props.get("_select_idx").map(|v| v.to_number() as usize),
        _ => None,
    };
    let Some(select_idx) = select_idx else {
        return Ok(Value::Undefined);
    };
    let n = arg(a, 0).to_number() as usize;
    // `if let Some(x) = obj.borrow()...` は scrutinee の一時 `Ref` が if-let ブロック
    // 終端まで生き続けるため、ブロック内で `borrow_mut()` すると「RefCell already
    // borrowed」で panic する（このファイルの `report_error` 修正と同型のバグ。
    // 一度 owned な値へ materialize してから `if let` することで回避する）。
    let opt_idx = it.dom.borrow().select_options(select_idx).get(n).copied();
    if let Some(opt_idx) = opt_idx {
        it.dom.borrow_mut().remove_child(select_idx, opt_idx);
    }
    Ok(Value::Undefined)
}
/// `select.options.namedItem(name)`（`HTMLOptionsCollection`。`id`/`name`
/// 属性が一致する `<option>` を探す定番メソッド。見つからなければ仕様どおり
/// `null`）。
pub fn select_options_named_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let select_idx = match &this {
        Value::Object(o) => o.borrow().props.get("_select_idx").map(|v| v.to_number() as usize),
        _ => None,
    };
    let Some(select_idx) = select_idx else {
        return Ok(Value::Null);
    };
    let name = arg(a, 0).to_js_string();
    let dom = it.dom.borrow();
    for opt_idx in dom.select_options(select_idx) {
        if dom.get_attr(opt_idx, "id").as_deref() == Some(name.as_str())
            || dom.get_attr(opt_idx, "name").as_deref() == Some(name.as_str())
        {
            return Ok(Value::Object(Obj::dom(opt_idx)));
        }
    }
    Ok(Value::Null)
}

/// parent.replaceChild(newChild, oldChild)。置換された old を返す。
pub fn dom_replace_child(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let old_child = arg(a, 1);
    if let (Some(p), Some(nc), Some(oc)) = (
        this_dom_idx(&this),
        this_dom_idx(&arg(a, 0)),
        this_dom_idx(&old_child),
    ) {
        // `insertBefore`と同じ理由（詳細はそちらの同種コメント参照）で、
        // `oldChild`が`this`の子でない場合は仕様上`NotFoundError`を投げる
        // べきだが、以前は`replace_child`（`dom_bridge.rs`）が黙って何もせず
        // 成功したかのように振る舞っていた。
        let is_child = it.dom.borrow().nodes.get(oc).and_then(|n| n.parent) == Some(p);
        if !is_child {
            return Err(make_dom_exception(
                "NotFoundError",
                "The node to be replaced is not a child of this node",
            ));
        }
        it.dom.borrow_mut().replace_child(p, nc, oc);
    }
    Ok(old_child)
}

/// 引数を DOM ノード idx に解決（要素はそのまま、文字列はテキストノード生成）。
pub(crate) fn arg_to_node(it: &mut Interp, v: &Value) -> Option<usize> {
    match this_dom_idx(v) {
        Some(i) => Some(i),
        None => match v {
            Value::Undefined | Value::Null => None,
            other => Some(it.dom.borrow_mut().create_text_node(&other.to_js_string())),
        },
    }
}

/// element.insertAdjacentHTML(position, html)。
/// `element.getHTML(options?)`（DOM。`innerHTML`ゲッターの明示的メソッド版
/// として2024年頃に標準化。丸ごと未対応だった）。仕様上の`options`
/// （`{serializableShadowRoots, shadowRoots}`）はShadow DOM自体が
/// この処理系に存在しないため意味を持たず無視する。`innerHTML`と全く同じ
/// `get_inner_html`をそのまま呼ぶだけの簡略実装。2026-07-18 発見・実装。
pub fn dom_get_html(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        return Ok(Value::str(it.dom.borrow().get_inner_html(idx)));
    }
    Ok(Value::str(""))
}

/// `element.setHTMLUnsafe(html)`（DOM。`innerHTML`セッターのTrusted
/// Types検証を明示的にバイパスする版として標準化。丸ごと未対応だった）。
/// この処理系にはTrusted Typesの強制自体が実装されていないため、
/// `innerHTML`セッターと全く同じ`set_inner_html`をそのまま呼ぶだけの
/// 簡略実装で仕様上の可視的な違いは無い。2026-07-18 発見・実装。
pub fn dom_set_html_unsafe(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let html = arg(a, 0).to_js_string();
        it.dom.borrow_mut().set_inner_html(idx, &html);
    }
    Ok(Value::Undefined)
}

pub fn dom_insert_adjacent_html(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        // `position` は仕様上 ASCII 大文字小文字を無視して照合すべきだが
        // （`"beforeBegin"`/`"BEFOREEND"` 等も有効）、以前は完全一致のみで
        // 小文字以外を渡すと静かに no-op になっていた。
        let pos = arg(a, 0).to_js_string().to_lowercase();
        let html = arg(a, 1).to_js_string();
        it.dom.borrow_mut().insert_adjacent_html(idx, &pos, &html);
    }
    Ok(Value::Undefined)
}
/// element.insertAdjacentElement(position, element)。
pub fn dom_insert_adjacent_element(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let el = arg(a, 1);
    if let (Some(idx), Some(node)) = (this_dom_idx(&this), this_dom_idx(&el)) {
        let pos = arg(a, 0).to_js_string().to_lowercase();
        it.dom.borrow_mut().insert_adjacent_node(idx, &pos, node);
    }
    Ok(el)
}
/// element.insertAdjacentText(position, text)。
pub fn dom_insert_adjacent_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let pos = arg(a, 0).to_js_string().to_lowercase();
        let node = it
            .dom
            .borrow_mut()
            .create_text_node(&arg(a, 1).to_js_string());
        it.dom.borrow_mut().insert_adjacent_node(idx, &pos, node);
    }
    Ok(Value::Undefined)
}
/// element.toggleAttribute(name[, force]) → 操作後の存在を返す。
pub fn dom_toggle_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        let has = it.dom.borrow().has_attr(idx, &name);
        let new_state = if a.len() > 1 && !matches!(arg(a, 1), Value::Undefined) {
            arg(a, 1).truthy()
        } else {
            !has
        };
        if new_state {
            it.dom.borrow_mut().set_attr(idx, &name, "");
        } else {
            it.dom.borrow_mut().remove_attr(idx, &name);
        }
        return Ok(Value::Bool(new_state));
    }
    Ok(Value::Bool(false))
}

/// `dialog.show()`（`<dialog>` が丸ごと未対応だった）。`open` 属性を付ける
/// だけの簡略実装。
pub fn dom_dialog_show(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom.borrow_mut().set_attr(idx, "open", "open");
    }
    Ok(Value::Undefined)
}

/// `dialog.showModal()`。以前は`.show()`と全く同じ`dom_dialog_show`を共有して
/// おり、モーダル/非モーダルの区別自体が存在しなかった（`showModal()`本来の
/// モーダルフォーカストラップ・`::backdrop`描画は依然対象外だが対象外）。CSS
/// `:modal`疑似クラス（丸ごと未対応だった。2026-07-18 発見・実装）が判定
/// できるよう、`open`属性に加え`:fullscreen`と同じ内部専用属性パターンで
/// `_modal`を書き込む点だけが`.show()`と異なる。
pub fn dom_dialog_show_modal(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let mut dom = it.dom.borrow_mut();
        dom.set_attr(idx, "open", "open");
        dom.set_attr(idx, "_modal", "1");
    }
    Ok(Value::Undefined)
}

/// `dialog.close(returnValue?)`。`open` 属性を外し、`returnValue` を設定してから
/// `close` イベントを発火する（仕様どおり）。DOM 要素は汎用の `Obj.props` ではなく
/// `interp.rs` 側の明示的なプロパティ一覧を介してアクセスされるため、`checked`/
/// `indeterminate` と同じ「内部専用の `_` プレフィックス属性キー」パターン
/// （`_return_value`）で持たせる（`this.props` へ直接書いても読み出し経路が
/// 無く反映されない）。
pub fn dom_dialog_close(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        {
            let mut dom = it.dom.borrow_mut();
            dom.remove_attr(idx, "open");
            dom.remove_attr(idx, "_modal");
        }
        if !a.is_empty() {
            it.dom
                .borrow_mut()
                .set_attr(idx, "_return_value", &arg(a, 0).to_js_string());
        }
        let _ = it.dispatch_event_in_interp(idx, "close", &[]);
    }
    Ok(Value::Undefined)
}

// `dialog.requestClose(returnValue?)`（HTML Living Standard。`.close()`と
// 違い、閉じる直前に取消可能な`cancel`イベントを発火し、リスナが
// `preventDefault()`すればダイアログを開いたままにできる。丸ごと
// 未対応だった。`.close()`自体は無条件クローズのため対になるこちらの
// 「ユーザーの閉じる操作を横取り可能にする」経路が漏れていた。
// `popover_toggle_extra`と同じ「取消可能イベント→未阻止なら実処理」
// パターンを再利用する。2026-07-18 発見・実装）。
pub fn dom_dialog_request_close(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let (_, prevented) = it.dispatch_event_in_interp(idx, "cancel", &[]);
        if !prevented {
            {
                let mut dom = it.dom.borrow_mut();
                dom.remove_attr(idx, "open");
                dom.remove_attr(idx, "_modal");
            }
            if !a.is_empty() {
                it.dom
                    .borrow_mut()
                    .set_attr(idx, "_return_value", &arg(a, 0).to_js_string());
            }
            let _ = it.dispatch_event_in_interp(idx, "close", &[]);
        }
    }
    Ok(Value::Undefined)
}

/// `element.showPopover()`/`.hidePopover()`/`.togglePopover(force?)`（Popover
/// API。丸ごと未対応だった）。`<dialog>` の `open` 属性と同じく、内部専用属性
/// （`_popover_open`）を付け外しするだけの簡略実装（`css.rs` 側の UA 既定
/// display 切り替えと対）。`beforetoggle`/`toggle` イベント発火・
/// `:popover-open` 疑似クラス・ライトディスミスは対象外。
// `showPopover`/`hidePopover`/`togglePopover`が状態変化を`toggle`イベント
// として発火していなかった（丸ごと未対応だった。`<dialog>.close()`は既に
// `"close"`イベントを発火していたのに、同じ「開閉状態変化を通知する」
// 役目のPopover側だけ漏れていた非対称ギャップ。2026-07-17 発見）。仕様上は
// `oldState`/`newState`を持つ`ToggleEvent`だが、この処理系に`ToggleEvent`
// コンストラクタ自体が無いため、`<details>`の`toggle`イベント修正と同じ
// 簡略方針で`dispatch_event_in_interp`にプレーンな`Event`へ同名プロパティ
// を追加する形（`extra`引数）で代用する。対になる取消可能な`beforetoggle`
// （状態変更「前」に発火し`preventDefault()`で開閉を中止できる。同じく
// 丸ごと未対応だった）も同時に実装。
fn popover_toggle_extra(old_open: bool, new_open: bool) -> alloc::vec::Vec<(String, Value)> {
    alloc::vec![
        (String::from("oldState"), Value::str(if old_open { "open" } else { "closed" })),
        (String::from("newState"), Value::str(if new_open { "open" } else { "closed" })),
    ]
}
pub fn dom_show_popover(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let was_open = it.dom.borrow().has_attr(idx, "_popover_open");
        // `beforetoggle`（状態変更「前」に発火する取消可能なイベント。
        // `preventDefault()`で開閉自体を中止できる。丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        let (_, prevented) =
            it.dispatch_event_in_interp(idx, "beforetoggle", &popover_toggle_extra(was_open, true));
        if prevented {
            return Ok(Value::Undefined);
        }
        it.dom.borrow_mut().set_attr(idx, "_popover_open", "");
        let _ = it.dispatch_event_in_interp(idx, "toggle", &popover_toggle_extra(was_open, true));
    }
    Ok(Value::Undefined)
}
pub fn dom_hide_popover(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let was_open = it.dom.borrow().has_attr(idx, "_popover_open");
        let (_, prevented) =
            it.dispatch_event_in_interp(idx, "beforetoggle", &popover_toggle_extra(was_open, false));
        if prevented {
            return Ok(Value::Undefined);
        }
        it.dom.borrow_mut().remove_attr(idx, "_popover_open");
        let _ = it.dispatch_event_in_interp(idx, "toggle", &popover_toggle_extra(was_open, false));
    }
    Ok(Value::Undefined)
}
pub fn dom_toggle_popover(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let was_open = it.dom.borrow().has_attr(idx, "_popover_open");
        let force = if matches!(arg(a, 0), Value::Undefined) {
            !was_open
        } else {
            arg(a, 0).truthy()
        };
        let (_, prevented) =
            it.dispatch_event_in_interp(idx, "beforetoggle", &popover_toggle_extra(was_open, force));
        if prevented {
            return Ok(Value::Bool(was_open));
        }
        if force {
            it.dom.borrow_mut().set_attr(idx, "_popover_open", "");
        } else {
            it.dom.borrow_mut().remove_attr(idx, "_popover_open");
        }
        let _ = it.dispatch_event_in_interp(idx, "toggle", &popover_toggle_extra(was_open, force));
        return Ok(Value::Bool(force));
    }
    Ok(Value::Bool(false))
}

/// element.append(...nodes)：末尾に複数追加（文字列はテキスト）。
/// `element.replaceChildren(...nodes)`（DOM 標準。`el.innerHTML=''; el.append(...)`
/// の1行版として使われる定番イディオム）が丸ごと未対応だった。既存の
/// `set_inner_html(idx, "")`（子を丸ごとクリア）と `append`/`arg_to_node` と同じ
/// 「文字列は text node、DOM ノードはそのまま」変換を組み合わせて実装する。
pub fn dom_replace_children(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(p) = this_dom_idx(&this) {
        it.dom.borrow_mut().set_inner_html(p, "");
        for v in a {
            if let Some(c) = arg_to_node(it, v) {
                it.dom.borrow_mut().append_child(p, c);
            }
        }
    }
    Ok(Value::Undefined)
}
pub fn dom_append(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(p) = this_dom_idx(&this) {
        for v in a {
            if let Some(c) = arg_to_node(it, v) {
                it.dom.borrow_mut().append_child(p, c);
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.prepend(...nodes)：先頭に複数追加（順序保持）。
pub fn dom_prepend(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(p) = this_dom_idx(&this) {
        let refnode = it
            .dom
            .borrow()
            .nodes
            .get(p)
            .and_then(|n| n.children.first().copied());
        for v in a {
            if let Some(c) = arg_to_node(it, v) {
                it.dom.borrow_mut().insert_before(p, c, refnode);
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.before(...nodes)：自身の前に兄弟として挿入。
pub fn dom_before(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_dom_idx(&this) {
        let parent = it.dom.borrow().nodes.get(s).and_then(|n| n.parent);
        if let Some(p) = parent {
            for v in a {
                if let Some(c) = arg_to_node(it, v) {
                    it.dom.borrow_mut().insert_before(p, c, Some(s));
                }
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.after(...nodes)：自身の後に兄弟として挿入。
pub fn dom_after(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_dom_idx(&this) {
        let (parent, next) = {
            let dom = it.dom.borrow();
            let parent = dom.nodes.get(s).and_then(|n| n.parent);
            let next = parent.and_then(|p| dom.nodes.get(p)).and_then(|n| {
                n.children
                    .iter()
                    .position(|&c| c == s)
                    .and_then(|i| n.children.get(i + 1).copied())
            });
            (parent, next)
        };
        if let Some(p) = parent {
            for v in a {
                if let Some(c) = arg_to_node(it, v) {
                    it.dom.borrow_mut().insert_before(p, c, next);
                }
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.replaceWith(...nodes)：自身を nodes で置換。
pub fn dom_replace_with(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_dom_idx(&this) {
        let parent = it.dom.borrow().nodes.get(s).and_then(|n| n.parent);
        if let Some(p) = parent {
            for v in a {
                if let Some(c) = arg_to_node(it, v) {
                    it.dom.borrow_mut().insert_before(p, c, Some(s));
                }
            }
            it.dom.borrow_mut().remove_node(s);
        }
    }
    Ok(Value::Undefined)
}

/// node.cloneNode(deep)。複製ノード（親なし）を返す。
pub fn dom_clone_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let deep = arg(a, 0).truthy();
        let new_idx = it.dom.borrow_mut().clone_node(idx, deep);
        return Ok(dom_handle(Some(new_idx)));
    }
    Ok(Value::Null)
}
/// `document.importNode(externalNode, deep)`（丸ごと未対応だった。
/// `<template>` の中身を複製して自文書へ取り込む定番パターン
/// `document.importNode(template.content, true)` で使われる）。この処理系は
/// 単一文書（複数 `Document` オブジェクトという概念自体が無い）のため、
/// 「別文書から取り込む」という仕様上の意味は無く、実質 `node.cloneNode(deep)`
/// と同じ結果になる簡略実装。仕様上 `deep` は省略時 `false` だが、実務では
/// ほぼ常に明示的に `true` が渡される。
pub fn document_import_node(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_clone_node(it, arg(a, 0), a.get(1..).unwrap_or(&[]))
}
/// `document.adoptNode(node)`（丸ごと未対応だった）。単一文書のこの処理系
/// では「別文書から養子縁組する」という意味は無いため、仕様の副作用
/// （現在の親から取り外す）のみを再現し、渡されたノードをそのまま返す。
pub fn document_adopt_node(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let node = arg(a, 0);
    if let Some(idx) = this_dom_idx(&node) {
        it.dom.borrow_mut().remove_node(idx);
    }
    Ok(node)
}

/// `element.click()`。以前は単なる no-op で、実際のクリック
/// （`onclick`/`addEventListener('click', ...)` リスナの発火）を一切引き起こさな
/// かった。実マウス操作からも呼ばれる既存の `dispatch_click()` を再利用する。
/// `checkbox`/`radio` は仕様上クリックすると（リスナの実行前に）自身の選択状態が
/// 切り替わる。以前は `element.checked` という JS プロパティ自体が丸ごと未実装
/// だったため、この状態切替もできていなかった。**重要**: 同じ `name` を持つ
/// ラジオボタン間の排他選択（1つを選ぶと他が自動で解除される、ラジオボタンの
/// 最も基本的な仕様上の挙動）も以前は非対応の簡略化として明示的に見送られていたが、
/// `uncheck_radio_group_siblings` を新設し配線した。
/// `element.scrollTo(x, y)`/`.scrollTo({top, left, behavior})` が丸ごと未対応
/// だった。`element.scrollTop` 自体は既に対応済み（`scroll_tops` に反映して再描画
/// 要求する実装）なので、それをそのまま呼び出す薄いラッパーとして実装する。
/// この処理系に横スクロールモデルは存在しないため `left`/`x` は無視する（`behavior`
/// も同様、実時間アニメーションの概念が無いため即座に反映する簡略実装）。
pub(crate) fn scroll_top_target(a: &[Value]) -> Option<i32> {
    match arg(a, 0) {
        Value::Object(_) => obj_prop(&arg(a, 0), "top").map(|v| v.to_number() as i32),
        Value::Undefined => None,
        _ => Some(arg(a, 1).to_number() as i32),
    }
}
pub fn dom_scroll_to(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        if let Some(top) = scroll_top_target(a) {
            let mut dom = it.dom.borrow_mut();
            dom.scroll_tops.insert(idx, top.max(0));
            dom.dirty = true;
        }
    }
    Ok(Value::Undefined)
}
/// `element.scrollBy(x, y)`/`.scrollBy({top, left})`。現在値からの相対移動である点
/// のみ `scrollTo` と異なる。
pub fn dom_scroll_by(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        if let Some(delta) = scroll_top_target(a) {
            let mut dom = it.dom.borrow_mut();
            let cur = dom.scroll_tops.get(&idx).copied().unwrap_or(0);
            dom.scroll_tops.insert(idx, (cur + delta).max(0));
            dom.dirty = true;
        }
    }
    Ok(Value::Undefined)
}
/// `element.scrollIntoView()`/`.scrollIntoView({behavior, block})`が丸ごと
/// no-opだった（HTML Standard §"scroll into view"の簡略実装が丸ごと欠落。
/// 実サイト www.sugi-lab.net のナビゲーションリンク（`target.scrollIntoView(
/// {behavior:'smooth', block:'start'})`）が完全に無効化されており、クリック
/// しても一切スクロールしないという実害があった。2026-07-22発見・修正）。
/// 既存の`window.scrollTo`と同じ`pending_scroll_abs_y`機構（`render.rs`の
/// `draw()`冒頭で消費・`fire_scroll()`呼び出しまで行う、既に動作確認済みの
/// 経路）を再利用する。対象要素の現在のビューポート相対Y座標
/// （`get_rect`。`getBoundingClientRect`と同じ値）に現在のスクロール量
/// （`window.scrollY`）を加算し、文書内の絶対Y座標を求めて要素の上端が
/// ビューポート上端に来るようにスクロールする（`block:'start'`相当。
/// `center`/`end`/`nearest`は簡略化しすべて`start`と同一視する。`behavior`
/// は既存の`scrollTo`と同様、実時間アニメーションの概念が無いため即座に
/// 反映する）。
pub fn dom_scroll_into_view(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let Some((_, y, _, _)) = it.dom.borrow().get_rect(idx) else {
        return Ok(Value::Undefined);
    };
    let current_scroll_y = it
        .global
        .borrow()
        .vars
        .get("scrollY")
        .map(|v| v.to_number())
        .unwrap_or(0.0);
    let target_abs_y = (current_scroll_y + y as f64).max(0.0);
    it.dom.borrow_mut().pending_scroll_abs_y = Some(target_abs_y as i32);
    Ok(Value::Undefined)
}
pub fn dom_click(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let ty = it.dom.borrow().get_attr(idx, "type").unwrap_or_default();
        match ty.as_str() {
            "checkbox" => {
                let checked = {
                    let dom = it.dom.borrow();
                    if let Some(lc) = dom.get_attr(idx, "_live_checked") {
                        lc == "true"
                    } else {
                        dom.has_attr(idx, "checked")
                    }
                };
                let mut dom = it.dom.borrow_mut();
                if checked {
                    dom.set_attr(idx, "_live_checked", "false");
                } else {
                    dom.set_attr(idx, "_live_checked", "true");
                }
            }
            "radio" => {
                let mut dom = it.dom.borrow_mut();
                dom.set_attr(idx, "_live_checked", "true");
                dom.uncheck_radio_group_siblings(idx);
            }
            _ => {}
        }
        it.dispatch_event_in_interp(idx, "click", &[]);
    }
    Ok(Value::Undefined)
}

/// `element.focus()`（HTML5。丸ごと未対応だった。`document.activeElement`
/// と対になる書き込み側。以前は `scrollIntoView` と同じ no-op で
/// `document.activeElement` が常に `null` 固定になっていた）。`DomBridge::
/// focused_idx` を直接更新し、仕様どおりの順序（旧要素の `blur`/
/// `focusout` → 新要素の `focus`/`focusin`）でイベントを発火する。レンダラ側
/// の `WebEngine::focused_id`（実クリック/`autofocus` 用の文字列キー版状態）
/// との同期は対象外（詳細は `DomBridge::focused_idx` のコメント参照）。
pub fn dom_focus(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let prev = it.dom.borrow().focused_idx;
        if prev == Some(idx) {
            return Ok(Value::Undefined);
        }
        if let Some(p) = prev {
            it.dom.borrow_mut().focused_idx = None;
            let _ = it.dispatch_event_in_interp(p, "blur", &[]);
            let _ = it.dispatch_event_in_interp(p, "focusout", &[]);
        }
        it.dom.borrow_mut().focused_idx = Some(idx);
        let _ = it.dispatch_event_in_interp(idx, "focus", &[]);
        let _ = it.dispatch_event_in_interp(idx, "focusin", &[]);
    }
    Ok(Value::Undefined)
}
/// `element.blur()`（HTML5。丸ごと未対応だった。`dom_focus` の対）。自身が
/// 現在のフォーカス対象である場合のみ解除して `blur`/`focusout` を発火する
/// （仕様どおり、フォーカスされていない要素での `.blur()` は no-op）。
pub fn dom_blur(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let is_focused = it.dom.borrow().focused_idx == Some(idx);
        if is_focused {
            it.dom.borrow_mut().focused_idx = None;
            let _ = it.dispatch_event_in_interp(idx, "blur", &[]);
            let _ = it.dispatch_event_in_interp(idx, "focusout", &[]);
        }
    }
    Ok(Value::Undefined)
}

/// `input.stepUp(n?)`/`.stepDown(n?)`（HTML5。`<input type="number"/"range">`
/// で値を `step` 刻みで増減する定番メソッド）が丸ごと未対応だった。`value`/
/// `step`/`min`/`max` 属性を読み、`min`/`max` があればクランプしてから
/// `value` 属性へ書き戻す（`step="any"`等パース不能な場合は既定値 1 に
/// フォールバックする、この処理系の他の数値属性パースと同じ寛容な簡略化）。
pub(crate) fn dom_step_by(it: &mut Interp, this: Value, a: &[Value], sign: f64) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let (cur, step, min, max) = {
            let dom = it.dom.borrow();
            let raw_val = dom.get_attr(idx, "_live_value")
                .or_else(|| dom.get_attr(idx, "value"));
            (
                raw_val.and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0),
                dom.get_attr(idx, "step").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(1.0),
                dom.get_attr(idx, "min").and_then(|s| s.trim().parse::<f64>().ok()),
                dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()),
            )
        };
        let multiplier = match arg(a, 0) {
            Value::Undefined => 1.0,
            n => n.to_number(),
        };
        let mut new_val = cur + sign * step * multiplier;
        if let Some(mn) = min {
            if new_val < mn {
                new_val = mn;
            }
        }
        if let Some(mx) = max {
            if new_val > mx {
                new_val = mx;
            }
        }
        let str_val = Value::Number(new_val).to_js_string();
        it.dom.borrow_mut().set_attr(idx, "_live_value", &str_val);
    }
    Ok(Value::Undefined)
}
pub fn dom_step_up(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_step_by(it, this, a, 1.0)
}
pub fn dom_step_down(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_step_by(it, this, a, -1.0)
}

/// `form.requestSubmit(submitter?)`（HTML5）が丸ごと未対応だった。既存の
/// `dom_click` と同じ `dispatch_event_in_interp` 経由で `submit` イベントを
/// 発火する（`preventDefault()` で中止可能。`submitter` 引数は現状無視）。
pub fn dom_request_submit(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dispatch_event_in_interp(idx, "submit", &[]);
    }
    Ok(Value::Undefined)
}

/// `node.contains(other)`（DOM 標準。`other` が `node` 自身または子孫かどうか。
/// click-outside 判定などで広く使われる）が丸ごと未対応だった。既存の
/// `is_ancestor_of()` は「`idx` 自身は含まない」仕様のため、仕様どおり自身も
/// 含めるにはここで等価チェックを補う。
pub fn dom_contains(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let other = arg(a, 0);
    if let (Some(anc), Some(desc)) = (this_dom_idx(&this), this_dom_idx(&other)) {
        let contains = anc == desc || it.dom.borrow().is_ancestor_of(anc, desc);
        return Ok(Value::Bool(contains));
    }
    Ok(Value::Bool(false))
}

/// `node.getRootNode()`（DOM標準。`el.getRootNode() === document` という
/// 「接続済みか」の定番判定や、shadow DOM 対応コードの分岐で使われる）が丸ごと
/// 未対応だった。この処理系は shadow DOM を持たないため、親を辿れる限り辿った
/// 最上位ノードを返す単純な実装で仕様の意図（最も遠い祖先）を満たす。
pub fn dom_get_root_node(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let mut cur = idx;
        let mut guard = 0;
        loop {
            let parent = it.dom.borrow().nodes.get(cur).and_then(|n| n.parent);
            match parent {
                Some(p) => {
                    cur = p;
                    guard += 1;
                    if guard > it.dom.borrow().nodes.len() {
                        break;
                    }
                }
                None => break,
            }
        }
        if cur == 0 {
            if let Some(doc) = it.global.borrow().vars.get("document").cloned() {
                return Ok(doc);
            }
        }
        return Ok(Value::Object(Obj::dom(cur)));
    }
    if matches!(this, Value::Object(_)) {
        if let Ok(parent) = it.get_property(&this, "parentNode") {
            if !matches!(parent, Value::Null | Value::Undefined) {
                return dom_get_root_node(it, parent, _a);
            }
        }
        return Ok(this);
    }
    Ok(Value::Undefined)
}

/// `element.checkVisibility()`（DOM 標準。丸ごと未対応だった）。オプション引数
/// （`checkOpacity`/`checkVisibilityCSS`/`contentVisibilityAuto` 等）は未対応で
/// 常に無視する簡略実装。自身の算出 `visibility` が `hidden`/`collapse` の場合、
/// および自身または祖先のいずれかの算出 `display` が `none` の場合に `false` を返す。
/// `node.lookupNamespaceURI(prefix)`/`.lookupPrefix(namespace)`/
/// `.isDefaultNamespace(namespace)`（丸ごと未対応だった。2026-07-16
/// 発見）。この処理系は `*AttributeNS`/`createElementNS` と同じく XML
/// 名前空間を一切モデル化していない（`document_create_element_ns` は
/// namespace 引数を無視して委譲するのみ）ため、`xmlns`/`xmlns:*` 属性を
/// 祖先チェーンから探索する誠実な実装は行わず、常に「名前空間なし」を表す
/// 値（`lookupNamespaceURI`/`lookupPrefix` は `null`）を返す簡略実装。
/// `isDefaultNamespace(namespace)` は仕様上 `lookupNamespaceURI(null) ===
/// namespace` と等価なので、`lookupNamespaceURI` が常に `null` を返す
/// このモデルでは `namespace` が `null`/`undefined` の時のみ `true` になる。
pub fn dom_lookup_namespace_uri(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Null)
}

pub fn dom_lookup_prefix(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Null)
}

pub fn dom_is_default_namespace(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(matches!(arg(a, 0), Value::Null | Value::Undefined)))
}

pub fn dom_check_visibility(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let visibility = it.dom.borrow().get_computed(idx, "visibility");
        if visibility == "hidden" || visibility == "collapse" {
            return Ok(Value::Bool(false));
        }
        let mut cur = idx;
        let mut guard = 0;
        loop {
            if it.dom.borrow().get_computed(cur, "display") == "none" {
                return Ok(Value::Bool(false));
            }
            let parent = it.dom.borrow().nodes.get(cur).and_then(|n| n.parent);
            match parent {
                Some(p) => {
                    cur = p;
                    guard += 1;
                    if guard > it.dom.borrow().nodes.len() {
                        break;
                    }
                }
                None => break,
            }
        }
        return Ok(Value::Bool(true));
    }
    Ok(Value::Bool(false))
}

/// `node.compareDocumentPosition(other)`（DOM標準）が丸ごと未対応だった。
/// `DomBridge::document_position` にビットマスク計算を委譲する。`other` が DOM ノードで
/// なければ仕様上 `TypeError` だが、この処理系では簡略化して disconnected 扱いにする。
pub fn dom_compare_document_position(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let other = arg(a, 0);
    if let (Some(this_idx), Some(other_idx)) = (this_dom_idx(&this), this_dom_idx(&other)) {
        let mask = it.dom.borrow().document_position(this_idx, other_idx);
        return Ok(Value::Number(mask as f64));
    }
    // DOM ノードでない引数（この処理系では TypeError の代わりに DISCONNECTED 扱い）。
    Ok(Value::Number(1.0))
}

/// classList.replace(oldClass, newClass)。old があれば new に置換し true、無ければ false。
pub fn dom_classlist_replace(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let old = arg(a, 0).to_js_string();
        let new = arg(a, 1).to_js_string();
        let mut dom = it.dom.borrow_mut();
        let had = dom.class_contains(idx, &old);
        if had {
            dom.class_remove(idx, &old);
            dom.class_add(idx, &new);
        }
        return Ok(Value::Bool(had));
    }
    Ok(Value::Bool(false))
}

pub fn dom_remove_child(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let child = arg(a, 0);
    if let (Some(p), Some(c)) = (this_dom_idx(&this), this_dom_idx(&child)) {
        // `insertBefore`/`replaceChild`と同じ理由（詳細はそちらの同種
        // コメント参照）で、`child`が`this`の子でない場合は仕様上
        // `NotFoundError`を投げるべきだが、以前は黙って何もせず成功した
        // かのように振る舞っていた。
        let is_child = it.dom.borrow().nodes.get(c).and_then(|n| n.parent) == Some(p);
        if !is_child {
            return Err(make_dom_exception(
                "NotFoundError",
                "The node to be removed is not a child of this node",
            ));
        }
        it.dom.borrow_mut().remove_child(p, c);
    }
    Ok(child)
}

/// `element.remove()`（`ChildNode.remove()`。引数無しで自身を親から取り外す）。
/// ただし`<select>`だけは`HTMLSelectElement.remove(index)`という別物の
/// オーバーロードを持ち、数値引数が渡された場合は「自身を削除」ではなく
/// 「指定インデックスのoptionを削除」という全く異なる意味になる（仕様上の
/// 別メソッドがたまたま同名なだけ）。以前はこの区別が無く、`select.remove(1)`
/// が常にselect自身を親から削除してしまう（`options`側の削除ではなく）
/// バグだった。
pub fn dom_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let is_select = it.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false);
        if is_select {
            if let Some(v) = a.first() {
                let n = v.to_number();
                if n.is_finite() {
                    // 負のインデックスは仕様上 no-op（`as usize` は負の f64 を 0 へ
                    // 飽和させてしまい、`remove(-1)` が誤って先頭optionを削除する
                    // バグになるため明示的に弾く）。
                    if n >= 0.0 {
                        let options = it.dom.borrow().select_options(idx);
                        if let Some(&opt) = options.get(n as usize) {
                            it.dom.borrow_mut().remove_child(idx, opt);
                        }
                    }
                    return Ok(Value::Undefined);
                }
            }
        }
        it.dom.borrow_mut().remove_node(idx);
    }
    Ok(Value::Undefined)
}

/// ネイティブ関数値を作るショートカット。
pub(crate) fn nv(name: &str, f: NativeFn) -> Value {
    Value::Object(Obj::native(name, f))
}
pub(crate) fn arg(args: &[Value], i: usize) -> Value {
    args.get(i).cloned().unwrap_or(Value::Undefined)
}

/// `HTMLCollection.prototype.item(index)`（DOM Standard §4.2.1）。
pub fn html_collection_item(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let idx_num = arg(a, 0).to_number();
        if idx_num >= 0.0 && idx_num.is_finite() {
            let i = idx_num as usize;
            let borrow = o.borrow();
            if let ObjKind::Array(ref vec) = borrow.kind {
                if let Some(val) = vec.get(i) {
                    return Ok(val.clone());
                }
            }
        }
    }
    Ok(Value::Null)
}

/// `HTMLCollection.prototype.namedItem(name)`（DOM Standard §4.2.1 / HTML Standard §4.10.21）。
/// 同名/同IDのコントロールが複数ある場合は `RadioNodeList` を返す。
pub fn html_collection_named_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let target = arg(a, 0).to_js_string();
        if !target.is_empty() {
            let borrow = o.borrow();
            if let ObjKind::Array(ref vec) = borrow.kind {
                let dom = it.dom.borrow();
                let mut matches: Vec<Value> = Vec::new();
                let mut match_indices: Vec<usize> = Vec::new();
                for val in vec {
                    if let Value::Object(item_obj) = val {
                        if let ObjKind::DomElement(elem_idx) = item_obj.borrow().kind {
                            let id_match = dom.get_attr(elem_idx, "id").map(|id| id == target).unwrap_or(false);
                            let name_match = dom.get_attr(elem_idx, "name").map(|name| name == target).unwrap_or(false);
                            if id_match || name_match {
                                matches.push(val.clone());
                                match_indices.push(elem_idx);
                            }
                        }
                    }
                }
                if matches.len() == 1 {
                    return Ok(matches[0].clone());
                } else if matches.len() > 1 {
                    return Ok(make_radio_node_list(it, match_indices));
                }
            }
        }
    }
    Ok(Value::Null)
}

/// `RadioNodeList` オブジェクトを生成するヘルパー（HTML Standard §4.10.21.1）。
/// 配列構造に加え `.value` (getter/setter) アクセスおよび `item(index)` メソッドをサポートする。
pub fn make_radio_node_list(_it: &Interp, elements: Vec<usize>) -> Value {
    let mut arr: Vec<Value> = Vec::with_capacity(elements.len());
    for &idx in &elements {
        arr.push(Value::Object(Obj::dom(idx)));
    }
    let obj = Obj::array(arr);
    obj.borrow_mut().props.insert("_is_radio_nodelist".into(), Value::Bool(true));
    obj.borrow_mut().props.insert("item".into(), nv("item", html_collection_item));
    Value::Object(obj)
}

/// `HTMLCollection` / `HTMLFormControlsCollection` オブジェクトを生成するヘルパー。
/// 配列機能に加え、DOM Standard §4.2.1 に準拠して `item(index)` および
/// `namedItem(name)` メソッドを持つ。
pub fn make_html_collection(_it: &Interp, elements: Vec<usize>) -> Value {
    let mut arr: Vec<Value> = Vec::with_capacity(elements.len());
    for &idx in &elements {
        arr.push(Value::Object(Obj::dom(idx)));
    }
    let obj = Obj::array(arr);
    obj.borrow_mut().props.insert("item".into(), nv("item", html_collection_item));
    obj.borrow_mut().props.insert("namedItem".into(), nv("namedItem", html_collection_named_item));
    Value::Object(obj)
}

/// `DOMParser.prototype.parseFromString(str, type)` （DOM Parsing and Serialization §4.1）。
/// 入力された HTML 文字列を parse_html でパースし、DomBridge へ組み込んで文書ノードを返却する。
pub fn dom_parser_parse_from_string(it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let html = args.first().map(|v| v.to_js_string()).unwrap_or_default();
    let root = crate::os_lib::dom::parse_html(&html);
    it.dom.borrow_mut().build_from(&root);
    let doc = Obj::host("document");
    {
        let mut d = doc.borrow_mut();
        d.props.insert(
            "getElementById".into(),
            nv("getElementById", document_get_element_by_id),
        );
        d.props.insert(
            "querySelector".into(),
            nv("querySelector", document_query_selector),
        );
        d.props.insert(
            "querySelectorAll".into(),
            nv("querySelectorAll", document_query_selector_all),
        );
    }
    Ok(Value::Object(doc))
}

/// `DOMParser` コンストラクタ。
pub fn dom_parser_ctor(_it: &mut Interp, _this: Value, _args: &[Value]) -> Result<Value, Value> {
    let obj = Obj::plain();
    obj.borrow_mut().props.insert(
        "parseFromString".into(),
        nv("parseFromString", dom_parser_parse_from_string),
    );
    Ok(Value::Object(obj))
}

/// `form.reset()`（HTML5）の実装。
/// フォーム要素配下のすべての `<input>`, `<select>`, `<textarea>` のフォームライブ値を初期状態にリセットする。
pub fn dom_form_reset(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(form_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let child_indices: alloc::vec::Vec<usize> = {
        let dom = it.dom.borrow();
        let mut list = alloc::vec::Vec::new();
        fn collect_descendants(dom: &crate::os_lib::js::dom_bridge::DomBridge, node_idx: usize, out: &mut alloc::vec::Vec<usize>) {
            if let Some(node) = dom.nodes.get(node_idx) {
                for &child in &node.children {
                    out.push(child);
                    collect_descendants(dom, child, out);
                }
            }
        }
        collect_descendants(&dom, form_idx, &mut list);
        list
    };

    let mut dom = it.dom.borrow_mut();
    for idx in child_indices {
        let tag = dom.nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        match tag.as_str() {
            "input" => {
                let ty = dom.get_attr(idx, "type").unwrap_or_default().to_lowercase();
                if ty == "checkbox" || ty == "radio" {
                    let default_checked = dom.has_attr(idx, "checked");
                    dom.set_attr(idx, "_live_checked", if default_checked { "true" } else { "false" });
                } else {
                    let default_val = dom.get_attr(idx, "value").unwrap_or_default();
                    dom.set_attr(idx, "_live_value", &default_val);
                }
            }
            "textarea" => {
                let default_val = dom.get_text_content(idx);
                dom.set_attr(idx, "_live_value", &default_val);
            }
            "select" => {
                dom.remove_attr(idx, "_live_value");
            }
            _ => {}
        }
    }
    Ok(Value::Undefined)
}

/// `<canvas>` 2D context の `measureText(text)` メソッドの実装。
pub fn dom_canvas_measure_text(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let text = args.first().map(|v| v.to_js_string()).unwrap_or_default();
    let width = (text.len() * 8) as f64;
    let obj = Obj::plain();
    {
        let mut b = obj.borrow_mut();
        b.props.insert("width".into(), Value::Number(width));
        b.props.insert("actualBoundingBoxAscent".into(), Value::Number(10.0));
        b.props.insert("actualBoundingBoxDescent".into(), Value::Number(2.0));
        b.props.insert("fontBoundingBoxAscent".into(), Value::Number(10.0));
        b.props.insert("fontBoundingBoxDescent".into(), Value::Number(2.0));
        b.props.insert("actualBoundingBoxLeft".into(), Value::Number(0.0));
        b.props.insert("actualBoundingBoxRight".into(), Value::Number(width));
    }
    Ok(Value::Object(obj))
}

pub fn dom_canvas_get_image_data(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let w = args.get(2).map(|v| v.to_number() as usize).unwrap_or(1).max(1);
    let h = args.get(3).map(|v| v.to_number() as usize).unwrap_or(1).max(1);
    let len = w * h * 4;
    let data_arr = Obj::array(alloc::vec![Value::Number(0.0); len]);
    let img_data = Obj::plain();
    {
        let mut b = img_data.borrow_mut();
        b.props.insert("width".into(), Value::Number(w as f64));
        b.props.insert("height".into(), Value::Number(h as f64));
        b.props.insert("data".into(), Value::Object(data_arr));
    }
    Ok(Value::Object(img_data))
}

/// `createImageData` は**透明で埋めた**新しい `ImageData` を返す（仕様）。
/// 面の内容は読まない。`getImageData` と混同しないこと。
pub fn dom_canvas_create_image_data(
    it: &mut Interp,
    this: Value,
    args: &[Value],
) -> Result<Value, Value> {
    dom_canvas_get_image_data(it, this, args)
}

pub fn dom_canvas_is_point_in_path(_it: &mut Interp, _this: Value, _args: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(false))
}

pub fn dom_canvas_get_transform(it: &mut Interp, _this: Value, _args: &[Value]) -> Result<Value, Value> {
    dom_matrix_ctor(it, Value::Undefined, &[])
}

pub fn dom_canvas_set_line_dash(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let segs = args.first().cloned().unwrap_or(Value::Undefined);
        let items = this_items(&segs);
        let mut nums: alloc::vec::Vec<Value> = items.into_iter().map(|v| Value::Number(v.to_number())).collect();
        if nums.len() % 2 != 0 {
            let dup = nums.clone();
            nums.extend(dup);
        }
        o.borrow_mut().props.insert("_line_dash".into(), Value::Object(Obj::array(nums)));
    }
    Ok(Value::Undefined)
}

pub fn dom_canvas_get_line_dash(_it: &mut Interp, this: Value, _args: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        if let Some(Value::Object(arr)) = o.borrow().props.get("_line_dash") {
            let items = this_items(&Value::Object(arr.clone()));
            return Ok(Value::Object(Obj::array(items)));
        }
    }
    Ok(Value::Object(Obj::array(alloc::vec![])))
}

pub fn dom_canvas_round_rect(_it: &mut Interp, _this: Value, _args: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}

/// `<canvas>` 2D context の `reset()` メソッド (WHATWG HTML Standard)。
pub fn dom_canvas_reset(_it: &mut Interp, this: Value, _args: &[Value]) -> Result<Value, Value> {
    if let Value::Object(ref ctx) = this {
        let mut b = ctx.borrow_mut();
        b.props.insert("fillStyle".into(), Value::str("#000000"));
        b.props.insert("strokeStyle".into(), Value::str("#000000"));
        b.props.insert("lineWidth".into(), Value::Number(1.0));
        b.props.insert("lineCap".into(), Value::str("butt"));
        b.props.insert("lineJoin".into(), Value::str("miter"));
        b.props.insert("miterLimit".into(), Value::Number(10.0));
        b.props.insert("lineDashOffset".into(), Value::Number(0.0));
        b.props.insert("font".into(), Value::str("10px sans-serif"));
        b.props.insert("textAlign".into(), Value::str("start"));
        b.props.insert("textBaseline".into(), Value::str("alphabetic"));
        b.props.insert("globalAlpha".into(), Value::Number(1.0));
        b.props.insert("globalCompositeOperation".into(), Value::str("source-over"));
        b.props.insert("shadowBlur".into(), Value::Number(0.0));
        b.props.insert("shadowColor".into(), Value::str("rgba(0, 0, 0, 0)"));
        b.props.insert("shadowOffsetX".into(), Value::Number(0.0));
        b.props.insert("shadowOffsetY".into(), Value::Number(0.0));
        b.props.insert("imageSmoothingEnabled".into(), Value::Bool(true));
        b.props.insert("direction".into(), Value::str("inherit"));
        b.props.insert("filter".into(), Value::str("none"));
        b.props.shift_remove("_line_dash");
    }
    Ok(Value::Undefined)
}

/// `Path2D` コンストラクタ (WHATWG HTML Canvas 2D Path2D API)。
pub fn dom_path2d_ctor(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let p = Obj::plain();
    {
        let mut b = p.borrow_mut();
        let path_data = args.first().map(|v| v.to_js_string()).unwrap_or_default();
        b.props.insert("_path_data".into(), Value::str(&path_data));
        for m in [
            "addPath", "closePath", "moveTo", "lineTo", "arc", "arcTo",
            "rect", "roundRect", "ellipse", "bezierCurveTo", "quadraticCurveTo"
        ] {
            b.props.insert(m.into(), nv(m, dom_noop));
        }
    }
    Ok(Value::Object(p))
}

/// `<canvas>` 2D context の `createLinearGradient` / `createRadialGradient` / `createConicGradient` のヘルパー。
pub fn dom_canvas_create_gradient(_it: &mut Interp, _this: Value, _args: &[Value]) -> Result<Value, Value> {
    let grad = Obj::plain();
    grad.borrow_mut().props.insert(
        "addColorStop".into(),
        nv("addColorStop", dom_noop),
    );
    Ok(Value::Object(grad))
}

/// `<canvas>` 要素の `getContext(contextId, options?)` (HTML5 Canvas 2D Context API)。
pub fn dom_canvas_get_context(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    let ctx_type = args.first().map(|v| v.to_js_string()).unwrap_or_default();
    if ctx_type.eq_ignore_ascii_case("2d") {
        // 面のサイズは `<canvas width height>` 属性から取る。
        // 属性が無い場合の既定は仕様どおり 300x150。
        // `this` はこの後 props へ move されるので、その前に読む。
        let (cw, ch) = match &this {
            Value::Object(o) => {
                let kind = o.borrow().kind.clone();
                if let ObjKind::DomElement(idx) = kind {
                    let d = _it.dom.borrow();
                    let w = d
                        .get_attr(idx, "width")
                        .and_then(|s| s.trim().parse::<u32>().ok())
                        .unwrap_or(300);
                    let h = d
                        .get_attr(idx, "height")
                        .and_then(|s| s.trim().parse::<u32>().ok())
                        .unwrap_or(150);
                    (w, h)
                } else {
                    (300, 150)
                }
            }
            _ => (300, 150),
        };
        let c2d_id = crate::os_lib::canvas2d::create_context(cw, ch);
        // レイアウト側（`web_engine/layout.rs`）は `StyledNode` しか見ないので、
        // id を DOM 属性へ書いて橋渡しする。JS のオブジェクトを直接引かせると
        // 層をまたぐ依存になる。
        if let (Some(id), Value::Object(o)) = (c2d_id, &this) {
            let kind = o.borrow().kind.clone();
            if let ObjKind::DomElement(idx) = kind {
                _it.dom
                    .borrow_mut()
                    .set_attr(idx, "_c2d_id", &alloc::format!("{}", id));
            }
        }
        let ctx = Obj::plain();
        {
            let mut b = ctx.borrow_mut();
            b.props.insert("canvas".into(), this);
            b.props.insert("fillStyle".into(), Value::str("#000000"));
            b.props.insert("strokeStyle".into(), Value::str("#000000"));
            b.props.insert("lineWidth".into(), Value::Number(1.0));
            b.props.insert("lineCap".into(), Value::str("butt"));
            b.props.insert("lineJoin".into(), Value::str("miter"));
            b.props.insert("miterLimit".into(), Value::Number(10.0));
            b.props.insert("lineDashOffset".into(), Value::Number(0.0));
            b.props.insert("font".into(), Value::str("10px sans-serif"));
            b.props.insert("textAlign".into(), Value::str("start"));
            b.props.insert("textBaseline".into(), Value::str("alphabetic"));
            b.props.insert("globalAlpha".into(), Value::Number(1.0));
            b.props.insert("globalCompositeOperation".into(), Value::str("source-over"));
            b.props.insert("shadowBlur".into(), Value::Number(0.0));
            b.props.insert("shadowColor".into(), Value::str("rgba(0, 0, 0, 0)"));
            b.props.insert("shadowOffsetX".into(), Value::Number(0.0));
            b.props.insert("shadowOffsetY".into(), Value::Number(0.0));
            b.props.insert("imageSmoothingEnabled".into(), Value::Bool(true));
            b.props.insert("direction".into(), Value::str("inherit"));
            b.props.insert("filter".into(), Value::str("none"));
            // 【2026-09-03】実描画へ接続する。従来これらは全て `dom_noop` で、
            // API 表面だけが存在し canvas は一切描画されなかった。
            // 幾何・ラスタライズは `os_lib/canvas2d.rs`（試験済み）にあり、
            // ここは registry の id を持たせて各メソッドから引くだけにする。
            if let Some(id) = c2d_id {
                b.props.insert("_c2d_id".into(), Value::Number(id as f64));
            }

            // 【2026-09-03】実描画へ接続する。
            //
            // 従来これらは全て `dom_noop` で、API 表面だけが存在し
            // canvas は一切描画されなかった。`os_lib/canvas2d.rs` の
            // `Canvas2dContext`（試験済み）を registry へ作り、その id を
            // `_c2d_id` として持たせて各メソッドから引く。
            //
            b.props.insert("fillRect".into(), nv("fillRect", canvas_fill_rect));
            b.props.insert("strokeRect".into(), nv("strokeRect", canvas_stroke_rect));
            b.props.insert("clearRect".into(), nv("clearRect", canvas_clear_rect));

            b.props.insert("beginPath".into(), nv("beginPath", canvas_begin_path));
            b.props.insert("closePath".into(), nv("closePath", canvas_close_path));
            b.props.insert("moveTo".into(), nv("moveTo", canvas_move_to));
            b.props.insert("lineTo".into(), nv("lineTo", canvas_line_to));
            b.props.insert("arc".into(), nv("arc", canvas_arc));
            b.props.insert("arcTo".into(), nv("arcTo", dom_noop));
            b.props.insert("bezierCurveTo".into(), nv("bezierCurveTo", canvas_bezier_curve_to));
            b.props.insert("quadraticCurveTo".into(), nv("quadraticCurveTo", canvas_quadratic_curve_to));
            b.props.insert("ellipse".into(), nv("ellipse", canvas_ellipse));
            b.props.insert("rect".into(), nv("rect", canvas_rect));
            b.props.insert("roundRect".into(), nv("roundRect", canvas_round_rect));

            b.props.insert("fill".into(), nv("fill", canvas_fill));
            b.props.insert("stroke".into(), nv("stroke", canvas_stroke));
            b.props.insert("clip".into(), nv("clip", canvas_clip));

            b.props.insert("fillText".into(), nv("fillText", canvas_fill_text));
            b.props.insert("strokeText".into(), nv("strokeText", canvas_fill_text));
            b.props.insert("measureText".into(), nv("measureText", canvas_measure_text));

            b.props.insert("drawImage".into(), nv("drawImage", canvas_draw_image));
            b.props.insert("getImageData".into(), nv("getImageData", canvas_get_image_data));
            b.props.insert("createImageData".into(), nv("createImageData", dom_canvas_create_image_data));
            b.props.insert("putImageData".into(), nv("putImageData", canvas_put_image_data));
            b.props.insert("isPointInPath".into(), nv("isPointInPath", dom_canvas_is_point_in_path));
            b.props.insert("isPointInStroke".into(), nv("isPointInStroke", dom_canvas_is_point_in_path));
            b.props.insert("getTransform".into(), nv("getTransform", dom_canvas_get_transform));
            b.props.insert("setLineDash".into(), nv("setLineDash", dom_canvas_set_line_dash));
            b.props.insert("getLineDash".into(), nv("getLineDash", dom_canvas_get_line_dash));
            b.props.insert("reset".into(), nv("reset", dom_canvas_reset));

            b.props.insert("createLinearGradient".into(), nv("createLinearGradient", dom_canvas_create_gradient));
            b.props.insert("createRadialGradient".into(), nv("createRadialGradient", dom_canvas_create_gradient));
            b.props.insert("createConicGradient".into(), nv("createConicGradient", dom_canvas_create_gradient));
            b.props.insert("createPattern".into(), nv("createPattern", dom_canvas_create_gradient));

            b.props.insert("save".into(), nv("save", canvas_save));
            b.props.insert("restore".into(), nv("restore", canvas_restore));
            b.props.insert("scale".into(), nv("scale", canvas_scale));
            b.props.insert("rotate".into(), nv("rotate", canvas_rotate));
            b.props.insert("translate".into(), nv("translate", canvas_translate));
            b.props.insert("transform".into(), nv("transform", canvas_transform));
            b.props.insert("setTransform".into(), nv("setTransform", canvas_set_transform));
            b.props.insert("resetTransform".into(), nv("resetTransform", canvas_reset_transform));
        }
        return Ok(Value::Object(ctx));
    } else if ctx_type.eq_ignore_ascii_case("webgl") || ctx_type.eq_ignore_ascii_case("webgl2") || ctx_type.eq_ignore_ascii_case("bitmaprenderer") {
        let ctx = Obj::plain();
        ctx.borrow_mut().props.insert("canvas".into(), this);
        return Ok(Value::Object(ctx));
    }
    Ok(Value::Null)
}

/// `<canvas>` 要素の `toDataURL(type, quality)` (HTML5 Canvas)。
pub fn dom_canvas_to_data_url(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let mime = args.first().map(|v| v.to_js_string()).unwrap_or_else(|| String::from("image/png"));
    let header = if mime.eq_ignore_ascii_case("image/jpeg") {
        "data:image/jpeg;base64,"
    } else if mime.eq_ignore_ascii_case("image/webp") {
        "data:image/webp;base64,"
    } else {
        "data:image/png;base64,"
    };
    // 1x1 透明 PNG の最小限データ URL
    let dummy_base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
    Ok(Value::str(alloc::format!("{}{}", header, dummy_base64)))
}

/// `<canvas>` 要素の `toBlob(callback, type, quality)` (HTML5 Canvas)。
pub fn dom_canvas_to_blob(it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let cb = args.first().cloned().unwrap_or(Value::Undefined);
    let mime = args.get(1).map(|v| v.to_js_string()).unwrap_or_else(|| String::from("image/png"));
    if matches!(cb, Value::Object(_)) {
        let blob = Obj::plain();
        {
            let mut b = blob.borrow_mut();
            b.props.insert("size".into(), Value::Number(68.0));
            b.props.insert("type".into(), Value::str(mime));
        }
        it.call_value(&cb, Value::Undefined, &[Value::Object(blob)])?;
    }
    Ok(Value::Undefined)
}


// ───────────── Canvas 2D の実描画（2026-09-03 追加） ─────────────
//
// これらは以前すべて `dom_noop` に接続されており、API 表面だけが存在して
// 一切描画されなかった。幾何とラスタライズは `os_lib/canvas2d.rs`
// （純粋モジュール・試験済み）にあり、ここは「JS の値を取り出して
// コンテキストへ渡す」薄い層に徹する。

/// コンテキストオブジェクトから registry の id を取り出す。
fn canvas_ctx_id(this: &Value) -> Option<u32> {
    match this {
        Value::Object(o) => match o.borrow().props.get("_c2d_id") {
            Some(Value::Number(n)) if *n >= 0.0 => Some(*n as u32),
            _ => None,
        },
        _ => None,
    }
}

/// 引数を f32 で取る。非有限値は 0 とみなす（描画系でパニックさせない）。
fn canvas_arg_f32(a: &[Value], i: usize) -> f32 {
    let v = a.get(i).map(|v| v.to_number()).unwrap_or(0.0);
    if v.is_finite() {
        v as f32
    } else {
        0.0
    }
}

/// JS 側のスタイル文字列を ARGB へ解決する。
///
/// CSS の色解析（`css::parse_color`）をそのまま使う。解釈できない値は
/// 仕様上「無視して直前の値を保つ」だが、ここでは不透明な黒へ倒す
/// （描かれないより、既定色で描かれた方が原因に気づきやすい）。
fn canvas_style_argb(this: &Value, key: &str) -> u32 {
    let s = match this {
        Value::Object(o) => o
            .borrow()
            .props
            .get(key)
            .map(|v| v.to_js_string())
            .unwrap_or_default(),
        _ => String::new(),
    };
    crate::os_lib::css::parse_color(&s).unwrap_or(0xFF00_0000)
}

/// 描画前に、JS 側で書き換えられた状態をコンテキストへ反映する。
///
/// `fillStyle` 等は JS の素のプロパティなので、代入は検知できない。
/// 各描画メソッドの入口で毎回読み直すのが確実。
fn canvas_sync_state(this: &Value, ctx: &mut crate::os_lib::canvas2d::Canvas2dContext) {
    ctx.state.fill = canvas_style_argb(this, "fillStyle");
    ctx.state.stroke = canvas_style_argb(this, "strokeStyle");
    if let Value::Object(o) = this {
        let b = o.borrow();
        if let Some(Value::Number(n)) = b.props.get("globalAlpha") {
            if n.is_finite() {
                ctx.state.global_alpha = (*n as f32).clamp(0.0, 1.0);
            }
        }
        if let Some(Value::Number(n)) = b.props.get("lineWidth") {
            if n.is_finite() && *n > 0.0 {
                ctx.state.line_width = *n as f32;
            }
        }
        // 未知の値は無視して既定を保つ（仕様どおり代入を捨てる）。
        if let Some(Value::Str(s)) = b.props.get("lineCap") {
            if let Some(v) = crate::os_lib::canvas2d::parse_line_cap(s) {
                ctx.state.line_cap = v;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("lineJoin") {
            if let Some(v) = crate::os_lib::canvas2d::parse_line_join(s) {
                ctx.state.line_join = v;
            }
        }
        if let Some(Value::Number(n)) = b.props.get("miterLimit") {
            if n.is_finite() && *n > 0.0 {
                ctx.state.miter_limit = *n as f32;
            }
        }
        // `setLineDash` が入れた配列。値の検査は `normalize_dash` に任せる
        // （不正なパターンはまるごと捨てるのが仕様）。
        ctx.state.line_dash.clear();
        if let Some(Value::Object(arr)) = b.props.get("_line_dash") {
            let ab = arr.borrow();
            if let ObjKind::Array(items) = &ab.kind {
                for v in items {
                    ctx.state.line_dash.push(v.to_number() as f32);
                }
            }
        }
        if let Some(Value::Number(n)) = b.props.get("lineDashOffset") {
            if n.is_finite() {
                ctx.state.line_dash_offset = *n as f32;
            }
        }
    }
}

pub fn canvas_fill_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            c.fill_rect(x, y, w, h);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_stroke_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            // `strokeRect` は現在のパスを変更しない（仕様）。
            // 別のパスを組んで線描する。
            let mut p = crate::os_lib::canvas2d::PathBuilder::new();
            p.rect(&c.state.transform, x, y, w, h);
            let color = c.apply_alpha(c.state.stroke);
            let lw = c.state.line_width;
            let (cap, join, limit) =
                (c.state.line_cap, c.state.line_join, c.state.miter_limit);
            let sub = c.apply_dash(&p.finish());
            c.surface
                .stroke_path_styled(&sub, color, lw, cap, join, limit);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_clear_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| c.clear_rect(x, y, w, h));
    }
    Ok(Value::Undefined)
}

pub fn canvas_begin_path(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| c.path.begin_path());
    }
    Ok(Value::Undefined)
}

pub fn canvas_close_path(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| c.path.close_path());
    }
    Ok(Value::Undefined)
}

pub fn canvas_move_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.move_to(&m, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_line_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.line_to(&m, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.rect(&m, x, y, w, h);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_arc(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (cx, cy, r) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
        );
        let start = canvas_arg_f32(a, 3);
        let end = canvas_arg_f32(a, 4);
        let ccw = a.get(5).map(|v| v.truthy()).unwrap_or(false);
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.arc(&m, cx, cy, r, start, end, ccw);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_fill(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        // 第 1 引数は塗りつぶし規則（省略時は nonzero）。
        let rule = match a.first().map(|v| v.to_js_string()) {
            Some(s) if s.eq_ignore_ascii_case("evenodd") => {
                crate::os_lib::canvas2d::FillRule::EvenOdd
            }
            _ => crate::os_lib::canvas2d::FillRule::NonZero,
        };
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            c.fill(rule);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_stroke(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            // `lineWidth` を反映する（1 以下なら 1px 線の高速路へ落ちる）。
            c.stroke_with_width();
        });
    }
    Ok(Value::Undefined)
}


/// `save()` — 現在の描画状態を退避する。
pub fn canvas_save(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| {
            // JS 側で書き換えられた状態も含めて退避したいので、
            // 先に読み直してから積む。
            canvas_sync_state(&this, c);
            c.save();
        });
    }
    Ok(Value::Undefined)
}

/// `restore()` — 直近の退避状態へ戻す。
///
/// 変換だけでなく `fillStyle` 等も戻すのが仕様だが、それらは JS の素の
/// プロパティなので、Rust 側で戻した値を JS へ書き戻す必要がある。
pub fn canvas_restore(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let restored = crate::os_lib::canvas2d::with_context(id, |c| {
            c.restore();
            (c.state.global_alpha, c.state.line_width)
        });
        // `globalAlpha`/`lineWidth` は JS からも読めるので書き戻す。
        // 色は文字列表現を保持していないため戻せない（既知の割り切り）。
        if let (Some((ga, lw)), Value::Object(o)) = (restored, &this) {
            let mut b = o.borrow_mut();
            b.props.insert("globalAlpha".into(), Value::Number(ga as f64));
            b.props.insert("lineWidth".into(), Value::Number(lw as f64));
        }
    }
    Ok(Value::Undefined)
}

pub fn canvas_translate(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (tx, ty) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| c.translate(tx, ty));
    }
    Ok(Value::Undefined)
}

pub fn canvas_scale(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (sx, sy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| c.scale(sx, sy));
    }
    Ok(Value::Undefined)
}

pub fn canvas_rotate(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let rad = canvas_arg_f32(a, 0);
        crate::os_lib::canvas2d::with_context(id, |c| c.rotate(rad));
    }
    Ok(Value::Undefined)
}

/// `transform(a,b,c,d,e,f)` — 現在の行列へ右から掛ける。
pub fn canvas_transform(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let m = crate::os_lib::canvas2d::Matrix {
            a: canvas_arg_f32(a, 0),
            b: canvas_arg_f32(a, 1),
            c: canvas_arg_f32(a, 2),
            d: canvas_arg_f32(a, 3),
            e: canvas_arg_f32(a, 4),
            f: canvas_arg_f32(a, 5),
        };
        crate::os_lib::canvas2d::with_context(id, |ctx| {
            let cur = ctx.state.transform;
            ctx.set_transform(cur.multiply(&m));
        });
    }
    Ok(Value::Undefined)
}

/// `setTransform(a,b,c,d,e,f)` — 行列を置き換える（積まない）。
pub fn canvas_set_transform(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let m = crate::os_lib::canvas2d::Matrix {
            a: canvas_arg_f32(a, 0),
            b: canvas_arg_f32(a, 1),
            c: canvas_arg_f32(a, 2),
            d: canvas_arg_f32(a, 3),
            e: canvas_arg_f32(a, 4),
            f: canvas_arg_f32(a, 5),
        };
        crate::os_lib::canvas2d::with_context(id, |ctx| ctx.set_transform(m));
    }
    Ok(Value::Undefined)
}

pub fn canvas_reset_transform(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| c.reset_transform());
    }
    Ok(Value::Undefined)
}

pub fn canvas_bezier_curve_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (c1x, c1y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (c2x, c2y) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let (x, y) = (canvas_arg_f32(a, 4), canvas_arg_f32(a, 5));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.bezier_curve_to(&m, c1x, c1y, c2x, c2y, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_quadratic_curve_to(
    _it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (x, y) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.quadratic_curve_to(&m, cx, cy, x, y);
        });
    }
    Ok(Value::Undefined)
}


/// `ellipse(cx, cy, rx, ry, rotation, start, end, anticlockwise)`。
pub fn canvas_ellipse(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (rx, ry) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let rot = canvas_arg_f32(a, 4);
        let start = canvas_arg_f32(a, 5);
        let end = canvas_arg_f32(a, 6);
        let ccw = a.get(7).map(|v| v.truthy()).unwrap_or(false);
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.ellipse(&m, cx, cy, rx, ry, rot, start, end, ccw);
        });
    }
    Ok(Value::Undefined)
}

/// `roundRect(x, y, w, h, radii)`。
///
/// `radii` は数値 1 個・配列（1〜4 要素）のどちらも取りうる。
/// CSS の `border-radius` と同じ補完規則（1 個なら全隅、2 個なら
/// 対角の組、3 個なら左上・対角・右下）に従う。
pub fn canvas_round_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (w, h) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        // 半径の取り出し。配列でなければ単一値として扱う。
        let vals: alloc::vec::Vec<f32> = match a.get(4) {
            Some(Value::Object(o)) => {
                let b = o.borrow();
                if let ObjKind::Array(items) = &b.kind {
                    items
                        .iter()
                        .map(|v| {
                            let n = v.to_number();
                            if n.is_finite() {
                                n as f32
                            } else {
                                0.0
                            }
                        })
                        .collect()
                } else {
                    alloc::vec![0.0]
                }
            }
            Some(v) => {
                let n = v.to_number();
                alloc::vec![if n.is_finite() { n as f32 } else { 0.0 }]
            }
            None => alloc::vec![0.0],
        };
        // CSS の border-radius と同じ補完規則。
        let radii = match vals.len() {
            0 => [0.0; 4],
            1 => [vals[0]; 4],
            2 => [vals[0], vals[1], vals[0], vals[1]],
            3 => [vals[0], vals[1], vals[2], vals[1]],
            _ => [vals[0], vals[1], vals[2], vals[3]],
        };
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.round_rect(&m, x, y, w, h, radii);
        });
    }
    Ok(Value::Undefined)
}


/// `clip(fillRule)`。現在のパスでクリップ領域を狭める。
///
/// 引数にパスを渡す形（`clip(path, rule)`）は `Path2D` が未実装のため
/// 対応しない。現在のパスを使う形だけを扱う。
pub fn canvas_clip(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let rule = match a.first().map(|v| v.to_js_string()) {
            Some(s) if s.eq_ignore_ascii_case("evenodd") => {
                crate::os_lib::canvas2d::FillRule::EvenOdd
            }
            _ => crate::os_lib::canvas2d::FillRule::NonZero,
        };
        crate::os_lib::canvas2d::with_context(id, |c| {
            c.clip(rule);
        });
    }
    Ok(Value::Undefined)
}


/// `getImageData(x, y, w, h)`。面の内容を読んで `ImageData` を返す。
///
/// コンテキストが無い（`getContext` を経ていない）場合は、
/// 従来どおり透明で埋めた配列を返す。
pub fn canvas_get_image_data(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return dom_canvas_get_image_data(it, this, a);
    };
    let (x, y) = (canvas_arg_f32(a, 0) as i32, canvas_arg_f32(a, 1) as i32);
    let w = (canvas_arg_f32(a, 2) as i32).max(0);
    let h = (canvas_arg_f32(a, 3) as i32).max(0);
    let bytes = crate::os_lib::canvas2d::with_context(id, |c| {
        crate::os_lib::canvas2d::get_image_data(&c.surface, x, y, w, h)
    });
    let Some(bytes) = bytes else {
        return dom_canvas_get_image_data(it, this, a);
    };
    let items: alloc::vec::Vec<Value> = bytes
        .into_iter()
        .map(|b| Value::Number(b as f64))
        .collect();
    let img = Obj::plain();
    {
        let mut b = img.borrow_mut();
        b.props.insert("width".into(), Value::Number(w as f64));
        b.props.insert("height".into(), Value::Number(h as f64));
        b.props.insert("data".into(), Value::Object(Obj::array(items)));
    }
    Ok(Value::Object(img))
}

/// `putImageData(imageData, dx, dy)`。
///
/// 合成せず上書きし、クリップも無視する（仕様。`fill` 系と意味論が違う）。
pub fn canvas_put_image_data(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let Some(Value::Object(img)) = a.first() else {
        return Ok(Value::Undefined);
    };
    let (w, h, bytes) = {
        let b = img.borrow();
        let w = b
            .props
            .get("width")
            .map(|v| v.to_number() as i32)
            .unwrap_or(0);
        let h = b
            .props
            .get("height")
            .map(|v| v.to_number() as i32)
            .unwrap_or(0);
        let mut bytes: alloc::vec::Vec<u8> = alloc::vec::Vec::new();
        if let Some(Value::Object(arr)) = b.props.get("data") {
            let ab = arr.borrow();
            if let ObjKind::Array(items) = &ab.kind {
                bytes.reserve(items.len());
                for v in items {
                    let n = v.to_number();
                    // 仕様どおり 0〜255 へ丸めて収める。
                    bytes.push(if n.is_finite() {
                        n.clamp(0.0, 255.0) as u8
                    } else {
                        0
                    });
                }
            }
        }
        (w, h, bytes)
    };
    let (dx, dy) = (canvas_arg_f32(a, 1) as i32, canvas_arg_f32(a, 2) as i32);
    crate::os_lib::canvas2d::with_context(id, |c| {
        crate::os_lib::canvas2d::put_image_data(&mut c.surface, &bytes, w, h, dx, dy);
    });
    Ok(Value::Undefined)
}


/// `drawImage` の転送元。`<img>` と別の canvas を扱う。
enum DrawSrc {
    /// デコード済み画像（`<img>`）。
    Image(alloc::sync::Arc<crate::os_lib::web_engine::DecodedImage>),
    /// 別の canvas の画素を RGBA8 へ写したもの。
    Canvas(u32, u32, alloc::vec::Vec<u8>),
}

/// 転送元の値から画素を取り出す。
///
/// `<img>` は `src` 属性で共有の置き場を引く。
/// canvas は `_c2d_id` からコンテキストを引いて画素を写す
/// （同じコンテキストを二重に借りないよう、ここで写しを作る）。
fn draw_src_from(it: &mut Interp, v: &Value) -> Option<DrawSrc> {
    let Value::Object(o) = v else {
        return None;
    };
    let idx = match o.borrow().kind {
        ObjKind::DomElement(i) => Some(i),
        _ => None,
    }?;
    let (tag, src, cid) = {
        let dom = it.dom.borrow();
        let tag = dom.nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        let src = dom.get_attr(idx, "src").unwrap_or_default();
        let cid = dom
            .get_attr(idx, "_c2d_id")
            .and_then(|s| s.parse::<u32>().ok());
        (tag, src, cid)
    };
    if tag == "canvas" {
        let id = cid?;
        return crate::os_lib::canvas2d::with_context(id, |c| {
            let (w, h) = (c.surface.width, c.surface.height);
            DrawSrc::Canvas(w, h, crate::os_lib::canvas2d::get_image_data(
                &c.surface, 0, 0, w as i32, h as i32,
            ))
        });
    }
    crate::os_lib::web_engine::shared_image(&src).map(DrawSrc::Image)
}

/// `drawImage(img, dx, dy)` / `(img, dx, dy, dw, dh)` /
/// `(img, sx, sy, sw, sh, dx, dy, dw, dh)`。
pub fn canvas_draw_image(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let Some(src) = a.first().and_then(|v| draw_src_from(it, v)) else {
        return Ok(Value::Undefined);
    };
    let (sw, sh, bytes): (u32, u32, &[u8]) = match &src {
        DrawSrc::Image(img) => (img.width, img.height, &img.rgba),
        DrawSrc::Canvas(w, h, b) => (*w, *h, b),
    };
    // 引数の個数で意味が変わる（仕様）。3・5・9 個のいずれか。
    let spec = match a.len() {
        0..=2 => return Ok(Value::Undefined),
        3 | 4 => crate::os_lib::canvas2d::BlitSpec {
            sx: 0.0,
            sy: 0.0,
            sw: sw as f32,
            sh: sh as f32,
            dx: canvas_arg_f32(a, 1),
            dy: canvas_arg_f32(a, 2),
            dw: sw as f32,
            dh: sh as f32,
        },
        5..=8 => crate::os_lib::canvas2d::BlitSpec {
            sx: 0.0,
            sy: 0.0,
            sw: sw as f32,
            sh: sh as f32,
            dx: canvas_arg_f32(a, 1),
            dy: canvas_arg_f32(a, 2),
            dw: canvas_arg_f32(a, 3),
            dh: canvas_arg_f32(a, 4),
        },
        _ => crate::os_lib::canvas2d::BlitSpec {
            sx: canvas_arg_f32(a, 1),
            sy: canvas_arg_f32(a, 2),
            sw: canvas_arg_f32(a, 3),
            sh: canvas_arg_f32(a, 4),
            dx: canvas_arg_f32(a, 5),
            dy: canvas_arg_f32(a, 6),
            dw: canvas_arg_f32(a, 7),
            dh: canvas_arg_f32(a, 8),
        },
    };
    let image = crate::os_lib::canvas2d::ImageSource {
        width: sw,
        height: sh,
        rgba: bytes,
    };
    crate::os_lib::canvas2d::with_context(id, |c| {
        canvas_sync_state(&this, c);
        c.sync_clip();
        let m = c.state.transform;
        let alpha = c.state.global_alpha;
        c.surface.draw_image(&image, &spec, &m, alpha);
    });
    Ok(Value::Undefined)
}


/// 1 文字ぶんの字形を、フォントの錠を**持たずに**扱えるよう写したもの。
struct OwnedGlyph {
    width: u32,
    height: u32,
    x_offset: i32,
    y_offset: i32,
    advance: f32,
    alpha: alloc::vec::Vec<u8>,
}

/// 文字列ぶんの字形を取り出す。
///
/// 【重要】フォントの錠を**描画中に持ち続けない**。
/// `GLOBAL_VECTOR_FONT` は毎フレームの文字描画が使う。低優先度の側が
/// 握ったまま長く走ると、提示ループが `spin::Mutex` で回り続けて
/// 優先度逆転を起こす（`image_results_ready` で実際に踏んだ）。
/// ここで写しを作って錠を放し、描画は錠の外で行う。
fn glyphs_for(text: &str, size_px: u32) -> alloc::vec::Vec<OwnedGlyph> {
    let mut out = alloc::vec::Vec::new();
    let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
    let Some(font) = font_lock.as_mut() else {
        return out;
    };
    for c in text.chars() {
        if let Some(g) = font.get_glyph(c, size_px) {
            out.push(OwnedGlyph {
                width: g.width,
                height: g.height,
                x_offset: g.x_offset,
                y_offset: g.y_offset,
                advance: g.advance as f32,
                alpha: g.data.clone(),
            });
        }
    }
    out
}

/// コンテキストの `font` から文字の大きさ（px）を得る。既定は 10px。
fn canvas_font_size(this: &Value) -> f32 {
    let Value::Object(o) = this else {
        return 10.0;
    };
    let b = o.borrow();
    let Some(Value::Str(s)) = b.props.get("font") else {
        return 10.0;
    };
    crate::os_lib::canvas2d::parse_font_size(s).unwrap_or(10.0)
}

/// `fillText(text, x, y)`。
///
/// `strokeText` も同じ処理へ回す。線でなぞる形は未対応で、
/// 塗りで代用する（何も描かないよりは近い）。
pub fn canvas_fill_text(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let text = a.first().map(|v| v.to_js_string()).unwrap_or_default();
    if text.is_empty() {
        return Ok(Value::Undefined);
    }
    let (x, y) = (canvas_arg_f32(a, 1), canvas_arg_f32(a, 2));
    if !x.is_finite() || !y.is_finite() {
        return Ok(Value::Undefined);
    }
    let size = canvas_font_size(&this);
    let glyphs = glyphs_for(&text, size as u32);
    if glyphs.is_empty() {
        return Ok(Value::Undefined);
    }
    let total: f32 = glyphs.iter().map(|g| g.advance).sum();

    let (align, baseline) = {
        let mut al = crate::os_lib::canvas2d::TextAlign::Start;
        let mut bl = crate::os_lib::canvas2d::TextBaseline::Alphabetic;
        if let Value::Object(o) = &this {
            let b = o.borrow();
            if let Some(Value::Str(s)) = b.props.get("textAlign") {
                if let Some(v) = crate::os_lib::canvas2d::parse_text_align(s) {
                    al = v;
                }
            }
            if let Some(Value::Str(s)) = b.props.get("textBaseline") {
                if let Some(v) = crate::os_lib::canvas2d::parse_text_baseline(s) {
                    bl = v;
                }
            }
        }
        (al, bl)
    };
    let x0 = x + crate::os_lib::canvas2d::align_offset(align, total);
    let y0 = y + crate::os_lib::canvas2d::baseline_offset(baseline, size);

    crate::os_lib::canvas2d::with_context(id, |c| {
        canvas_sync_state(&this, c);
        c.sync_clip();
        let color = c.apply_alpha(c.state.fill);
        let m = c.state.transform;
        let mut pen = x0;
        for g in &glyphs {
            let bm = crate::os_lib::canvas2d::GlyphBitmap {
                width: g.width,
                height: g.height,
                x_offset: g.x_offset,
                y_offset: g.y_offset,
                advance: g.advance,
                alpha: &g.alpha,
            };
            c.surface.draw_glyph(&bm, pen, y0, color, &m);
            pen += g.advance;
        }
    });
    Ok(Value::Undefined)
}

/// `measureText(text)`。
///
/// 従来はバイト長 × 8 を返していた。日本語では実際と大きくずれ、
/// `font` の大きさも無視していた。字形の送り幅を実測する。
pub fn canvas_measure_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let text = a.first().map(|v| v.to_js_string()).unwrap_or_default();
    let size = canvas_font_size(&this);
    let glyphs = glyphs_for(&text, size as u32);
    if glyphs.is_empty() && !text.is_empty() {
        // フォントが無い（未初期化）ときは従来の概算へ落ちる。
        return dom_canvas_measure_text(it, this, a);
    }
    let width: f32 = glyphs.iter().map(|g| g.advance).sum();
    let obj = Obj::plain();
    {
        let mut b = obj.borrow_mut();
        b.props.insert("width".into(), Value::Number(width as f64));
        // 上下の張り出しは字形の実測から出す。
        let ascent = glyphs
            .iter()
            .map(|g| -g.y_offset)
            .max()
            .unwrap_or(0)
            .max(0) as f64;
        let descent = glyphs
            .iter()
            .map(|g| g.y_offset + g.height as i32)
            .max()
            .unwrap_or(0)
            .max(0) as f64;
        b.props
            .insert("actualBoundingBoxAscent".into(), Value::Number(ascent));
        b.props
            .insert("actualBoundingBoxDescent".into(), Value::Number(descent));
        b.props.insert(
            "fontBoundingBoxAscent".into(),
            Value::Number((size * 0.85) as f64),
        );
        b.props.insert(
            "fontBoundingBoxDescent".into(),
            Value::Number((size * 0.15) as f64),
        );
        b.props
            .insert("actualBoundingBoxLeft".into(), Value::Number(0.0));
        b.props.insert(
            "actualBoundingBoxRight".into(),
            Value::Number(width as f64),
        );
    }
    Ok(Value::Object(obj))
}