atmos/os_lib/js/interp/

dom_props.rs

// 分割: interp.rs の `impl Interp` から機械的に移動（2026-07-16 リファクタ フェーズ5）。
// ロジック不変。メソッド可視性のみ pub(crate) へ昇格（別モジュールの impl Interp
// からの self 呼び出しのため）。impl ブロックは型 Interp に自動で結合する。
use super::*;
use crate::os_lib::js::builtins::this_dom_idx;

impl Interp {
    pub(crate) fn dom_get_property(&mut self, disp: DomDisp, key: &str) -> Value {
        match disp {
            DomDisp::Element(idx) => self.dom_element_get(idx, key),
            DomDisp::Host(tag) => {
                if let Some(rest) = tag.strip_prefix("style:") {
                    match key {
                        "setProperty" => {
                            return Value::Object(Obj::native(
                                "style.setProperty",
                                super::super::builtins::dom_style_set_property,
                            ))
                        }
                        "getPropertyValue" => {
                            return Value::Object(Obj::native(
                                "style.getPropertyValue",
                                super::super::builtins::dom_style_get_property_value,
                            ))
                        }
                        "removeProperty" => {
                            return Value::Object(Obj::native(
                                "style.removeProperty",
                                super::super::builtins::dom_style_remove_property,
                            ))
                        }
                        // `style.getPropertyPriority(name)`（丸ごと未対応
                        // だった。2026-07-16 発見）。
                        "getPropertyPriority" => {
                            return Value::Object(Obj::native(
                                "style.getPropertyPriority",
                                super::super::builtins::dom_style_get_property_priority,
                            ))
                        }
                        _ => {}
                    }
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    // `element.style.cssText`（全プロパティを1つの文字列で読み書きする
                    // 定番パターン）が丸ごと未対応で、通常の CSS プロパティ名として扱う
                    // 汎用経路に落ちて常に空文字列になっていた。
                    if key == "cssText" {
                        return Value::str(self.dom.borrow().get_css_text(idx));
                    }
                    // `style.length`/`.item(index)`（丸ごと未対応だった。
                    // `for (let i=0;i<style.length;i++) style.item(i)`という
                    // 定番の反復イディオム。2026-07-17 発見）。専用の内部
                    // 列挙APIは無いため、既存の`get_css_text`が返す直列化
                    // 済み文字列（`"color: red; font-size: 12px"`）を`;`で
                    // 分割し直す簡略実装（プロパティ名はkebab-caseのまま）。
                    let style_names = || {
                        self.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::<alloc::vec::Vec<_>>()
                    };
                    if key == "length" {
                        return Value::Number(style_names().len() as f64);
                    }
                    if key == "item" {
                        return Value::Object(Obj::native("item", super::super::builtins::dom_style_item));
                    }
                    // `style.cssFloat`（`float`プロパティのレガシー別名。
                    // `float`はかつて一部のJS実装で予約語扱いされていた
                    // 名残の互換名。丸ごと未対応だった。2026-07-17 発見）。
                    let key = if key == "cssFloat" { "float" } else { key };
                    return Value::str(self.dom.borrow().get_style(idx, key));
                }
                if let Some(rest) = tag.strip_prefix("stylesheet:") {
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    match key {
                        "ownerNode" => return Value::Object(Obj::dom(idx)),
                        "insertRule" => {
                            return Value::Object(Obj::native(
                                "StyleSheet.insertRule",
                                super::super::builtins::dom_stylesheet_insert_rule,
                            ))
                        }
                        "deleteRule" => {
                            return Value::Object(Obj::native(
                                "StyleSheet.deleteRule",
                                super::super::builtins::dom_stylesheet_delete_rule,
                            ))
                        }
                        "cssRules" => {
                            let text = self.dom.borrow().get_text_content(idx);
                            let rules = super::super::builtins::split_css_rules(&text);
                            let rule_objs: alloc::vec::Vec<Value> = rules
                                .into_iter()
                                .enumerate()
                                .map(|(r_idx, rule_text)| {
                                    let r_obj = Obj::host(&format!("cssrule:{}:{}", idx, r_idx));
                                    r_obj.borrow_mut().props.insert("cssText".into(), Value::str(rule_text.clone()));
                                    let selector = rule_text.split('{').next().unwrap_or("").trim().to_string();
                                    r_obj.borrow_mut().props.insert("selectorText".into(), Value::str(selector));
                                    Value::Object(r_obj)
                                })
                                .collect();
                            return Value::Object(Obj::array(rule_objs));
                        }
                        _ => {}
                    }
                }
                if let Some(rest) = tag.strip_prefix("classList:") {
                    let cidx: usize = rest.parse().unwrap_or(usize::MAX);
                    // メソッドはネイティブで返す（this から idx を取る）。
                    return match key {
                        "add" => Value::Object(Obj::native(
                            "classList.add",
                            super::super::builtins::dom_classlist_add,
                        )),
                        "remove" => Value::Object(Obj::native(
                            "classList.remove",
                            super::super::builtins::dom_classlist_remove,
                        )),
                        "toggle" => Value::Object(Obj::native(
                            "classList.toggle",
                            super::super::builtins::dom_classlist_toggle,
                        )),
                        "contains" => Value::Object(Obj::native(
                            "classList.contains",
                            super::super::builtins::dom_classlist_contains,
                        )),
                        "replace" => Value::Object(Obj::native(
                            "classList.replace",
                            super::super::builtins::dom_classlist_replace,
                        )),
                        "item" => Value::Object(Obj::native(
                            "classList.item",
                            super::super::builtins::dom_classlist_item,
                        )),
                        "toString" => Value::Object(Obj::native(
                            "classList.toString",
                            super::super::builtins::dom_classlist_to_string,
                        )),
                        "forEach" => Value::Object(Obj::native(
                            "classList.forEach",
                            super::super::builtins::dom_classlist_for_each,
                        )),
                        "entries" => Value::Object(Obj::native(
                            "classList.entries",
                            super::super::builtins::dom_classlist_entries,
                        )),
                        "keys" => Value::Object(Obj::native(
                            "classList.keys",
                            super::super::builtins::dom_classlist_keys,
                        )),
                        "values" => Value::Object(Obj::native(
                            "classList.values",
                            super::super::builtins::dom_classlist_values,
                        )),
                        "supports" => Value::Object(Obj::native(
                            "classList.supports",
                            super::super::builtins::dom_classlist_supports,
                        )),
                        "length" => Value::Number(
                            self.dom
                                .borrow()
                                .nodes
                                .get(cidx)
                                .map(|n| n.classes.len())
                                .unwrap_or(0) as f64,
                        ),
                        "value" => Value::str(
                            self.dom
                                .borrow()
                                .nodes
                                .get(cidx)
                                .map(|n| n.classes.join(" "))
                                .unwrap_or_default(),
                        ),
                        _ => Value::Undefined,
                    };
                }
                if let Some(rest) = tag.strip_prefix("dataset:") {
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    let attr = camel_to_data_attr(key);
                    return match self.dom.borrow().get_attr(idx, &attr) {
                        Some(v) => Value::str(v),
                        None => Value::Undefined,
                    };
                }
                if let Some(rest) = tag.strip_prefix("computed:") {
                    if key == "getPropertyValue" {
                        return Value::Object(Obj::native(
                            "getPropertyValue",
                            super::super::builtins::computed_get_property_value,
                        ));
                    }
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    // camelCase（backgroundColor）→ kebab（background-color）。既に kebab ならそのまま。
                    let prop = camel_to_kebab(key);
                    return Value::str(self.dom.borrow().get_computed(idx, &prop));
                }
                Value::Undefined
            }
        }
    }

    /// 要素の組込みメンバだけを引く（expando・カスタム要素のクラスを見ない）。
    /// `Element.prototype.setAttribute` 等の転送用ネイティブが使う。
    pub(crate) fn dom_builtin_get(&mut self, idx: usize, key: &str) -> Value {
        self.dom_builtin_lookup = true;
        let v = self.dom_element_get(idx, key);
        self.dom_builtin_lookup = false;
        v
    }

    /// 要素の組込みプロパティに書く（クラスの setter を経由しない）。
    pub(crate) fn dom_builtin_set(&mut self, idx: usize, key: &str, val: Value) {
        self.dom_set_property(DomDisp::Element(idx), key, val);
        self.process_ce_reactions();
    }

    /// 要素の原型連鎖に JS が定義した上書き（ネイティブでない関数・getter）があれば返す。
    /// 【2026-10-20】YouTube は `Node.prototype.appendChild` 等を JS で包み、挿入時に
    /// monomer 部品の接続処理を呼ぶ（`usePatchedLifecycles`）。組込みが先だと包みが効かず、
    /// ytd-page-manager が接続されないまま視聴ページが描かれなかった。
    fn dom_proto_override(&mut self, idx: usize, key: &str) -> Option<Value> {
        let mut cur = self.get_dom_node_proto(idx);
        let mut guard = 0;
        let is_native = |v: &Value| matches!(v, Value::Object(o) if matches!(o.borrow().kind, ObjKind::Native { .. }));
        while let Some(p) = cur {
            let acc = p.borrow().accessors.get(key).map(|a| a.get.clone());
            if let Some(g) = acc {
                return match g {
                    Some(g) if !is_native(&g) => {
                        Some(self.call_value(&g, Value::Object(Obj::dom(idx)), &[]).unwrap_or(Value::Undefined))
                    }
                    _ => None,
                };
            }
            if let Some(v) = p.borrow().props.get(key).cloned() {
                return if is_native(&v) || !matches!(v, Value::Object(_)) { None } else { Some(v) };
            }
            guard += 1;
            if guard > 64 {
                break;
            }
            cur = p.borrow().proto.clone();
        }
        None
    }

    /// 昇格したカスタム要素のクラスの原型連鎖から `key` を引く（無ければ None）。
    fn ce_chain_get(&mut self, idx: usize, key: &str) -> Option<Value> {
        let mut cur = self.dom.borrow().node_protos.get(&idx).cloned();
        let mut guard = 0;
        while let Some(p) = cur {
            let getter = p.borrow().accessors.get(key).map(|a| a.get.clone());
            if let Some(g) = getter {
                return Some(match g {
                    Some(g) => self.call_value(&g, Value::Object(Obj::dom(idx)), &[]).unwrap_or(Value::Undefined),
                    None => Value::Undefined,
                });
            }
            if let Some(v) = p.borrow().props.get(key).cloned() {
                return Some(v);
            }
            guard += 1;
            if guard > 64 {
                break;
            }
            cur = p.borrow().proto.clone();
        }
        None
    }

    pub(crate) fn dom_element_get(&mut self, idx: usize, key: &str) -> Value {
        let builtin_only = core::mem::replace(&mut self.dom_builtin_lookup, false);
        if !builtin_only {
            // JS が付けた独自プロパティ（組込みの上書きも含む）が最優先。
            if let Some(v) = self.dom.borrow().expandos.get(&idx).and_then(|m| m.get(key)) {
                return v.clone();
            }
            // 昇格したカスタム要素は、クラス（とその先の Element.prototype 等）の定義が組込みより先。
            // 【2026-10-20】Polymer（legacyOptimizations）は setAttribute/removeAttribute を
            // prototype で上書きし、その中で disable-upgrade の反応を起こす。組込みが先だと
            // YouTube の ytd-app が起動しなかった。
            if self.dom.borrow().node_protos.contains_key(&idx) {
                if let Some(v) = self.ce_chain_get(idx, key) {
                    return v;
                }
            } else if let Some(v) = self.dom_proto_override(idx, key) {
                return v;
            }
        }
        match key {
            "__proto__" => self.get_dom_node_proto(idx).map(Value::Object).unwrap_or(Value::Null),
            // `node.baseURI`（DOM 標準。丸ごと未対応だった）。`<base>` タグ対応が
            // 無いため、全ノードで `document.URL`/`location.href` と同一の値を
            // 返す簡略実装。
            "baseURI" => Value::str(super::super::builtins::location_href(&self.global).unwrap_or_default()),
            // `element.attributes`（DOM 標準の `NamedNodeMap`。丸ごと未対応
            // だった）。本物の `NamedNodeMap`（`getNamedItem`/名前でのブラケット
            // アクセス等）は実装せず、`{name, value}` オブジェクトの配列という
            // 簡略表現とする（`for...of`/`.length`/添字アクセスという最頻出の
            // 利用パターンはこれで満たせる）。
            "attributes" => {
                let dom = self.dom.borrow();
                let named: Vec<(String, Value)> = dom
                    .attr_names(idx)
                    .into_iter()
                    .map(|name| {
                        let value = dom.get_attr(idx, &name).unwrap_or_default();
                        let o = Obj::plain();
                        o.borrow_mut().props.insert("name".into(), Value::str(name.clone()));
                        o.borrow_mut().props.insert("localName".into(), Value::str(name.clone()));
                        o.borrow_mut().props.insert("value".into(), Value::str(value));
                        (name, Value::Object(o))
                    })
                    .collect();
                // NamedNodeMap の主な形（`getNamedItem`/`item`/名前での参照）も持たせる。
                // 【2026-10-20】YouTube（Polymer の setUpProps）が `attributes.getNamedItem(…)` を使う。
                let arr = Obj::array(named.iter().map(|(_, v)| v.clone()).collect());
                {
                    let mut b = arr.borrow_mut();
                    for (n, v) in &named {
                        b.props.insert(n.clone(), v.clone());
                    }
                    b.props.insert("getNamedItem".into(), Value::Object(Obj::native("getNamedItem", super::super::builtins::named_node_map_get)));
                    b.props.insert("item".into(), Value::Object(Obj::native("item", super::super::builtins::named_node_map_item)));
                }
                Value::Object(arr)
            }
            "textContent" | "innerText" | "outerText" => {
                Value::str(self.dom.borrow().get_text_content(idx))
            }
            // `option.text`（`<option>` 専用の `textContent` の別名。`new Option(...)`/
            // `option.text = '...'` という定番パターン）が丸ごと未対応だった。
            "text" => Value::str(self.dom.borrow().get_text_content(idx)),
            // `innerHTML` は以前 `textContent` と同じ実装を共有しており、子要素の
            // マークアップ自体（タグ）が失われ、全テキストを連結しただけの値になる
            // バグだった。`outerHTML`（丸ごと未対応だった。自身のタグを含む）と
            // 合わせて新設の DOM 側シリアライザで実装する。
            "innerHTML" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                if is_template {
                    let frag_val = self.dom_element_get(idx, "content");
                    if let Some(fi) = this_dom_idx(&frag_val) {
                        Value::str(self.dom.borrow().get_inner_html(fi))
                    } else {
                        Value::str(self.dom.borrow().get_inner_html(idx))
                    }
                } else {
                    Value::str(self.dom.borrow().get_inner_html(idx))
                }
            }
            "outerHTML" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                if is_template {
                    Value::str("<template></template>")
                } else {
                    Value::str(self.dom.borrow().get_outer_html(idx))
                }
            }
            "id" => Value::str(self.dom.borrow().get_attr(idx, "id").unwrap_or_default()),
            "attachShadow" => {
                Value::Object(Obj::native(
                    "attachShadow",
                    super::super::builtins::dom_attach_shadow,
                ))
            }
            "shadowRoot" => {
                if let Some(root_idx) = self.dom.borrow().get_shadow_root(idx) {
                    Value::Object(Obj::dom(root_idx))
                } else {
                    Value::Null
                }
            }
            "className" => Value::str(self.dom.borrow().get_attr(idx, "class").unwrap_or_default()),
            "tagName" => {
                let t = self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| {
                        if n.attrs.contains_key("_xml") {
                            n.tag.clone()
                        } else {
                            n.tag.to_uppercase()
                        }
                    })
                    .unwrap_or_default();
                Value::str(t)
            }
            // `element.constructor`（`instanceof HTMLDivElement`等は`get_dom_node_proto`
            // 経由のタグ→プロトタイプ解決で既に対応済みだったが、`.constructor`
            // プロパティ自体はDOM要素の`props`/`proto`連鎖には無く未対応だった。
            // `instanceof`と同じタグ→プロトタイプ解決を再利用し、そのプロトタイプが
            // 持つ`constructor`データプロパティ（`make_dom_cls`で設定済み）を返す。
            // 2026-07-18 発見・実装）。
            "constructor" => {
                match self.get_dom_node_proto(idx).and_then(|p| p.borrow().props.get("constructor").cloned()) {
                    Some(v) => v,
                    None => Value::Undefined,
                }
            }
            // `element.namespaceURI`/`.localName`/`.prefix`（丸ごと未対応
            // だった）。この処理系は`*AttributeNS`系/`createElementNS`と
            // 同じくXML名前空間を一切モデル化していないため、`namespaceURI`
            // は常にHTML名前空間の定数、`localName`はタグ名そのもの
            // （プレフィックス分離が無いため`tagName`の小文字版と同一）、
            // `prefix`は常に`null`という誠実な簡略実装とする。テキスト
            // ノードは仕様どおり全て`null`。2026-07-18 発見・実装）。
            "namespaceURI" => {
                let is_text = self.dom.borrow().nodes.get(idx).map(|n| n.is_text).unwrap_or(false);
                if is_text {
                    Value::Null
                } else {
                    Value::str("http://www.w3.org/1999/xhtml")
                }
            }
            "localName" => {
                let dom = self.dom.borrow();
                match dom.nodes.get(idx) {
                    Some(n) if !n.is_text => Value::str(n.tag.clone()),
                    _ => Value::Null,
                }
            }
            "prefix" => Value::Null,
            // `<select>` は仕様上 `value` 属性を自身に持たず、選択状態は子の
            // `<option selected>` が持つため、汎用の属性直結 getter では常に空文字列に
            // なるバグだった。`selectedIndex` も丸ごと未対応だった。
            // `<textarea>` も同種のバグ: 初期値はテキストノードの内容（`value` 属性では
            // ない）で表現されるため、JS からまだ書き込んでいない `textarea.value` の
            // 読み出しが常に空文字列になっていた（`collect_form_data` は `value` 属性
            // 優先・無ければ `initial_text` というフォールバックを既に実装済みだったが、
            // JS プロパティの getter 側にはこのフォールバックが欠けていた）。
            // `li.value`（順序リストの番号を明示的に上書きする`long`型IDL
            // プロパティ。仕様上、`value`属性が無いか不正値の場合の既定値は
            // `0`。実際の表示番号への反映機構は無いため属性値の反映のみ
            // 行う簡略実装だが、プロパティ自体が丸ごと未対応だった。
            // 汎用の`value`アーム（次項）に落ちると数値ではなく文字列に
            // なってしまうため、先にタグ限定で判定する。2026-07-17
            // 発見・実装）。
            "value" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "li").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "value")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .unwrap_or(0);
                Value::Number(v as f64)
            }
            "value" => {
                let dom = self.dom.borrow();
                let tag = dom.nodes.get(idx).map(|n| n.tag.as_str()).unwrap_or("");
                if tag == "select" {
                    Value::str(dom.select_effective_value(idx))
                } else if tag == "textarea" {
                    Value::str(
                        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 if tag == "output" {
                    // `output.value`/`.defaultValue`が丸ごと未対応だった。
                    // `<output>`は`value`content属性を持たず、仕様上`.value`
                    // はJSから明示的に代入されていなければ`.textContent`を
                    // 返す（`textarea.value`と同じ「未書込み時は表示内容へ
                    // フォールバック」パターン）。`textarea`は`initial_text`
                    // （パース時点の内容）にフォールバックするが、`output`は
                    // 現在の`textContent`にフォールバックする点が異なる
                    // （`defaultValue`側で仕様上のより厳密な区別が必要だが、
                    // 今回はスコープ外）。2026-07-18 発見・実装）。
                    Value::str(dom.get_attr(idx, "value").unwrap_or_else(|| dom.get_text_content(idx)))
                } else if tag == "progress" || tag == "meter" {
                    // `<progress>`/`<meter>` は仕様上 `.value` が数値プロパティ（丸ごと
                    // 未対応だった。汎用の属性直結分岐だと常に文字列 `""`/属性値の
                    // 生文字列になってしまい `progress.value` が数値として使えなかった）。
                    Value::Number(
                        dom.get_attr(idx, "value").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0),
                    )
                } else if tag == "input" && dom.get_attr(idx, "type").as_deref() == Some("file") {
                    Value::str("")
                } else if tag == "input"
                    && matches!(dom.get_attr(idx, "type").as_deref(), Some("checkbox") | Some("radio"))
                {
                    let raw_val = dom.get_attr(idx, "_live_value").or_else(|| dom.get_attr(idx, "value"));
                    Value::str(raw_val.unwrap_or_else(|| String::from("on")))
                } else if tag == "input"
                    && dom.get_attr(idx, "type").as_deref() == Some("color")
                {
                    let is_valid_hex_color = |s: &str| {
                        s.len() == 7
                            && s.starts_with('#')
                            && s.chars().skip(1).all(|c| c.is_ascii_hexdigit() && !c.is_ascii_uppercase())
                    };
                    let raw_val = dom.get_attr(idx, "_live_value").or_else(|| dom.get_attr(idx, "value"));
                    match raw_val {
                        Some(v) if is_valid_hex_color(&v) => Value::str(v),
                        _ => Value::str("#000000"),
                    }
                } else if tag == "input" && dom.get_attr(idx, "type").as_deref() == Some("range") {
                    let min = dom.get_attr(idx, "min").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0);
                    let max = dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(100.0);
                    let default = if max < min { min } else { min + (max - min) / 2.0 };
                    let raw_val = dom.get_attr(idx, "_live_value").or_else(|| dom.get_attr(idx, "value"));
                    let v = raw_val
                        .and_then(|s| s.trim().parse::<f64>().ok())
                        .unwrap_or(default);
                    let clamped = if max < min {
                        min
                    } else {
                        v.clamp(min, max)
                    };
                    Value::str(Value::Number(clamped).to_js_string())
                } else if tag == "input"
                    && matches!(
                        dom.get_attr(idx, "type").as_deref(),
                        Some("date") | Some("month") | Some("datetime-local")
                    )
                {
                    let ty = dom.get_attr(idx, "type").unwrap_or_default();
                    let raw_val = dom.get_attr(idx, "_live_value").or_else(|| dom.get_attr(idx, "value"));
                    match raw_val {
                        Some(v) if super::super::builtins::input_value_as_date_ms(&ty, &v).is_some() => {
                            Value::str(v)
                        }
                        _ => Value::str(""),
                    }
                } else {
                    let raw_val = dom.get_attr(idx, "_live_value").or_else(|| dom.get_attr(idx, "value"));
                    Value::str(raw_val.unwrap_or_default())
                }
            }
            // `input`/`textarea.defaultValue`（`value`属性/初期テキストを
            // 反映するIDLプロパティ。`.value`と同じ「未書込み時のフォール
            // バック」パターン）と`input.defaultChecked`/`option.
            // defaultSelected`（`checked`/`selected`属性の有無を反映する
            // ブール型）が丸ごと未対応だった。フォームリセット（`.reset()`
            // は仕様上これらの既定値へ戻す）や、React等のフレームワークが
            // 制御/非制御入力の判別に使う定番プロパティ。2026-07-17
            // 発見・実装）。
            "defaultValue" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "textarea").unwrap_or(false) => {
                let dom = self.dom.borrow();
                Value::str(
                    dom.get_attr(idx, "value")
                        .unwrap_or_else(|| dom.nodes.get(idx).map(|n| n.initial_text.clone()).unwrap_or_default()),
                )
            }
            "defaultValue" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "input").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "value").unwrap_or_default())
            }
            // `output.defaultValue`（`output.value`と対になる既定値追跡
            // プロパティ。丸ごと未対応だった。`initial_text`(パース時点の
            // 内容)にフォールバックする点は`textarea.defaultValue`と同じ。
            // 2026-07-18 発見・実装）。
            "defaultValue" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "output").unwrap_or(false) => {
                let dom = self.dom.borrow();
                Value::str(
                    dom.get_attr(idx, "value")
                        .unwrap_or_else(|| dom.nodes.get(idx).map(|n| n.initial_text.clone()).unwrap_or_default()),
                )
            }
            "defaultChecked" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "input").unwrap_or(false) => {
                Value::Bool(self.dom.borrow().has_attr(idx, "checked"))
            }
            "defaultSelected" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "option").unwrap_or(false) => {
                Value::Bool(self.dom.borrow().has_attr(idx, "selected"))
            }
            // `input`/`textarea.selectionStart`/`.selectionEnd`/
            // `.selectionDirection`（丸ごと未対応だった。2026-07-17 発見）。
            // この処理系には実際のキャレット/テキスト選択機構が無いため、
            // 内部専用属性（`_selection_start`等）へ書き込み値をそのまま
            // 保存するだけの状態追跡のみの簡略実装（`checkbox.indeterminate`
            // と同方針）。未設定時は仕様どおり`0`/`"none"`。
            "selectionStart" | "selectionEnd"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "input" || n.tag == "textarea")
                    .unwrap_or(false) =>
            {
                let attr = if key == "selectionStart" { "_selection_start" } else { "_selection_end" };
                Value::Number(self.dom.borrow().get_attr(idx, attr).and_then(|v| v.parse::<f64>().ok()).unwrap_or(0.0))
            }
            "selectionDirection"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "input" || n.tag == "textarea")
                    .unwrap_or(false) =>
            {
                Value::str(self.dom.borrow().get_attr(idx, "_selection_direction").unwrap_or_else(|| "none".into()))
            }
            // `textarea.textLength`（仕様上`HTMLTextAreaElement`限定。`.value`
            // の文字数を毎回`.length`で数える手間を省くIDL属性。丸ごと
            // 未対応だった）。
            "textLength" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "textarea").unwrap_or(false) => {
                let dom = self.dom.borrow();
                let v = 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());
                Value::Number(v.chars().count() as f64)
            }
            // `textarea.wrap`（`"soft"`/`"hard"`の列挙属性。既知値以外・
            // 欠落時は仕様上の既定値`"soft"`にフォールバックする必要が
            // あるが、丸ごと未対応だった。`fieldset.type`等と同じバグ
            // パターン。2026-07-17 発見・実装）。
            "wrap" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "textarea").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "wrap").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("hard") => Value::str("hard"),
                    _ => Value::str("soft"),
                }
            }
            // `setSelectionRange(start, end, direction?)`/`setRangeText
            // (replacement, start?, end?, selectMode?)`（丸ごと未対応
            // だった。`selectionStart`等と対になる操作メソッド。
            // 2026-07-17 発見・実装）。
            "setSelectionRange"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "input" || n.tag == "textarea")
                    .unwrap_or(false) =>
            {
                Value::Object(Obj::native("setSelectionRange", super::super::builtins::dom_set_selection_range))
            }
            "setRangeText"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "input" || n.tag == "textarea")
                    .unwrap_or(false) =>
            {
                Value::Object(Obj::native("setRangeText", super::super::builtins::dom_set_range_text))
            }
            // `input.valueAsNumber`（HTML5。`type="number"`/`"range"` の `.value`
            // 文字列を毎回 `Number()` で変換する定番の手間を省く IDL 属性。丸ごと
            // 未対応だった。対象外の `type` や未入力/不正値では仕様どおり `NaN`）。
            "valueAsNumber" => {
                let dom = self.dom.borrow();
                let ty = dom.get_attr(idx, "type").unwrap_or_default();
                if ty == "number" || ty == "range" {
                    let raw_val = dom.get_attr(idx, "_live_value").or_else(|| dom.get_attr(idx, "value"));
                    Value::Number(
                        raw_val
                            .and_then(|s| s.trim().parse::<f64>().ok())
                            .unwrap_or(f64::NAN),
                    )
                } else {
                    Value::Number(f64::NAN)
                }
            }
            // `input.valueAsDate`（HTML5。`type="date"`/`"month"` の `.value` 文字列を
            // `Date` オブジェクトとして読み書きする IDL 属性。丸ごと未対応だった。
            // 対象外の `type` や未入力/不正値では仕様どおり `null`（`valueAsNumber`
            // の `NaN` とは異なる）。
            "valueAsDate" => {
                let dom = self.dom.borrow();
                let ty = dom.get_attr(idx, "type").unwrap_or_default();
                let value = dom.get_attr(idx, "_live_value")
                    .or_else(|| dom.get_attr(idx, "value"))
                    .unwrap_or_default();
                match super::super::builtins::input_value_as_date_ms(&ty, &value) {
                    Some(ms) => Value::Object(Obj::date_obj(ms)),
                    None => Value::Null,
                }
            }
            // `<progress>`/`<meter>` の `max`/`min`（`<meter>` のみ）。既定値は仕様どおり
            // `max`=1、`min`=0。
            "max"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "progress" || n.tag == "meter")
                    .unwrap_or(false) =>
            {
                Value::Number(
                    self.dom
                        .borrow()
                        .get_attr(idx, "max")
                        .and_then(|s| s.trim().parse::<f64>().ok())
                        .unwrap_or(1.0),
                )
            }
            "min"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "meter")
                    .unwrap_or(false) =>
            {
                Value::Number(
                    self.dom
                        .borrow()
                        .get_attr(idx, "min")
                        .and_then(|s| s.trim().parse::<f64>().ok())
                        .unwrap_or(0.0),
                )
            }
            // `progress.position`（廃止予定だが仕様に残る読み取り専用IDL
            // プロパティ。`value`属性が無い不確定状態なら`-1`、それ以外は
            // `value/max`を返す。丸ごと未対応だった。2026-07-18 発見・
            // 実装）。
            "position"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "progress").unwrap_or(false) =>
            {
                let dom = self.dom.borrow();
                match dom.get_attr(idx, "value").and_then(|s| s.trim().parse::<f64>().ok()) {
                    None => Value::Number(-1.0),
                    Some(v) => {
                        let max = dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(1.0);
                        let max = if max > 0.0 { max } else { 1.0 };
                        Value::Number((v / max).clamp(0.0, 1.0))
                    }
                }
            }
            // `meter.low`/`.high`/`.optimum`（`min`/`max`と同じく丸ごと
            // 未対応だった。仕様上、`low`の既定値は`min`、`high`の既定値は
            // `max`、`optimum`の既定値は`min`と`max`の中点。それぞれの
            // 属性値が範囲外の場合も仕様どおりクランプする。2026-07-17
            // 発見・実装）。
            "low" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "meter").unwrap_or(false) => {
                let dom = self.dom.borrow();
                let min = dom.get_attr(idx, "min").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0);
                let max = dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(1.0);
                let low = dom.get_attr(idx, "low").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(min);
                Value::Number(low.clamp(min, max))
            }
            "high" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "meter").unwrap_or(false) => {
                let dom = self.dom.borrow();
                let min = dom.get_attr(idx, "min").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0);
                let max = dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(1.0);
                let high = dom.get_attr(idx, "high").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(max);
                Value::Number(high.clamp(min, max))
            }
            "optimum" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "meter").unwrap_or(false) => {
                let dom = self.dom.borrow();
                let min = dom.get_attr(idx, "min").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0);
                let max = dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(1.0);
                let optimum =
                    dom.get_attr(idx, "optimum").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or((min + max) / 2.0);
                Value::Number(optimum.clamp(min, max))
            }
            "selectedIndex" => Value::Number(self.dom.borrow().select_selected_index(idx) as f64),
            // `select.add(element, before)`（`select.options.add`と同じ意味の
            // 便利メソッド。丸ごと未対応だった。2026-07-18 発見・実装）。
            "add" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false) => {
                Value::Object(Obj::native("add", super::super::builtins::dom_select_add))
            }
            // `select.length`（`select.options.length`と同じ値を返すIDL属性。
            // 丸ごと未対応だった）。`<select>`以外のタグでは意味を持たないため
            // 対象外（他プロパティと同じ簡略方針）。
            "length"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false) =>
            {
                Value::Number(self.dom.borrow().select_options(idx).len() as f64)
            }
            // `select.selectedOptions`（`<select multiple>` で選択中の option 一覧を得る
            // 定番イディオム）が丸ごと未対応だった。`FormData` の multi-select 収集漏れ
            // 修正と同じ根本原因（`selected` 属性の集約先が無かった）。
            "selectedOptions" => {
                let indices = self.dom.borrow().selected_option_indices(idx);
                Value::Object(Obj::array(
                    indices.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                ))
            }
            // `select.options`（動的にドロップダウンを構築する定番イディオム
            // `for (const o of select.options)`/`select.options[i]` で使われる）が
            // `selectedOptions` と同じ理由で丸ごと未対応だった。
            "options" => {
                let indices = self.dom.borrow().select_options(idx);
                let arr = Obj::array(
                    indices.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                );
                // `select.options.add`/`.remove`/`.namedItem`（`HTMLOptionsCollection`。
                // 丸ごと未対応だった。`_select_idx` は元の `<select>` を辿るための
                // 隠しプロパティ）。
                {
                    let mut b = arr.borrow_mut();
                    b.props.insert("_select_idx".into(), Value::Number(idx as f64));
                    b.props.insert(
                        "item".into(),
                        Value::Object(Obj::native("options.item", super::super::builtins::html_collection_item)),
                    );
                    b.props.insert(
                        "add".into(),
                        Value::Object(Obj::native("options.add", super::super::builtins::select_options_add)),
                    );
                    b.props.insert(
                        "remove".into(),
                        Value::Object(Obj::native("options.remove", super::super::builtins::select_options_remove)),
                    );
                    b.props.insert(
                        "namedItem".into(),
                        Value::Object(Obj::native(
                            "options.namedItem",
                            super::super::builtins::select_options_named_item,
                        )),
                    );
                }
                Value::Object(arr)
            }
            // `input.form`（自身が属する `<form>` への逆参照。`el.form.reset()`/
            // `el.form.submit()` という定番イディオムで使われる）が丸ごと未対応
            // だった。`associated_form`は祖先探索（`closest_tag`）に加え、
            // `form="formId"`属性による明示的なフォーム外関連付け（HTML5仕様の
            // 「form owner」）も見る。
            "form" => match self.dom.borrow().associated_form(idx) {
                Some(fi) => Value::Object(Obj::dom(fi)),
                None => Value::Null,
            },
            // `label.control`（`labels` の逆方向。`<label>` から自身に関連付いた
            // フォームコントロールを引く）が丸ごと未対応だった。`for` 属性による
            // 明示的な関連付けを優先し、無ければ子孫の最初のフォームコントロールへ
            // フォールバックする。
            "control" => {
                let dom = self.dom.borrow();
                let is_label = dom.nodes.get(idx).map(|n| n.tag == "label").unwrap_or(false);
                if !is_label {
                    Value::Undefined
                } else {
                    let for_id = dom.get_attr(idx, "for");
                    let by_for = for_id.filter(|f| !f.is_empty()).and_then(|f| {
                        (0..dom.nodes.len())
                            .find(|&i| !dom.nodes[i].is_text && dom.nodes[i].id == f)
                    });
                    let target = by_for.or_else(|| {
                        dom.descendants_by_tags(idx, &["input", "select", "textarea", "button"])
                            .into_iter()
                            .next()
                    });
                    match target {
                        Some(i) => Value::Object(Obj::dom(i)),
                        None => Value::Null,
                    }
                }
            }
            // `input.labels`（自身に紐づく `<label>` 一覧。`<label for="id">` による
            // 明示的な関連付けと、`<label>` の子孫に置く暗黙の関連付けの両方が対象）が
            // 丸ごと未対応だった。フォームアクセシビリティの定番パターンで使われる。
            "labels" => {
                let dom = self.dom.borrow();
                let control_id = dom.nodes.get(idx).map(|n| n.id.clone()).unwrap_or_default();
                let mut labels: Vec<usize> = Vec::new();
                for (i, n) in dom.nodes.iter().enumerate() {
                    if n.is_text || n.tag != "label" {
                        continue;
                    }
                    let matches_for = !control_id.is_empty()
                        && dom.get_attr(i, "for").map(|f| f == control_id).unwrap_or(false);
                    let is_ancestor = dom.is_ancestor_of(i, idx);
                    if matches_for || is_ancestor {
                        labels.push(i);
                    }
                }
                Value::Object(Obj::array(
                    labels.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                ))
            }
            // `form.elements`（`form.elements[i]`/`for (const el of form.elements)` で
            // 全フォームコントロールを走査する定番イディオム）が丸ごと未対応だった。
            // `form_associated_controls`（`form.checkValidity()`/`FormData`収集と
            // 共通の「子孫 + form="このformのid"属性による外部関連付け」判定）を
            // 再利用する。以前は`descendants_by_tags`（子孫のみ）だったため、
            // `<form>`の外に置かれた`<input form="...">`が`.elements`からも
            // 漏れる兄弟ギャップだった（名前/id によるプロパティアクセスは
            // 対象外の簡略実装のまま）。
            // `fieldset.elements`（丸ごと未対応だった。`HTMLFieldSetElement`の
            // 仕様上のIDLプロパティ。`form.elements`と異なり`form="id"`に
            // よる木構造外の関連付けは対象外で、純粋なDOM子孫のみを対象と
            // する。2026-07-17 発見・実装）。
            "elements" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "fieldset").unwrap_or(false) => {
                let fields = self.dom.borrow().descendants_by_tags(idx, &["input", "select", "textarea", "button"]);
                super::super::builtins::make_html_collection(self, fields)
            }
            "elements" => {
                let dom = self.dom.borrow();
                let is_form = dom.nodes.get(idx).map(|n| n.tag == "form").unwrap_or(false);
                if is_form {
                    let fields =
                        dom.form_associated_controls(idx, &["input", "select", "textarea", "button"]);
                    drop(dom);
                    super::super::builtins::make_html_collection(self, fields)
                } else {
                    Value::Undefined
                }
            }
            // `form.length`（`form.elements.length`と同じ値を返すIDL属性の
            // 数値ショートハンド。`select.length`の対になる`<form>`側だが
            // 丸ごと未対応だった。`elements`と全く同じ`form_associated_controls`
            // を再利用する）。
            "length" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "form").unwrap_or(false) => {
                Value::Number(
                    self.dom
                        .borrow()
                        .form_associated_controls(idx, &["input", "select", "textarea", "button"])
                        .len() as f64,
                )
            }
            // `table.rows`/`tr.cells`（HTML5 Table DOM。丸ごと未対応だった。
            // 2026-07-17 発見）。`form.elements` と同じ `descendants_by_tags`
            // を再利用する簡略実装（`caption`/`colgroup`は対象外、`thead`/
            // `tbody`/`tfoot`内の`tr`も含めて文書順で列挙する）。
            // `HTMLTableSectionElement.rows`（`thead`/`tbody`/`tfoot`自身が
            // 持つ、そのセクション内に限定した`rows`。丸ごと未対応だった。
            // `table.rows`は実装済みなのに対になるこちらだけ抜けていた
            // 兄弟ギャップ。2026-07-17 発見・実装）。
            "rows"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| matches!(n.tag.as_str(), "table" | "thead" | "tbody" | "tfoot"))
                    .unwrap_or(false) =>
            {
                let rows = self.dom.borrow().descendants_by_tags(idx, &["tr"]);
                Value::Object(Obj::array(rows.into_iter().map(|i| Value::Object(Obj::dom(i))).collect()))
            }
            "cells" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "tr").unwrap_or(false) => {
                let cells = self.dom.borrow().descendants_by_tags(idx, &["td", "th"]);
                Value::Object(Obj::array(cells.into_iter().map(|i| Value::Object(Obj::dom(i))).collect()))
            }
            // `table.tHead`/`.tFoot`/`.caption`（直接の子のみが対象。仕様上
            // `thead`/`tfoot`/`caption`はテーブルの直下にしか置けないため、
            // `rows`/`cells`の`descendants_by_tags`のような子孫検索ではなく
            // 直接の子だけを見る。丸ごと未対応だった。2026-07-17 発見・実装）。
            "tHead" | "tFoot" | "caption"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) =>
            {
                let want = match key {
                    "tHead" => "thead",
                    "tFoot" => "tfoot",
                    _ => "caption",
                };
                let dom = self.dom.borrow();
                let found = dom.nodes[idx].children.iter().find(|&&c| dom.nodes[c].tag == want).copied();
                match found {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            // `table.tBodies`（直接の子`tbody`のみを集約するHTMLCollection）。
            "tBodies" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                let dom = self.dom.borrow();
                let bodies: alloc::vec::Vec<usize> =
                    dom.nodes[idx].children.iter().filter(|&&c| dom.nodes[c].tag == "tbody").copied().collect();
                Value::Object(Obj::array(bodies.into_iter().map(|i| Value::Object(Obj::dom(i))).collect()))
            }
            // `tr.rowIndex`（自身が属する`table`内の`rows`集合における位置）。
            "rowIndex" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "tr").unwrap_or(false) => {
                let dom = self.dom.borrow();
                let mut cur = dom.nodes.get(idx).and_then(|n| n.parent);
                let table = loop {
                    match cur {
                        Some(p) if dom.nodes.get(p).map(|n| n.tag == "table").unwrap_or(false) => break Some(p),
                        Some(p) => cur = dom.nodes.get(p).and_then(|n| n.parent),
                        None => break None,
                    }
                };
                match table {
                    Some(t) => {
                        let rows = dom.descendants_by_tags(t, &["tr"]);
                        Value::Number(rows.iter().position(|&r| r == idx).map(|p| p as f64).unwrap_or(-1.0))
                    }
                    None => Value::Number(-1.0),
                }
            }
            // `tr.sectionRowIndex`（丸ごと未対応だった。`rowIndex`は実装済み
            // なのに、対になるこちらだけ抜けていた兄弟ギャップ。2026-07-17
            // 発見・実装）。`rowIndex`が「テーブル全体の`rows`集合における
            // 位置」なのに対し、こちらは「直接の親（`thead`/`tbody`/
            // `tfoot`、無ければ`table`自身）配下の`tr`集合における位置」。
            // `thead`に2行・`tbody`に3行ある表で`tbody`側の2行目の
            // `tr`なら、`rowIndex`は`3`（テーブル全体で4番目）だが
            // `sectionRowIndex`は`1`（tbody内で2番目、0始まり）になる。
            "sectionRowIndex" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "tr").unwrap_or(false) => {
                let dom = self.dom.borrow();
                match dom.nodes.get(idx).and_then(|n| n.parent) {
                    Some(p) => {
                        let rows = dom.descendants_by_tags(p, &["tr"]);
                        Value::Number(rows.iter().position(|&r| r == idx).map(|i| i as f64).unwrap_or(-1.0))
                    }
                    None => Value::Number(-1.0),
                }
            }
            // `cell.cellIndex`（自身が属する`tr`内の`cells`集合における位置）。
            "cellIndex" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "td" || n.tag == "th").unwrap_or(false) => {
                let dom = self.dom.borrow();
                match dom.nodes.get(idx).and_then(|n| n.parent) {
                    Some(p) => {
                        let cells = dom.descendants_by_tags(p, &["td", "th"]);
                        Value::Number(cells.iter().position(|&c| c == idx).map(|i| i as f64).unwrap_or(-1.0))
                    }
                    None => Value::Number(-1.0),
                }
            }
            // `td`/`th.colSpan`/`.rowSpan`（丸ごと未対応だった。動的に表を
            // 組み立てる際の定番プロパティ。仕様上どちらも欠落・不正値時の
            // 既定値は`1`で、`colSpan`は最大`1000`、`rowSpan`は最大`65534`
            // にクランプする（`rowSpan`は`0`が「セクション末尾まで」を表す
            // 特殊な有効値のため`colSpan`と異なり下限クランプは無い）。
            // 2026-07-17 発見・実装）。
            "colSpan" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "td" || n.tag == "th").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "colspan")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 1)
                    .unwrap_or(1);
                Value::Number(v.min(1000) as f64)
            }
            "rowSpan" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "td" || n.tag == "th").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "rowspan")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 0)
                    .unwrap_or(1);
                Value::Number(v.min(65534) as f64)
            }
            // `td`/`th.headers`（空白区切りID文字列の単純な属性反映）と
            // `th.scope`（`"row"`/`"col"`/`"rowgroup"`/`"colgroup"`の列挙
            // 属性。既知値以外・欠落時は仕様上の既定値`""`（`auto`状態）に
            // フォールバックする）、`th.abbr`（単純な文字列反映）が丸ごと
            // 未対応だった。`colSpan`/`.rowSpan`と同じ点検で発見。
            // 2026-07-17 発見・実装）。
            "headers" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "td" || n.tag == "th").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "headers").unwrap_or_default())
            }
            "scope" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "th").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "scope").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("row") => Value::str("row"),
                    Some("col") => Value::str("col"),
                    Some("rowgroup") => Value::str("rowgroup"),
                    Some("colgroup") => Value::str("colgroup"),
                    _ => Value::str(""),
                }
            }
            "abbr" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "th").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "abbr").unwrap_or_default())
            }
            // `col`/`colgroup.span`（`colSpan`/`.rowSpan`と同じく丸ごと
            // 未対応だった。仕様上、欠落・不正値時の既定値は`1`で最大
            // `1000`にクランプする。2026-07-17 発見・実装）。
            "span" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "col" || n.tag == "colgroup").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "span")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 1)
                    .unwrap_or(1);
                Value::Number(v.min(1000) as f64)
            }
            // `table.insertRow(index?)`/`.deleteRow(index)`、`tr.insertCell
            // (index?)`/`.deleteCell(index)`（HTML5 Table DOM。丸ごと未対応
            // だった。`select.options.add`/`.remove` と同じ「動的に表を
            // 組み立てる」定番イディオム）。
            // `HTMLTableSectionElement.insertRow`/`.deleteRow`（`thead`/
            // `tbody`/`tfoot`自身が持つ、そのセクション内に限定した版。
            // 丸ごと未対応だった。`table.insertRow`は実装済みなのに対になる
            // こちらだけ抜けていた兄弟ギャップ。`dom_table_insert_row`/
            // `dom_table_delete_row`は`this`を起点にスコープする汎用実装の
            // ため、`<table>`用に書いた関数をそのまま再利用できる。
            // 2026-07-17 発見・実装）。
            "insertRow"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| matches!(n.tag.as_str(), "table" | "thead" | "tbody" | "tfoot"))
                    .unwrap_or(false) =>
            {
                Value::Object(Obj::native("insertRow", super::super::builtins::dom_table_insert_row))
            }
            "deleteRow"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| matches!(n.tag.as_str(), "table" | "thead" | "tbody" | "tfoot"))
                    .unwrap_or(false) =>
            {
                Value::Object(Obj::native("deleteRow", super::super::builtins::dom_table_delete_row))
            }
            "insertCell" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "tr").unwrap_or(false) => {
                Value::Object(Obj::native("insertCell", super::super::builtins::dom_table_insert_cell))
            }
            "deleteCell" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "tr").unwrap_or(false) => {
                Value::Object(Obj::native("deleteCell", super::super::builtins::dom_table_delete_cell))
            }
            // `table.createTHead()`/`.createTFoot()`/`.createCaption()`と
            // 対になる`delete*`（既存要素があれば返す/削除するだけの
            // 冪等な簡略実装。丸ごと未対応だった。2026-07-17 発見・実装）。
            "createTHead" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                Value::Object(Obj::native("createTHead", super::super::builtins::dom_table_create_thead))
            }
            "createTFoot" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                Value::Object(Obj::native("createTFoot", super::super::builtins::dom_table_create_tfoot))
            }
            "createCaption" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                Value::Object(Obj::native("createCaption", super::super::builtins::dom_table_create_caption))
            }
            "deleteTHead" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                Value::Object(Obj::native("deleteTHead", super::super::builtins::dom_table_delete_thead))
            }
            "deleteTFoot" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                Value::Object(Obj::native("deleteTFoot", super::super::builtins::dom_table_delete_tfoot))
            }
            "deleteCaption" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) => {
                Value::Object(Obj::native("deleteCaption", super::super::builtins::dom_table_delete_caption))
            }
            // `input.type` の読み書きが JS プロパティとして未対応だった
            // （`getAttribute('type')` 経由の間接アクセスしかできなかった）。
            // `fieldset.type`（仕様上、属性値に関わらず常に固定文字列
            // `"fieldset"`を返す読み取り専用IDLプロパティ。丸ごと未対応
            // だった。汎用の属性直結`type`ゲッターに落ちると空文字列に
            // なってしまうため、こちらを先に処理する。2026-07-17 発見・
            // 実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "fieldset").unwrap_or(false) => {
                Value::str("fieldset")
            }
            // `textarea.type`（仕様上、属性値に関わらず常に固定文字列
            // `"textarea"`を返す読み取り専用IDLプロパティ。`fieldset.type`
            // と同じ理由で丸ごと未対応だった。2026-07-17 発見・実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "textarea").unwrap_or(false) => {
                Value::str("textarea")
            }
            // `output.type`（仕様上、属性値に関わらず常に固定文字列
            // `"output"`を返す読み取り専用IDLプロパティ。`<output>`要素
            // 自体が丸ごと未対応だった。`fieldset.type`/`textarea.type`と
            // 同じパターン。2026-07-17 発見・実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "output").unwrap_or(false) => {
                Value::str("output")
            }
            // `output.htmlFor`（`for`属性を空白区切りトークンとして扱う
            // `DOMTokenList`。丸ごと未対応だった。`label.htmlFor`は同名だが
            // 単一文字列を返す別の意味なので、`relList`/`sandbox`と同じ
            // 「読み取り専用トークン配列」簡略実装で区別する。汎用の
            // 単一文字列版`htmlFor`アームより先にタグ限定で判定する。
            // 2026-07-18 発見・実装）。
            "htmlFor" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "output").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "for").unwrap_or_default();
                Value::Object(Obj::array(v.split_whitespace().map(Value::str).collect()))
            }
            // `select.type`（仕様上、`multiple`属性の有無で`"select-
            // multiple"`/`"select-one"`のいずれか固定文字列を返す読み取り
            // 専用IDLプロパティ。`fieldset.type`と同じ理由（汎用の属性
            // 直結`type`ゲッターに落ちると空文字列になる）で丸ごと未対応
            // だった。2026-07-17 発見・実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false) => {
                if self.dom.borrow().has_attr(idx, "multiple") {
                    Value::str("select-multiple")
                } else {
                    Value::str("select-one")
                }
            }
            // `button.type`（仕様上、`type`属性が無いか不正な値（列挙値
            // `"submit"`/`"reset"`/`"button"`以外）の場合は既定値
            // `"submit"`にフォールバックする読み取り専用寄りIDLプロパティ
            // だが、汎用の属性直結`type`ゲッターに落ちると単に空文字列に
            // なってしまい、`if (btn.type === 'submit')`という広く使われる
            // 定番チェックが常に偽になる実害のあるバグだった。丸ごと
            // 未対応だった。2026-07-17 発見・実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "button").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "type").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("reset") => Value::str("reset"),
                    Some("button") => Value::str("button"),
                    _ => Value::str("submit"),
                }
            }
            // `input.type`（仕様上、`type`属性が無いか既知の列挙値以外
            // （不正な値）の場合は既定値`"text"`にフォールバックする
            // 読み取り専用寄りIDLプロパティ。`fieldset.type`/`select.type`/
            // `button.type`と同じ理由で丸ごと未対応だった。全入力系IDL
            // プロパティの中で最も広く参照される`.type`が常に空文字列に
            // なっていた実害の大きいバグ。2026-07-17 発見・実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "input").unwrap_or(false) => {
                const KNOWN_TYPES: [&str; 22] = [
                    "text", "hidden", "search", "tel", "url", "email", "password", "date", "month",
                    "week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio",
                    "file", "submit", "image", "reset", "button",
                ];
                let v = self.dom.borrow().get_attr(idx, "type").map(|s| s.to_lowercase());
                match v {
                    Some(t) if KNOWN_TYPES.contains(&t.as_str()) => Value::str(t),
                    _ => Value::str("text"),
                }
            }
            // `ol.type`（`"1"`/`"a"`/`"A"`/`"i"`/`"I"`の列挙属性。既知値以外・
            // 欠落時は仕様上の既定値`"1"`にフォールバックする。`fieldset.
            // type`等と同じバグパターンで丸ごと未対応だった。2026-07-17
            // 発見・実装）。
            "type" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "ol").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "type");
                match v.as_deref() {
                    Some("1") => Value::str("1"),
                    Some("a") => Value::str("a"),
                    Some("A") => Value::str("A"),
                    Some("i") => Value::str("i"),
                    Some("I") => Value::str("I"),
                    _ => Value::str("1"),
                }
            }
            "type" => Value::str(self.dom.borrow().get_attr(idx, "type").unwrap_or_default()),
            // `input.checked`（チェックボックス/ラジオボタンの選択状態）が JS プロパティ
            // として一切実装されていなかった（`getAttribute('checked')`/`hasAttribute
            // ('checked')` 経由の間接アクセスしかできず、`checkbox.checked` や
            // `checkbox.checked = true` という最も基本的な書き方が常に `undefined`/
            // 黙殺になっていた）。`checked` 属性の有無をそのまま真偽値として公開する。
            "checked" => {
                let dom = self.dom.borrow();
                if let Some(lc) = dom.get_attr(idx, "_live_checked") {
                    Value::Bool(lc == "true")
                } else {
                    Value::Bool(dom.has_attr(idx, "checked"))
                }
            }
            // `input.files`（`<input type="file">`のFileList。丸ごと未対応
            // だった。2026-07-17 発見）。この処理系には実際のファイル
            // ピッカーUIが無く、JSから見て「ファイルが選択される」経路が
            // 一切存在しないため、常に空の配列（空`FileList`相当）を返す
            // 誠実な簡略実装（`.readyState`/`.networkState`と同方針）。
            "files"
                if self.dom.borrow().get_attr(idx, "type").as_deref() == Some("file") =>
            {
                Value::Object(Obj::array(alloc::vec![]))
            }

            // `iframe.contentWindow`/`.contentDocument`（丸ごと未対応
            // だった。2026-07-17 発見）。この処理系には独立JSレルムを持つ
            // iframe（ネストしたブラウジングコンテキスト）が無く常に単一
            // フレームのため、`window.top`/`.parent`/`.frames`（2026-07-16
            // 追加。同じ「フレームが無いので自分自身を指す」規定を適用
            // 済み）と同じ簡略方針で、単一のグローバル`window`/`document`
            // をそのまま返す誠実な近似実装。
            "contentWindow"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "iframe").unwrap_or(false) =>
            {
                self.global.borrow().vars.get("window").cloned().unwrap_or(Value::Undefined)
            }
            // `object.contentDocument`（丸ごと未対応だった。`HTMLObject
            // Element`は`contentWindow`を持たず`contentDocument`のみが
            // 仕様上の対象。2026-07-17 発見）。`iframe`と同じ「フレームが
            // 無いので自分自身を指す」簡略方針を適用。
            "contentDocument"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "iframe" || n.tag == "object")
                    .unwrap_or(false) =>
            {
                self.global.borrow().vars.get("document").cloned().unwrap_or(Value::Undefined)
            }
            // `object.data`（`href`/`src`/`action`と同じくURL属性を反映する
            // IDLプロパティで、生の属性文字列ではなく現在のページURL基準で
            // 解決した絶対URLを返す必要がある。テキストノードの
            // `CharacterData.data`と同名で衝突するため、`is_text`ガード付き
            // の既存`data`アームより先にタグ限定で判定する。丸ごと未対応
            // だった。2026-07-17 発見・実装）。
            "data" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "object").unwrap_or(false) => {
                let raw = self.dom.borrow().get_attr(idx, "data").unwrap_or_default();
                Value::str(self.resolve_url_against_page(&raw))
            }
            // `dialog.open`（`<dialog>` が丸ごと未対応だった。`open` 属性の有無を
            // そのまま真偽値として公開する。`checked` と同じパターン）。
            "open" => Value::Bool(self.dom.borrow().has_attr(idx, "open")),
            // `element.inert`（HTML5 グローバル真偽属性。丸ごと未対応だった。`checked`
            // と同じパターン。実際のポインタ操作ブロックは CSS 側の UA 既定
            // `pointer-events: none` 配線で実現、詳細は css.rs 参照）。
            "inert" => Value::Bool(self.dom.borrow().has_attr(idx, "inert")),
            // `dialog.returnValue`（`close(v)` が内部専用属性 `_return_value` に
            // 書き込んだ値を読む。未設定なら仕様どおり空文字列）。
            "returnValue" => Value::str(
                self.dom
                    .borrow()
                    .get_attr(idx, "_return_value")
                    .unwrap_or_default(),
            ),
            // `input.indeterminate`（checkbox の不確定表示状態）が丸ごと未対応
            // だった。HTML 属性としては反映されない JS 専用プロパティ（仕様どおり
            // `hasAttribute('indeterminate')` は常に `false` のまま）のため、内部
            // 専用の `_indeterminate` 属性キーで状態を持つ（`:indeterminate` CSS
            // 疑似クラスもこのキーを直接見る）。
            "indeterminate" => Value::Bool(self.dom.borrow().has_attr(idx, "_indeterminate")),
            // `input.disabled`/`option.selected`（属性の有無を真偽値として公開する
            // ブール型プロパティ）と `input.placeholder`/`input.name`（文字列型
            // プロパティ）が、`checked`/`type` と同じ理由で JS プロパティとして
            // 丸ごと未実装だった（`button.disabled = true` という定番パターンが
            // 常に黙殺されていた）。
            // `<fieldset disabled>`配下のコントロールは自身に`disabled`属性が無くても
            // 暗黙に無効化される（HTML5仕様。`is_disabled`は祖先の`<fieldset
            // disabled>`も遡って見る。詳細はそちらのコメント参照）。以前は要素自身の
            // `disabled`属性の有無しか見ておらず、`<fieldset disabled><input></fieldset>`
            // の`input.disabled`が常に`false`になっていた。
            "disabled" => Value::Bool(self.dom.borrow().is_disabled(idx)),
            "selected" => Value::Bool(self.dom.borrow().has_attr(idx, "selected")),
            // `option.index`（`select.selectedIndex`と対になる、`<option>`側の
            // 0始まり位置を返すIDL属性。丸ごと未対応だった）。`<option>`以外の
            // タグでは意味を持たないため対象外（他プロパティと同じ簡略方針）。
            "index"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "option").unwrap_or(false) =>
            {
                Value::Number(self.dom.borrow().option_index(idx) as f64)
            }
            "placeholder" => {
                Value::str(self.dom.borrow().get_attr(idx, "placeholder").unwrap_or_default())
            }
            // `input.pattern`（正規表現バリデーション制約文字列。`placeholder`
            // と同じ単純な文字列反映だが丸ごと未対応だった。`checkValidity`/
            // `.validity.patternMismatch`側は`pattern_matches`経由で既に
            // `pattern`属性を評価済みだったが、JSプロパティとして
            // `input.pattern`単体で読み書きする経路が漏れていた。
            // 2026-07-17 発見・実装）。
            "pattern" => Value::str(self.dom.borrow().get_attr(idx, "pattern").unwrap_or_default()),
            "name" => Value::str(self.dom.borrow().get_attr(idx, "name").unwrap_or_default()),
            // `input.required`/`input.readOnly`/`input.multiple`（属性直結のブール型
            // プロパティ）と `img.src`/`img.alt`/`a.href`（文字列型プロパティ）も、
            // `disabled`/`placeholder` と同じ理由で JS プロパティとして丸ごと未実装
            // だった。`readOnly` は DOM の慣例どおり属性名 `readonly`（小文字）に対応する。
            "required" => Value::Bool(self.dom.borrow().has_attr(idx, "required")),
            // `form.noValidate`（`novalidate` 属性の camelCase プロパティ版）が丸ごと
            // 未対応だった。`WebEngine::submit_form` は属性の有無を直接見て送信前検証を
            // スキップしていたため実挙動には既に配線済みだったが、JS からプログラム的に
            // `form.noValidate = true` で検証を無効化する定番パターンだけができなかった。
            "noValidate" => Value::Bool(self.dom.borrow().has_attr(idx, "novalidate")),
            "readOnly" => Value::Bool(self.dom.borrow().has_attr(idx, "readonly")),
            "multiple" => Value::Bool(self.dom.borrow().has_attr(idx, "multiple")),
            // `input.capture`（`type="file"`のカメラ/マイク取り込みヒント。
            // `"user"`/`"environment"`を指す単純な文字列反映。実際の
            // カメラ起動機構は無いため属性値の反映のみ行う簡略実装だが
            // 丸ごと未対応だった。2026-07-17 発見・実装）。
            "capture" => Value::str(self.dom.borrow().get_attr(idx, "capture").unwrap_or_default()),
            // `input.accept`（`type="file"`が許可するファイル種別フィルタ。
            // `capture`と同じ単純な文字列反映だが丸ごと未対応だった。
            // 2026-07-18 発見・実装）。
            "accept" => Value::str(self.dom.borrow().get_attr(idx, "accept").unwrap_or_default()),
            // `src`/`href`/`action`（URL属性を反映する IDL プロパティ）は仕様上、生の
            // 属性文字列ではなく現在のページURL基準で解決した絶対URLを返す必要がある
            // （`getAttribute('href')` は生の文字列のままでよいが、`.href`/`.src`/
            // `.action` は常に絶対URL、という区別）。以前はこの解決が一切行われず
            // `<a href="/p">.href` が相対文字列 `"/p"` のまま返る静かなバグだった。
            "src" => {
                let raw = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                Value::str(self.resolve_url_against_page(&raw))
            }
            "srcObject" => Value::Null,
            "alt" => Value::str(self.dom.borrow().get_attr(idx, "alt").unwrap_or_default()),
            "href" => {
                let raw = self.dom.borrow().get_attr(idx, "href").unwrap_or_default();
                Value::str(self.resolve_url_against_page(&raw))
            }
            // `a`/`area`要素のURL分解プロパティ（`URLUtils`ミックスイン。
            // `.protocol`/`.host`/`.hostname`/`.port`/`.pathname`/`.search`/
            // `.hash`/`.origin`/`.username`/`.password`）が丸ごと未対応
            // だった（`location`/`URL`は既に`location_components`で対応
            // 済みだったが、`<a>`要素側への配線が漏れていた非対称ギャップ。
            // 2026-07-17 発見）。`href`と同じ`resolve_url_against_page`で
            // 絶対URL化した上で、`location`/`URL`と同じ`location_components`
            // パーサを再利用する。
            "protocol" | "host" | "hostname" | "port" | "pathname" | "search" | "hash" | "origin"
            | "username" | "password"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "a" || n.tag == "area")
                    .unwrap_or(false) =>
            {
                let raw = self.dom.borrow().get_attr(idx, "href").unwrap_or_default();
                let abs = self.resolve_url_against_page(&raw);
                let comps = super::super::builtins::location_components(&abs);
                Value::str(comps.iter().find(|(k, _)| *k == key).map(|(_, v)| v.clone()).unwrap_or_default())
            }
            // `label.htmlFor`/`form.action`/`form.method`/`input.min`/`max`/`step`/
            // `maxLength`/`a.target`/`rel`/`download` も同種の未実装だった。
            // `htmlFor`/`maxLength` は DOM の慣例どおりそれぞれ属性名 `for`/`maxlength`
            // （小文字・別名）に対応する。
            "htmlFor" => Value::str(self.dom.borrow().get_attr(idx, "for").unwrap_or_default()),
            // `form.acceptCharset`（`accept-charset`属性のcamelCase IDL
            // プロパティ版。`htmlFor`と同じ単純な属性名マッピングだが
            // 丸ごと未対応だった。2026-07-17 発見・実装）。
            "acceptCharset" => Value::str(self.dom.borrow().get_attr(idx, "accept-charset").unwrap_or_default()),
            // `meta.httpEquiv`（`http-equiv`属性のcamelCase IDLプロパティ版。
            // `htmlFor`/`acceptCharset`と同じ単純な属性名マッピングだが、
            // `meta.content`/`.name`/`.charset`ともども丸ごと未対応
            // だった。2026-07-17 発見・実装）。
            "httpEquiv" => Value::str(self.dom.borrow().get_attr(idx, "http-equiv").unwrap_or_default()),
            "content" => {
                let tag = self.dom.borrow().nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
                if tag == "meta" {
                    Value::str(self.dom.borrow().get_attr(idx, "content").unwrap_or_default())
                } else if tag == "template" {
                    let existing_attr = self.dom.borrow().get_attr(idx, "_template_content_idx");
                    let frag_idx = existing_attr.and_then(|s| s.parse::<usize>().ok());
                    let frag_idx = match frag_idx {
                        Some(fi) => fi,
                        None => {
                            let fi = self.dom.borrow_mut().create_element("#document-fragment");
                            self.dom.borrow_mut().set_attr(idx, "_template_content_idx", &fi.to_string());
                            let direct_children = self.dom.borrow().nodes.get(idx).map(|n| n.children.clone()).unwrap_or_default();
                            if !direct_children.is_empty() {
                                let mut dom = self.dom.borrow_mut();
                                if let Some(template_node) = dom.nodes.get_mut(idx) {
                                    template_node.children.clear();
                                }
                                if let Some(frag_node) = dom.nodes.get_mut(fi) {
                                    frag_node.children = direct_children.clone();
                                }
                                for &child_idx in &direct_children {
                                    if let Some(child_node) = dom.nodes.get_mut(child_idx) {
                                        child_node.parent = Some(fi);
                                    }
                                }
                            }
                            fi
                        }
                    };
                    Value::Object(Obj::dom(frag_idx))
                } else {
                    Value::str(self.dom.borrow().get_attr(idx, "content").unwrap_or_default())
                }
            }
            "charset" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "meta").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "charset").unwrap_or_default())
            }
            // `script.charset`（廃止予定だが仕様に残る単純な文字列反映。
            // 対になる汎用セッターは既に存在したが、ゲッターが`meta`
            // タグ限定のままで他タグ（`script`等）では未対応だった。
            // 2026-07-18 発見・実装）。
            "charset" => Value::str(self.dom.borrow().get_attr(idx, "charset").unwrap_or_default()),
            // `blockquote`/`q`/`ins`/`del.cite`（単純な文字列反映）と
            // `ins`/`del`/`time.dateTime`（`datetime`属性のcamelCase IDL
            // プロパティ版。`htmlFor`と同じマッピングパターン）が丸ごと
            // 未対応だった。2026-07-17 発見・実装）。
            "cite" => Value::str(self.dom.borrow().get_attr(idx, "cite").unwrap_or_default()),
            "dateTime" => Value::str(self.dom.borrow().get_attr(idx, "datetime").unwrap_or_default()),
            "action" => {
                let raw = self.dom.borrow().get_attr(idx, "action").unwrap_or_default();
                Value::str(self.resolve_url_against_page(&raw))
            }
            // `form.method`（仕様上、`method`属性が無いか既知の列挙値
            // （`"get"`/`"post"`/`"dialog"`）以外の場合は既定値`"get"`に
            // フォールバックする読み取り専用寄りIDLプロパティだが、単純な
            // 属性直結ゲッターに落ちて空文字列になっていた（`fieldset.
            // type`等と同じバグパターン。2026-07-17 発見・実装）。
            "method" => {
                let v = self.dom.borrow().get_attr(idx, "method").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("post") => Value::str("post"),
                    Some("dialog") => Value::str("dialog"),
                    _ => Value::str("get"),
                }
            }
            // `form.enctype`/`.encoding`（`encoding`は`enctype`のレガシー
            // 別名で同じ属性を指す）が丸ごと未対応だった。仕様上、
            // `enctype`属性が無いか既知の列挙値3種以外の場合は既定値
            // `"application/x-www-form-urlencoded"`にフォールバックする。
            // 2026-07-17 発見・実装）。
            "enctype" | "encoding" => {
                let v = self.dom.borrow().get_attr(idx, "enctype").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("multipart/form-data") => Value::str("multipart/form-data"),
                    Some("text/plain") => Value::str("text/plain"),
                    _ => Value::str("application/x-www-form-urlencoded"),
                }
            }
            // `button`/`input` の「送信オーバーライド」IDL プロパティ
            // （`formAction`/`formEnctype`/`formMethod`/`formNoValidate`/
            // `formTarget`）が丸ごと未対応だった。仕様上、対応する`form*`
            // 属性が要素自身にあればそれを使い、無ければ所属フォーム
            // （`associated_form`）の同名属性にフォールバックする
            // （`formNoValidate`のみ自身の属性のみを反映するブール型）。
            // 2026-07-17 発見・実装）。
            "formAction"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "button" || n.tag == "input")
                    .unwrap_or(false) =>
            {
                let dom = self.dom.borrow();
                let raw = dom.get_attr(idx, "formaction").or_else(|| {
                    dom.associated_form(idx).and_then(|fi| dom.get_attr(fi, "action"))
                }).unwrap_or_default();
                drop(dom);
                Value::str(self.resolve_url_against_page(&raw))
            }
            "formEnctype"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "button" || n.tag == "input")
                    .unwrap_or(false) =>
            {
                let dom = self.dom.borrow();
                let raw = dom.get_attr(idx, "formenctype").or_else(|| {
                    dom.associated_form(idx).and_then(|fi| dom.get_attr(fi, "enctype"))
                }).map(|s| s.to_lowercase());
                match raw.as_deref() {
                    Some("multipart/form-data") => Value::str("multipart/form-data"),
                    Some("text/plain") => Value::str("text/plain"),
                    _ => Value::str("application/x-www-form-urlencoded"),
                }
            }
            "formMethod"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "button" || n.tag == "input")
                    .unwrap_or(false) =>
            {
                let dom = self.dom.borrow();
                let raw = dom.get_attr(idx, "formmethod").or_else(|| {
                    dom.associated_form(idx).and_then(|fi| dom.get_attr(fi, "method"))
                }).map(|s| s.to_lowercase());
                match raw.as_deref() {
                    Some("post") => Value::str("post"),
                    Some("dialog") => Value::str("dialog"),
                    _ => Value::str("get"),
                }
            }
            "formNoValidate"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "button" || n.tag == "input")
                    .unwrap_or(false) =>
            {
                Value::Bool(self.dom.borrow().has_attr(idx, "formnovalidate"))
            }
            "formTarget"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "button" || n.tag == "input")
                    .unwrap_or(false) =>
            {
                let dom = self.dom.borrow();
                let raw = dom.get_attr(idx, "formtarget").or_else(|| {
                    dom.associated_form(idx).and_then(|fi| dom.get_attr(fi, "target"))
                }).unwrap_or_default();
                Value::str(raw)
            }
            "min" => Value::str(self.dom.borrow().get_attr(idx, "min").unwrap_or_default()),
            "max" => Value::str(self.dom.borrow().get_attr(idx, "max").unwrap_or_default()),
            "step" => Value::str(self.dom.borrow().get_attr(idx, "step").unwrap_or_default()),
            // `input`/`textarea.maxLength`/`.minLength`はWebIDL上`long`（数値型）の
            // IDL属性で、無指定時の既定値は`-1`だが、`maxLength`は文字列型
            // （`Value::str`）で属性が無ければ空文字列を返しており、`minLength`は
            // ゲッター自体が丸ごと存在しなかった（`min`/`max`/`step`はIDL定義上も
            // 本当に`DOMString`型のため文字列のままで正しいが、`maxLength`/
            // `minLength`だけは`long`型という違いを見落としていた）。
            "maxLength" => Value::Number(
                self.dom
                    .borrow()
                    .get_attr(idx, "maxlength")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .unwrap_or(-1) as f64,
            ),
            "minLength" => Value::Number(
                self.dom
                    .borrow()
                    .get_attr(idx, "minlength")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .unwrap_or(-1) as f64,
            ),
            "target" => Value::str(self.dom.borrow().get_attr(idx, "target").unwrap_or_default()),
            "rel" => Value::str(self.dom.borrow().get_attr(idx, "rel").unwrap_or_default()),
            "download" => Value::str(self.dom.borrow().get_attr(idx, "download").unwrap_or_default()),
            // `area.coords`（単純な文字列反映）と`area.shape`（`"rect"`/
            // `"circle"`/`"poly"`/`"default"`の列挙属性。既知値以外・欠落時は
            // 仕様上の既定値`"rect"`にフォールバックし、レガシー別名
            // `"circ"`/`"polygon"`/`"rectangle"`も正規化する）が丸ごと
            // 未対応だった。2026-07-17 発見・実装）。
            "coords"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "area").unwrap_or(false) =>
            {
                Value::str(self.dom.borrow().get_attr(idx, "coords").unwrap_or_default())
            }
            "shape"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "area").unwrap_or(false) =>
            {
                let v = self.dom.borrow().get_attr(idx, "shape").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("circle") | Some("circ") => Value::str("circle"),
                    Some("poly") | Some("polygon") => Value::str("poly"),
                    Some("default") => Value::str("default"),
                    _ => Value::str("rect"),
                }
            }
            // `ol.start`/`.reversed`（丸ごと未対応だった。`start`は仕様上
            // `long`型IDLで欠落・不正値時の既定値は`1`。`reversed`は単純な
            // ブール属性。2026-07-17 発見・実装）。
            "start" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "ol").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "start")
                    .and_then(|s| s.trim().parse::<i64>().ok());
                Value::Number(v.unwrap_or(1) as f64)
            }
            "reversed" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "ol").unwrap_or(false) => {
                Value::Bool(self.dom.borrow().has_attr(idx, "reversed"))
            }
            // `element.lang`/`.dir`（グローバル属性の JS プロパティ版。`:lang()`/`:dir()`
            // CSS 疑似クラス自体は既に対応済みだったが、こちらの属性直結プロパティは
            // 他の同種プロパティ群の点検から漏れていた）。
            "lang" => Value::str(self.dom.borrow().get_attr(idx, "lang").unwrap_or_default()),
            "dir" => Value::str(self.dom.borrow().get_attr(idx, "dir").unwrap_or_default()),
            // `element.title`（要素のツールチップ文字列。グローバル属性の JS
            // プロパティ版）が丸ごと未対応だった（未マッチキーはこの巨大
            // match の末尾 `_ => Value::Undefined` に落ちるだけで、`title`
            // 属性を汎用的に反映するフォールバックは存在しないため常に
            // `undefined` になっていた。2026-07-16 発見）。`lang`/`dir` と
            // 同型の属性直結プロパティとして追加。
            "title" => Value::str(self.dom.borrow().get_attr(idx, "title").unwrap_or_default()),
            // `option`/`optgroup.label`（丸ごと未対応だった。2026-07-17
            // 発見）。`option.label`は仕様上`label`属性が無ければ要素の
            // テキスト内容（トリム済み）にフォールバックするが、
            // `optgroup.label`は同名でも既定`""`の単純な属性反映のため
            // 別のmatch armとして分ける。
            "label" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "option").unwrap_or(false) => {
                match self.dom.borrow().get_attr(idx, "label") {
                    Some(v) => Value::str(v),
                    None => Value::str(self.dom.borrow().get_text_content(idx).trim().to_string()),
                }
            }
            "label" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "optgroup").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "label").unwrap_or_default())
            }
            // `track.label`/`.srclang`（単純な文字列反映）と`track.default`
            // （`default`属性の有無を反映するブール型）が丸ごと未対応
            // だった。`track.kind`修正時の点検漏れ。2026-07-18 発見・
            // 実装）。
            "label" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "track").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "label").unwrap_or_default())
            }
            "srclang" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "track").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_attr(idx, "srclang").unwrap_or_default())
            }
            "default" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "track").unwrap_or(false) => {
                Value::Bool(self.dom.borrow().has_attr(idx, "default"))
            }
            // `element.accessKey`（同じ理由で丸ごと未対応だった）。この
            // 処理系にキーボードショートカット実装は無いため実際の挙動には
            // 影響しないが、値の読み書き自体は仕様どおり動作させる。
            "accessKey" => Value::str(self.dom.borrow().get_attr(idx, "accesskey").unwrap_or_default()),
            // `element.translate`（`translate="no"` のみ `false`、それ以外は
            // 仕様どおり既定 `true`）。
            "translate" => Value::Bool(
                self.dom.borrow().get_attr(idx, "translate").as_deref() != Some("no"),
            ),
            // `element.draggable`（丸ごと未対応だった。2026-07-16 発見）。
            // 仕様上は `img`/`a[href]` のみ既定 `true` 他は既定 `false`
            // という要素種別依存の複雑な既定値があるが、この処理系に
            // ドラッグ＆ドロップの実装は無く実際の挙動には影響しないため、
            // `translate` と同型の単純な `"true"`/`"false"` 属性直結
            // （明示指定が無ければ既定 `false`）とする簡略実装。
            "draggable" => Value::Bool(
                self.dom.borrow().get_attr(idx, "draggable").as_deref() == Some("true"),
            ),
            // `element.slot`（named slot 割り当て名。丸ごと未対応だった。
            // 2026-07-16 発見）。この処理系は Shadow DOM 自体を未実装だが、
            // `slot` content 属性自体は Shadow DOM の有無に関わらず単純な
            // 文字列属性として存在するため、`title`/`lang` と同型の
            // 属性直結プロパティとして追加（実際のスロット割り当て解決は
            // 対象外）。
            "slot" => Value::str(self.dom.borrow().get_attr(idx, "slot").unwrap_or_default()),
            // `element.tabIndex`（`tabindex` 属性の数値プロパティ版）が同じ理由で
            // 丸ごと未対応だった。この処理系にキーボード Tab 順序の実装は無いため
            // 実際のフォーカス移動には影響しないが、値の読み書き自体は仕様どおり動作
            // させる（`tabindex` 未指定時の既定値は `-1` という簡略化）。
            "tabIndex" => Value::Number(
                self.dom
                    .borrow()
                    .get_attr(idx, "tabindex")
                    .and_then(|v| v.trim().parse::<f64>().ok())
                    .unwrap_or(-1.0),
            ),
            // `element.contentEditable`/`.isContentEditable`（`contenteditable`
            // グローバル属性の JS プロパティ版。丸ごと未対応だった）。この処理系には
            // キャレット/テキスト編集機構自体が無い（`::selection` と同じ既知の
            // 制約）ため、実際の編集可能化は行わず属性値の反映のみを行う簡略実装。
            // 祖先からの継承（属性値 `"inherit"`／未指定時の既定）は非対応。
            "contentEditable" => Value::str(
                match self.dom.borrow().get_attr(idx, "contenteditable").as_deref() {
                    Some("true") | Some("") => "true",
                    Some("false") => "false",
                    Some("plaintext-only") => "plaintext-only",
                    _ => "inherit",
                },
            ),
            "isContentEditable" => Value::Bool(matches!(
                self.dom.borrow().get_attr(idx, "contenteditable").as_deref(),
                Some("true") | Some("") | Some("plaintext-only")
            )),
            // `element.spellcheck`（`spellcheck` グローバル属性の JS プロパティ版。
            // 丸ごと未対応だった）。この処理系にはスペルチェック機構自体が無いため
            // 属性値の反映のみ行う簡略実装。仕様上の既定値は `true`（未指定/`"true"`
            // なら有効、`"false"` のみ無効）。
            "spellcheck" => Value::Bool(
                self.dom.borrow().get_attr(idx, "spellcheck").as_deref() != Some("false"),
            ),
            // `element.inputMode`/`.enterKeyHint`（`inputmode`/`enterkeyhint`
            // グローバル属性の JS プロパティ版。丸ごと未対応だった）。この処理系には
            // 仮想キーボード自体が無いため属性値の反映のみ行う簡略実装。
            "inputMode" => Value::str(self.dom.borrow().get_attr(idx, "inputmode").unwrap_or_default()),
            // `select.size`（欠落・不正値時の既定値`0`。表示行数を指定する
            // `unsigned long`型IDLプロパティ）と`input.size`（欠落・不正値
            // 時の既定値`20`。テキストフィールドの表示幅を文字数で指定する
            // `unsigned long`型IDLプロパティ）が丸ごと未対応だった。
            // `fieldset.type`等と同じバグパターン。2026-07-18 発見・実装）。
            "size" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "size")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 0)
                    .unwrap_or(0);
                Value::Number(v as f64)
            }
            "size" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "input").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "size")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 1)
                    .unwrap_or(20);
                Value::Number(v as f64)
            }
            // `textarea.rows`/`.cols`（欠落・不正値時の既定値がそれぞれ`2`/
            // `20`の`unsigned long`型IDLプロパティ。`select.size`等と同じ
            // バグパターンで丸ごと未対応だった。2026-07-18 発見・実装）。
            "rows" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "textarea").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "rows")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 1)
                    .unwrap_or(2);
                Value::Number(v as f64)
            }
            "cols" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "textarea").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "cols")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 1)
                    .unwrap_or(20);
                Value::Number(v as f64)
            }
            // `input`/`select`/`textarea`/`form.autocomplete`（単純な文字列
            // 反映）と`element.autofocus`（ブール型。フォーカス自動移動の
            // 実機構は無いため属性値の反映のみ行う簡略実装）が丸ごと
            // 未対応だった。2026-07-18 発見・実装）。
            "autocomplete" => Value::str(self.dom.borrow().get_attr(idx, "autocomplete").unwrap_or_default()),
            "autofocus" => Value::Bool(self.dom.borrow().has_attr(idx, "autofocus")),
            "enterKeyHint" => {
                Value::str(self.dom.borrow().get_attr(idx, "enterkeyhint").unwrap_or_default())
            }
            // `element.autocapitalize`（`autocapitalize` グローバル属性の JS
            // プロパティ版。丸ごと未対応だった）。仮想キーボード自体が無いため
            // `inputMode`/`enterKeyHint` と同じ単純な文字列反映の簡略実装。
            "autocapitalize" => {
                Value::str(self.dom.borrow().get_attr(idx, "autocapitalize").unwrap_or_default())
            }
            // `audio`/`video.autoplay`/`.controls`/`.loop`/`.muted`/
            // `.playsInline`（HTMLMediaElement の真偽属性群。丸ごと未対応
            // だった）。`.play()`等と同じく実際の音声/映像出力機構は無いため
            // 属性値の反映のみ行う簡略実装（`disabled`等と同型パターン）。
            "autoplay" => Value::Bool(self.dom.borrow().has_attr(idx, "autoplay")),
            "controls" => Value::Bool(self.dom.borrow().has_attr(idx, "controls")),
            "loop" => Value::Bool(self.dom.borrow().has_attr(idx, "loop")),
            "muted" => Value::Bool(self.dom.borrow().has_attr(idx, "muted")),
            "playsInline" => Value::Bool(self.dom.borrow().has_attr(idx, "playsinline")),
            // `video.disablePictureInPicture`（`playsInline`と同じ単純な
            // ブール属性反映だが丸ごと未対応だった）と`iframe.allowFullscreen`
            // （`allowfullscreen`属性のcamelCase IDLプロパティ版）。
            // 2026-07-17 発見・実装）。
            "disablePictureInPicture" => {
                Value::Bool(self.dom.borrow().has_attr(idx, "disablepictureinpicture"))
            }
            // `video.disableRemotePlayback`（`disablePictureInPicture`と同じ
            // 単純なブール属性反映だが丸ごと未対応だった。2026-07-18
            // 発見・実装）。
            "disableRemotePlayback" => {
                Value::Bool(self.dom.borrow().has_attr(idx, "disableremoteplayback"))
            }
            "allowFullscreen" => Value::Bool(self.dom.borrow().has_attr(idx, "allowfullscreen")),
            // `iframe.credentialless`（COEP credentialless。`allowFullscreen`と
            // 同じ単純なブール属性反映だが丸ごと未対応だった。2026-07-18
            // 発見・実装）。
            "credentialless" => Value::Bool(self.dom.borrow().has_attr(idx, "credentialless")),
            // `canvas.width`/`.height`（`unsigned long`型IDL属性。欠落・
            // 不正値時の既定値は仕様上それぞれ`300`/`150`）と
            // `img`/`video.width`/`.height`（同じく`unsigned long`型だが
            // 既定値は`0`）が丸ごと未対応だった。`embed`/`object`/`iframe`
            // の`width`/`height`は仕様上`DOMString`型で意味が異なるため
            // 対象外（既知ギャップとしてTODO.mdに記載）。2026-07-17
            // 発見・実装）。
            "width" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "canvas").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "width")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 0)
                    .unwrap_or(300);
                Value::Number(v as f64)
            }
            "height" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "canvas").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "height")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 0)
                    .unwrap_or(150);
                Value::Number(v as f64)
            }
            "getContext" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "canvas").unwrap_or(false) => {
                Value::Object(Obj::native("getContext", super::super::builtins::dom_canvas_get_context))
            }
            "toDataURL" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "canvas").unwrap_or(false) => {
                Value::Object(Obj::native("toDataURL", super::super::builtins::dom_canvas_to_data_url))
            }
            "toBlob" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "canvas").unwrap_or(false) => {
                Value::Object(Obj::native("toBlob", super::super::builtins::dom_canvas_to_blob))
            }
            "width" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "img" || n.tag == "video").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "width")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 0)
                    .unwrap_or(0);
                Value::Number(v as f64)
            }
            "height" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "img" || n.tag == "video").unwrap_or(false) => {
                let v = self
                    .dom
                    .borrow()
                    .get_attr(idx, "height")
                    .and_then(|s| s.trim().parse::<i64>().ok())
                    .filter(|n| *n >= 0)
                    .unwrap_or(0);
                Value::Number(v as f64)
            }
            // `embed`/`object`/`iframe.width`/`.height`（`canvas`/`img`/
            // `video.width`/`.height`とは異なり、仕様上`DOMString`型の
            // レガシー予約済み属性で単純な文字列反映（数値クランプ・既定値
            // フォールバック無し）。`spec/TODO.md`に記載していた既知
            // ギャップを解消。2026-07-17 発見・実装）。
            "width"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "embed" || n.tag == "object" || n.tag == "iframe")
                    .unwrap_or(false) =>
            {
                Value::str(self.dom.borrow().get_attr(idx, "width").unwrap_or_default())
            }
            "height"
                if self
                    .dom
                    .borrow()
                    .nodes
                    .get(idx)
                    .map(|n| n.tag == "embed" || n.tag == "object" || n.tag == "iframe")
                    .unwrap_or(false) =>
            {
                Value::str(self.dom.borrow().get_attr(idx, "height").unwrap_or_default())
            }
            // `audio`/`video.paused`/`.currentTime`/`.duration`/`.volume`/
            // `.playbackRate`/`.ended`（HTMLMediaElement の再生状態群。丸ごと
            // 未対応だった）。この処理系には実際のデコード/再生パイプラインが
            // 無いため、`.play()`/`.pause()`（内部専用属性 `_paused` を切替）と
            // 同じ「状態だけを追跡する」簡略実装とする。`duration` は実際の
            // メディア長を計測できないため仕様どおり `NaN`（未ロード時の既定
            // 値）を返す誠実な簡略実装。
            // 【2026-10-17】再生中（または再生した）要素は、再生スレッドの実際の状態
            // （`mse::PLAYBACK`）を返す。それ以外は従来どおり内部属性。
            "paused" => match self.media_status(idx) {
                Some(st) if st.playing => Value::Bool(false),
                Some(st) if st.ended => Value::Bool(true),
                _ => Value::Bool(self.dom.borrow().get_attr(idx, "_paused").as_deref() != Some("false")),
            },
            "currentTime" => match self.media_status(idx) {
                Some(st) => Value::Number(st.current_time),
                None => Value::Number(
                    self.dom
                        .borrow()
                        .get_attr(idx, "_current_time")
                        .and_then(|v| v.parse::<f64>().ok())
                        .unwrap_or(0.0),
                ),
            },
            "duration" => {
                let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                Value::Number(self.media_source_duration(&src).unwrap_or(f64::NAN))
            }
            "volume" => Value::Number(
                self.dom
                    .borrow()
                    .get_attr(idx, "_volume")
                    .and_then(|v| v.parse::<f64>().ok())
                    .unwrap_or(1.0),
            ),
            "playbackRate" => Value::Number(
                self.dom
                    .borrow()
                    .get_attr(idx, "_playback_rate")
                    .and_then(|v| v.parse::<f64>().ok())
                    .unwrap_or(1.0),
            ),
            "ended" => match self.media_status(idx) {
                Some(st) => Value::Bool(st.ended),
                None => Value::Bool(self.dom.borrow().has_attr(idx, "_ended")),
            },
            // `audio`/`video.readyState`/`.networkState`/`.error`（丸ごと
            // 未対応だった）。この処理系には実際のネットワーク層/デコーダが無く
            // メディアデータを一切ロードしないため、`src`/`srcset` 未指定なら
            // `NETWORK_EMPTY`（0）、指定済みでも実際には取得しないため
            // `NETWORK_NO_SOURCE`（3）を返す誠実な簡略実装（`navigator.
            // geolocation` と同じ「できないことを楽観視しない」方針）。
            // `readyState` は常に `HAVE_NOTHING`（0）、`error` は常に `null`。
            // MSE の要素は SourceBuffer の中身から（初期化セグメントだけ = HAVE_METADATA 1、
            // メディアデータもある = HAVE_ENOUGH_DATA 4）。
            "readyState" => {
                let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                Value::Number(super::super::builtins::media_source_ready_state(&src).unwrap_or(0) as f64)
            }
            "networkState" => {
                let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                if src.starts_with("blob:mediasource-") {
                    let ended = self.media_status(idx).is_some_and(|st| st.ended);
                    Value::Number(if ended { 1.0 } else { 2.0 })
                } else {
                    let has_src = !src.is_empty() || self.dom.borrow().has_attr(idx, "srcset");
                    Value::Number(if has_src { 3.0 } else { 0.0 })
                }
            }
            "error" => Value::Null,
            // `script`/`style.nonce`（CSP nonce。丸ごと未対応だった）。この
            // 処理系には実際の CSP 検証機構が無いため、単純な文字列反映の
            // 簡略実装とする（仕様上は `nonce` content 属性を読めなくする
            // セキュリティ対策があるが、IDL プロパティ経由の読み書きは通す）。
            "nonce" => Value::str(self.dom.borrow().get_attr(idx, "nonce").unwrap_or_default()),
            // `element.role`/`.ariaLabel`/`.ariaHidden`等（`ARIAMixin`。
            // `role`/`aria-*`属性のIDLプロパティ版）が丸ごと未対応
            // だった。`aria-*`側の命名規則は単純で、`aria`接頭辞の後の
            // PascalCase部分を全て小文字化するだけで対応する属性名になる
            // （例: `ariaValueNow`→`aria-valuenow`、`ariaLabelledBy`→
            // `aria-labelledby`。内部のダッシュは無い）。個別に50近く
            // ある属性を1つずつ列挙する代わりに、この規則をそのまま
            // コードにした汎用アームで一括対応する。2026-07-18
            // 発見・実装）。
            "role" => match self.dom.borrow().get_attr(idx, "role") {
                Some(v) => Value::str(v),
                None => Value::Null,
            },
            // `ariaActiveDescendantElement`（ARIA Element Reflection。
            // `aria-activedescendant`のidref文字列ではなく実際のElement参照を
            // 返す/設定する。`popoverTargetElement`と全く同じidref解決
            // パターン。汎用の`aria-*`文字列反映アームより前に置く必要がある
            // （`starts_with("aria")`の汎用ガードに先に吸われてしまうため）。
            // 丸ごと未対応だった。2026-07-18 発見・実装）。
            "ariaActiveDescendantElement" => {
                let dom = self.dom.borrow();
                match dom.get_attr(idx, "aria-activedescendant").filter(|f| !f.is_empty()) {
                    Some(target_id) => match dom.get_element_by_id(&target_id) {
                        Some(ti) => Value::Object(Obj::dom(ti)),
                        None => Value::Null,
                    },
                    None => Value::Null,
                }
            }
            // `ariaLabelledByElements`/`ariaDescribedByElements`/
            // `ariaControlsElements`/`ariaOwnsElements`/`ariaFlowToElements`/
            // `ariaDetailsElements`/`ariaErrorMessageElements`（ARIA Element
            // Reflection。空白区切りidref属性を、文字列ではなく実際の
            // Element参照の配列として返す。単数の`ariaActiveDescendantElement`
            // と同じ理由で汎用の`aria-*`文字列反映アームより前に置く必要が
            // ある。`get_element_by_id`で解決できないid（未接続/存在しない）
            // は配列から除外する（仕様は`null`要素を含むが、この処理系の
            // 簡略配列表現では穴を開けられないため）。丸ごと未対応だった。
            // 2026-07-18 発見・実装）。
            _ if key.starts_with("aria") && key.ends_with("Elements") && key.len() > 12 => {
                let suffix: String =
                    key.chars().skip(4).take(key.len() - 4 - 8).collect::<String>().to_lowercase();
                let attr = alloc::format!("aria-{}", suffix);
                let dom = self.dom.borrow();
                let ids = dom.get_attr(idx, &attr).unwrap_or_default();
                let elems: Vec<Value> = ids
                    .split_whitespace()
                    .filter_map(|id| dom.get_element_by_id(id))
                    .map(|ti| Value::Object(Obj::dom(ti)))
                    .collect();
                Value::Object(Obj::array(elems))
            }
            _ if key.starts_with("aria") && key.as_bytes().get(4).is_some_and(u8::is_ascii_uppercase) => {
                let suffix: String = key.chars().skip(4).collect::<String>().to_lowercase();
                let attr = alloc::format!("aria-{}", suffix);
                match self.dom.borrow().get_attr(idx, &attr) {
                    Some(v) => Value::str(v),
                    None => Value::Null,
                }
            }
            // `audio`/`video.buffered`/`.seekable`（`TimeRanges`。丸ごと未対応
            // だった）。実際にはメディアデータを一切ロード/シークしないため、
            // 常に空の `TimeRanges`（`length:0`、`start`/`end` は範囲外
            // アクセスとして例外を投げる）を返す誠実な簡略実装。
            // 【2026-10-18】MSE の要素は SourceBuffer の実際の範囲を返す（空だと YouTube の
            // player は「読み込み中」のままスピナーを出し続ける）。
            "buffered" if self.dom.borrow().get_attr(idx, "src").is_some_and(|s| s.starts_with("blob:mediasource-")) => {
                let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                super::super::builtins::media_element_buffered(&src)
                    .unwrap_or_else(|| Value::Object(super::super::builtins::make_empty_time_ranges()))
            }
            "seekable" if self.dom.borrow().get_attr(idx, "src").is_some_and(|s| s.starts_with("blob:mediasource-")) => {
                let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                super::super::builtins::media_element_seekable(self.media_source_duration(&src))
            }
            "played" => match self.media_status(idx) {
                Some(st) if st.current_time > 0.0 => {
                    super::super::builtins::media_element_seekable(Some(st.current_time))
                }
                _ => Value::Object(super::super::builtins::make_empty_time_ranges()),
            },
            "buffered" | "seekable" => {
                Value::Object(super::super::builtins::make_empty_time_ranges())
            }
            // `video.videoWidth`/`.videoHeight`: MSE の場合は SourceBuffer の初期化セグメント
            // から得られた映像寸法を返し、それ以外は `0` を返す。
            "videoWidth" | "videoHeight"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "video").unwrap_or(false) =>
            {
                let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                if src.starts_with("blob:mediasource-") {
                    if let Some((w, h)) = super::super::builtins::media_source_video_dimensions(&src) {
                        return Value::Number(if key == "videoWidth" { w as f64 } else { h as f64 });
                    }
                }
                Value::Number(0.0)
            }
            "seeking" => Value::Bool(false),
            // `video.getVideoPlaybackQuality()`: 再生状態（`mse::PLAYBACK`）の累計フレーム数・
            // ドロップフレーム数を返す。
            "getVideoPlaybackQuality"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "video").unwrap_or(false) =>
            {
                Value::Object(Obj::native("getVideoPlaybackQuality", |_, _, _| {
                    let (total, dropped) = {
                        let pb = crate::os_lib::mse::PLAYBACK.lock();
                        (pb.total_video_frames as f64, pb.dropped_video_frames as f64)
                    };
                    let q = Obj::plain();
                    {
                        let mut b = q.borrow_mut();
                        b.props.insert("creationTime".into(), Value::Number(0.0));
                        b.props.insert("totalVideoFrames".into(), Value::Number(total));
                        b.props.insert("droppedVideoFrames".into(), Value::Number(dropped));
                        b.props.insert("corruptedVideoFrames".into(), Value::Number(0.0));
                    }
                    Ok(Value::Object(q))
                }))
            }
            // `audio`/`video.defaultPlaybackRate`（丸ごと未対応だった）。仕様上
            // `playbackRate`とは独立した既定値の保持先だが、この処理系には
            // 「再生開始時に既定値へリセットする」処理自体が無いため、単純に
            // 別の内部専用属性へ保存するだけの簡略実装。
            "defaultPlaybackRate" => Value::Number(
                self.dom
                    .borrow()
                    .get_attr(idx, "_default_playback_rate")
                    .and_then(|v| v.parse::<f64>().ok())
                    .unwrap_or(1.0),
            ),
            // `audio`/`video.preload`（既知の列挙値`"none"`/`"metadata"`/
            // `"auto"`のうち、属性が無ければ仕様上の欠落時既定値`"metadata"`、
            // 既知値以外なら不正値既定値`"auto"`にフォールバックする必要が
            // あるが、単純な属性直結ゲッターに落ちて空文字列になっていた
            // （`fieldset.type`等と同じバグパターン。2026-07-17 発見・実装）。
            "preload" => {
                let v = self.dom.borrow().get_attr(idx, "preload").map(|s| s.to_lowercase());
                match v.as_deref() {
                    None => Value::str("metadata"),
                    Some("none") => Value::str("none"),
                    Some("metadata") => Value::str("metadata"),
                    Some(_) => Value::str("auto"),
                }
            }
            // `video.poster`（丸ごと未対応だった。単純な文字列反映）。
            "poster" => Value::str(self.dom.borrow().get_attr(idx, "poster").unwrap_or_default()),
            // `track.kind`（`"subtitles"`/`"captions"`/`"descriptions"`/
            // `"chapters"`/`"metadata"`の列挙属性。`preload`と同じく
            // 「欠落時既定値」と「不正値既定値」が異なる特殊なケース
            // （欠落時は`"subtitles"`、既知値以外の不正値は`"metadata"`）。
            // プロパティ自体が丸ごと未対応だった。2026-07-17 発見・実装）。
            "kind" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "track").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "kind").map(|s| s.to_lowercase());
                match v.as_deref() {
                    None => Value::str("subtitles"),
                    Some("subtitles") => Value::str("subtitles"),
                    Some("captions") => Value::str("captions"),
                    Some("descriptions") => Value::str("descriptions"),
                    Some("chapters") => Value::str("chapters"),
                    Some(_) => Value::str("metadata"),
                }
            }
            // `a.ping`/`.hreflang`（丸ごと未対応だった。単純な文字列反映。
            // 実際の ping 送信/言語ヒント処理は対象外）。
            "ping" => Value::str(self.dom.borrow().get_attr(idx, "ping").unwrap_or_default()),
            "hreflang" => Value::str(self.dom.borrow().get_attr(idx, "hreflang").unwrap_or_default()),
            // `img`/`source`/`link.srcset`/`.sizes`（レスポンシブ画像の候補
            // リスト/表示サイズヒント。丸ごと未対応だった）。この処理系には実際の
            // 候補選択アルゴリズムが無いため属性値の反映のみ行う簡略実装。
            "srcset" => Value::str(self.dom.borrow().get_attr(idx, "srcset").unwrap_or_default()),
            // `link.sizes`は`img`/`source.sizes`（レスポンシブ画像の表示
            // サイズヒント、単純なDOMString）とは異なり、仕様上`DOMTokenList`
            // （アイコンサイズ`"16x16 32x32"`等の空白区切りトークン集合）。
            // 同名の属性を共有タグ間で単純な文字列反映アームに一括で
            // 落としていたため、`link`側だけ型が誤っていた（`part`/
            // `relList`と同じ「読み取り専用トークン配列」簡略実装で
            // 区別する）。2026-07-18 発見・実装）。
            "sizes" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "link").unwrap_or(false) => {
                let v = self.dom.borrow().get_attr(idx, "sizes").unwrap_or_default();
                Value::Object(Obj::array(v.split_whitespace().map(Value::str).collect()))
            }
            "sizes" => Value::str(self.dom.borrow().get_attr(idx, "sizes").unwrap_or_default()),
            // `link`/`style`/`source.media`（メディアクエリ文字列。丸ごと未対応
            // だった）。この処理系はこの属性に基づく実際の適用可否判定を行わない
            // ため属性値の反映のみ行う。
            "media" => Value::str(self.dom.borrow().get_attr(idx, "media").unwrap_or_default()),
            // `img.complete`/`.naturalWidth`/`.naturalHeight`（丸ごと未対応
            // だった。2026-07-17 発見）。実際の画像デコード（`web_engine/
            // image.rs`の`decode_image`）はレンダラ側で完結しており、
            // デコード後の実ピクセル寸法がDOMブリッジへ書き戻される経路が
            // 無いため、`naturalWidth`/`naturalHeight`は`buffered`/
            // `TimeRanges`と同方針の「状態追跡なし」の誠実な簡略実装として
            // 常に`0`を返す。`complete`はこの処理系がページ全体を同期的に
            // パースしてから`<script>`を実行する（`readyState`と同じ前提）
            // ため、`src`属性が設定されていれば「ロード試行済み」として
            // `true`を返す簡略実装（実デコード成否は反映しない）。
            "complete" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "img").unwrap_or(false) => {
                Value::Bool(self.dom.borrow().get_attr(idx, "src").map(|s| !s.is_empty()).unwrap_or(false))
            }
            "naturalWidth" | "naturalHeight"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "img").unwrap_or(false) =>
            {
                Value::Number(0.0)
            }
            // `img.useMap`/`.isMap`（イメージマップ関連。丸ごと未対応だった）。
            "useMap" => Value::str(self.dom.borrow().get_attr(idx, "usemap").unwrap_or_default()),
            // `img.decode()`（丸ごと未対応だった。`complete`と同じ前提で、
            // `src`があれば解決、無ければ拒否するPromiseを返す簡略実装。
            // 2026-07-17 発見・実装）。
            "decode" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "img").unwrap_or(false) => {
                Value::Object(Obj::native("decode", super::super::builtins::dom_img_decode))
            }
            "isMap" => Value::Bool(self.dom.borrow().has_attr(idx, "ismap")),
            // `img.currentSrc`（読み取り専用。レスポンシブ画像の候補選択
            // アルゴリズムの結果を表すが、この処理系にはその機構が無いため
            // `src` 属性をそのまま返す簡略実装。`srcset` のみ指定され `src` が
            // 無い場合は空文字列のまま=仕様上のフォールバックは対象外）。
            "currentSrc" => Value::str(self.dom.borrow().get_attr(idx, "src").unwrap_or_default()),
            // `img`/`script`/`link.crossOrigin`（丸ごと未対応だった）。この処理系
            // には実際の CORS リクエスト制御機構が無いため属性値の反映のみ行う。
            // 未指定時は仕様どおり `null`。
            "crossOrigin" => match self.dom.borrow().get_attr(idx, "crossorigin") {
                Some(v) => Value::str(v),
                None => Value::Null,
            },
            // `img`/`script`/`link.fetchPriority`（丸ごと未対応だった。既定値は
            // 仕様どおり `"auto"`）。
            "fetchPriority" => Value::str(
                self.dom.borrow().get_attr(idx, "fetchpriority").unwrap_or_else(|| "auto".into()),
            ),
            // `script`/`link.integrity`（丸ごと未対応だった。SRI 検証機構自体は
            // この処理系には無いため属性値の反映のみ行う）。
            "integrity" => Value::str(self.dom.borrow().get_attr(idx, "integrity").unwrap_or_default()),
            // `script.async`/`.defer`/`.noModule`（丸ごと未対応だった。`disabled`
            // 等と同じ真偽属性の反映のみを行う簡略実装）。
            "async" => Value::Bool(self.dom.borrow().has_attr(idx, "async")),
            "defer" => Value::Bool(self.dom.borrow().has_attr(idx, "defer")),
            "noModule" => Value::Bool(self.dom.borrow().has_attr(idx, "nomodule")),
            // `a`/`area`/`link.referrerPolicy`（丸ごと未対応だった）。この処理系は
            // 実際のリファラ送信制御機構を持たないため、`inputMode`等と同じ単純な
            // 文字列反映の簡略実装。
            "referrerPolicy" => {
                Value::str(self.dom.borrow().get_attr(idx, "referrerpolicy").unwrap_or_default())
            }
            // `link.as`（`rel="preload"`/`"prefetch"`と組み合わせて使う取得先
            // 種別ヒント。`referrerPolicy`と同じ単純な文字列反映だが丸ごと
            // 未対応だった。2026-07-18 発見・実装）。
            "as" => Value::str(self.dom.borrow().get_attr(idx, "as").unwrap_or_default()),
            // `link.imageSrcset`/`.imageSizes`（`rel="preload" as="image"`と
            // 組み合わせて使うレスポンシブ画像プリロードヒント。`link.as`
            // と同じ単純な文字列反映だが丸ごと未対応だった。2026-07-18
            // 発見・実装）。
            "imageSrcset" => Value::str(self.dom.borrow().get_attr(idx, "imagesrcset").unwrap_or_default()),
            "imageSizes" => Value::str(self.dom.borrow().get_attr(idx, "imagesizes").unwrap_or_default()),
            // `img`/`iframe.loading`（`lazy`/`eager`。既知の列挙値以外なら
            // 仕様上の既定値`"auto"`にフォールバックする必要があるが、
            // `fieldset.type`等と同じく単純な属性直結ゲッターに落ちて
            // 空文字列になっていた。2026-07-17 発見・実装）。この処理系には
            // 実際の遅延読み込み機構が無いため属性値の反映のみ行う。
            "loading" => {
                let v = self.dom.borrow().get_attr(idx, "loading").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("lazy") => Value::str("lazy"),
                    Some("eager") => Value::str("eager"),
                    _ => Value::str("auto"),
                }
            }
            // `img.decoding`（`sync`/`async`/`auto`。既知の列挙値以外なら
            // 仕様上の既定値`"auto"`にフォールバックする必要があるが、同じ
            // バグパターンで空文字列になっていた。2026-07-17 発見・実装）。
            "decoding" => {
                let v = self.dom.borrow().get_attr(idx, "decoding").map(|s| s.to_lowercase());
                match v.as_deref() {
                    Some("sync") => Value::str("sync"),
                    Some("async") => Value::str("async"),
                    _ => Value::str("auto"),
                }
            }
            // `iframe.allow`（Permissions Policy 文字列。丸ごと未対応だった）。
            "allow" => Value::str(self.dom.borrow().get_attr(idx, "allow").unwrap_or_default()),
            // `iframe.srcdoc`（単純な文字列反映だが丸ごと未対応だった。
            // 実際にsrcdoc内容をレンダリングする機構は無いため属性値の
            // 反映のみ行う簡略実装。2026-07-17 発見・実装）。
            "srcdoc" => Value::str(self.dom.borrow().get_attr(idx, "srcdoc").unwrap_or_default()),
            // `iframe.sandbox`（`rel`属性と同じ空白区切りトークンの `DOMTokenList`。
            // 丸ごと未対応だった）。`relList` と同じ方針で読み取り専用のトークン
            // 配列にとどめる簡略実装（実際のサンドボックス隔離機構自体もこの
            // 処理系には無い）。
            "sandbox" => {
                let v = self.dom.borrow().get_attr(idx, "sandbox").unwrap_or_default();
                Value::Object(Obj::array(v.split_whitespace().map(Value::str).collect()))
            }
            // `element.popover`（`popover` グローバル属性の JS プロパティ版。
            // 丸ごと未対応だった。`showPopover()`等のメソッド自体は前サイクルで
            // 実装済みだが、属性の読み書き用 IDL プロパティが欠けていた）。
            // 属性が無ければ仕様どおり `null`。
            "popover" => match self.dom.borrow().get_attr(idx, "popover") {
                Some(v) => Value::str(v),
                None => Value::Null,
            },
            // `button.popoverTargetElement`（`popovertarget` idref 属性を実際の
            // 要素へ解決する IDL 属性。丸ごと未対応だった。`label.control`と同じ
            // id 解決パターンを再利用）。`popoverTargetAction` は単純な文字列
            // 反映（`inputMode`等と同じ簡略実装）。
            // `a`/`area`/`link.relList`（`rel` 属性を空白区切りトークンの
            // 集合として扱う `DOMTokenList`。丸ごと未対応だった）。`classList`
            // ほど頻出でないため、専用の `Host("relList:N")` プロキシ
            // （`add`/`remove`/`toggle`等のフル実装）までは実装せず、
            // `element.attributes`（`NamedNodeMap`の簡略化）と同じ方針で
            // トークンの配列という読み取り専用の簡略表現にとどめる
            // （`for...of`/`.includes()`/`.length` という最頻出パターンは
            // これで満たせる）。
            "relList" => {
                let rel = self.dom.borrow().get_attr(idx, "rel").unwrap_or_default();
                let tokens: Vec<Value> =
                    rel.split_whitespace().map(Value::str).collect();
                Value::Object(Obj::array(tokens))
            }
            // `element.part`（CSS Shadow Parts。`part`属性を空白区切り
            // トークンとして扱う`DOMTokenList`。丸ごと未対応だった）。
            // この処理系にはShadow DOM自体が無く`::part()`セレクタも
            // 意味を持たないが、`relList`/`sandbox`と同じ「読み取り専用
            // トークン配列」簡略実装としてプロパティ自体は提供する。
            // 2026-07-18 発見・実装）。
            "part" => {
                let v = self.dom.borrow().get_attr(idx, "part").unwrap_or_default();
                Value::Object(Obj::array(v.split_whitespace().map(Value::str).collect()))
            }
            // `link`/`script.blocking`（レンダリングブロッキング指定を空白
            // 区切りトークンとして扱う`DOMTokenList`。丸ごと未対応
            // だった）。`part`/`relList`/`sandbox`と同じ読み取り専用
            // トークン配列の簡略実装。2026-07-18 発見・実装）。
            "blocking" => {
                let v = self.dom.borrow().get_attr(idx, "blocking").unwrap_or_default();
                Value::Object(Obj::array(v.split_whitespace().map(Value::str).collect()))
            }
            // `input.list`（`list` idref 属性から実際の `<datalist>` 要素を
            // 解決する IDL 属性。丸ごと未対応だった。`popoverTargetElement` と
            // 同じ id 解決パターンを再利用。参照先が `<datalist>` でなければ
            // 仕様どおり `null`）。
            "list" => {
                let dom = self.dom.borrow();
                match dom.get_attr(idx, "list").filter(|f| !f.is_empty()) {
                    Some(target_id) => match dom.get_element_by_id(&target_id) {
                        Some(ti) if dom.nodes.get(ti).map(|n| n.tag == "datalist").unwrap_or(false) => {
                            Value::Object(Obj::dom(ti))
                        }
                        _ => Value::Null,
                    },
                    None => Value::Null,
                }
            }
            "popoverTargetElement" => {
                let dom = self.dom.borrow();
                match dom.get_attr(idx, "popovertarget").filter(|f| !f.is_empty()) {
                    Some(target_id) => match dom.get_element_by_id(&target_id) {
                        Some(ti) => Value::Object(Obj::dom(ti)),
                        None => Value::Null,
                    },
                    None => Value::Null,
                }
            }
            "popoverTargetAction" => {
                Value::str(self.dom.borrow().get_attr(idx, "popovertargetaction").unwrap_or_default())
            }
            // `button.command`/`.commandForElement`（Invoker Commands API。
            // `<button command="show-modal" commandfor="my-dialog">`という
            // 宣言的UIパターンが丸ごと未対応だった。`popoverTargetElement`と
            // 全く同じidref解決パターンを再利用する（`commandfor`属性→実際の
            // 要素）。クリック時に実際に`CommandEvent`を発火し`show-modal`/
            // `close`/`toggle-popover`等の組込み動作を実行する経路は
            // `render.rs`側のクリックディスパッチへの新規配線が必要で改修
            // 範囲が広いため、本サイクルではプロパティ反映のみ実装する
            // （詳細はwalkthrough.md参照）。2026-07-18 発見・実装）。
            "command" => Value::str(self.dom.borrow().get_attr(idx, "command").unwrap_or_default()),
            "commandForElement" => {
                let dom = self.dom.borrow();
                match dom.get_attr(idx, "commandfor").filter(|f| !f.is_empty()) {
                    Some(target_id) => match dom.get_element_by_id(&target_id) {
                        Some(ti) => Value::Object(Obj::dom(ti)),
                        None => Value::Null,
                    },
                    None => Value::Null,
                }
            }
            "style" => Value::Object(Obj::host(&format!("style:{}", idx))),
            "classList" => Value::Object(Obj::host(&format!("classList:{}", idx))),
            "dataset" => Value::Object(Obj::host(&format!("dataset:{}", idx))),
            "addEventListener" => Value::Object(Obj::native(
                "addEventListener",
                super::super::builtins::dom_add_event_listener,
            )),
            "removeEventListener" => Value::Object(Obj::native(
                "removeEventListener",
                super::super::builtins::dom_remove_event_listener,
            )),
            "dispatchEvent" => Value::Object(Obj::native(
                "dispatchEvent",
                super::super::builtins::dom_dispatch_event,
            )),
            // `node.hasChildNodes()`（丸ごと未対応だった。2026-07-15 発見・実装）。
            "hasChildNodes" => Value::Object(Obj::native(
                "hasChildNodes",
                super::super::builtins::dom_has_child_nodes,
            )),
            "getAttribute" => Value::Object(Obj::native(
                "getAttribute",
                super::super::builtins::dom_get_attribute,
            )),
            // `getAttributeNode`/`setAttributeNode`/`removeAttributeNode`
            // （丸ごと未対応だった。`getAttribute` より古い/低レベルな `Attr`
            // ノード経由の定番イディオム。2026-07-14 発見・実装）。
            "getAttributeNode" => Value::Object(Obj::native(
                "getAttributeNode",
                super::super::builtins::dom_get_attribute_node,
            )),
            "getAttributeNodeNS" => Value::Object(Obj::native(
                "getAttributeNodeNS",
                super::super::builtins::dom_get_attribute_node_ns,
            )),
            "setAttributeNode" => Value::Object(Obj::native(
                "setAttributeNode",
                super::super::builtins::dom_set_attribute_node,
            )),
            "removeAttributeNode" => Value::Object(Obj::native(
                "removeAttributeNode",
                super::super::builtins::dom_remove_attribute_node,
            )),
            "setAttribute" => Value::Object(Obj::native(
                "setAttribute",
                super::super::builtins::dom_set_attribute,
            )),
            "hasAttribute" => Value::Object(Obj::native(
                "hasAttribute",
                super::super::builtins::dom_has_attribute,
            )),
            "removeAttribute" => Value::Object(Obj::native(
                "removeAttribute",
                super::super::builtins::dom_remove_attribute,
            )),
            "getAttributeNS" => Value::Object(Obj::native(
                "getAttributeNS",
                super::super::builtins::dom_get_attribute_ns,
            )),
            "setAttributeNS" => Value::Object(Obj::native(
                "setAttributeNS",
                super::super::builtins::dom_set_attribute_ns,
            )),
            "hasAttributeNS" => Value::Object(Obj::native(
                "hasAttributeNS",
                super::super::builtins::dom_has_attribute_ns,
            )),
            "removeAttributeNS" => Value::Object(Obj::native(
                "removeAttributeNS",
                super::super::builtins::dom_remove_attribute_ns,
            )),
            "getAttributeNames" => Value::Object(Obj::native(
                "getAttributeNames",
                super::super::builtins::dom_get_attribute_names,
            )),
            "hasAttributes" => Value::Object(Obj::native(
                "hasAttributes",
                super::super::builtins::dom_has_attributes,
            )),
            "normalize" => Value::Object(Obj::native("normalize", super::super::builtins::dom_normalize)),
            "isSameNode" => Value::Object(Obj::native("isSameNode", super::super::builtins::dom_is_same_node)),
            "isEqualNode" => {
                Value::Object(Obj::native("isEqualNode", super::super::builtins::dom_is_equal_node))
            }
            "matches" | "webkitMatchesSelector" => {
                Value::Object(Obj::native("matches", super::super::builtins::dom_matches))
            }
            "closest" => Value::Object(Obj::native("closest", super::super::builtins::dom_closest)),
            "getBoundingClientRect" => Value::Object(Obj::native(
                "getBoundingClientRect",
                super::super::builtins::dom_get_bounding_client_rect,
            )),
            "getClientRects" => Value::Object(Obj::native(
                "getClientRects",
                super::super::builtins::dom_get_client_rects,
            )),
            "setPointerCapture" => Value::Object(Obj::native(
                "setPointerCapture",
                super::super::builtins::dom_set_pointer_capture,
            )),
            "releasePointerCapture" => Value::Object(Obj::native(
                "releasePointerCapture",
                super::super::builtins::dom_release_pointer_capture,
            )),
            "hasPointerCapture" => Value::Object(Obj::native(
                "hasPointerCapture",
                super::super::builtins::dom_has_pointer_capture,
            )),
            "offsetWidth" => {
                Value::Number(self.dom.borrow().get_rect(idx).map(|r| r.2).unwrap_or(0) as f64)
            }
            "clientWidth" => {
                let dom = self.dom.borrow();
                let w = dom.get_rect(idx).map(|r| r.2).unwrap_or(0);
                let borders = dom.get_border_widths(idx);
                Value::Number((w - borders.3 - borders.1).max(0) as f64)
            }
            "offsetHeight" => {
                Value::Number(self.dom.borrow().get_rect(idx).map(|r| r.3).unwrap_or(0) as f64)
            }
            "clientHeight" => {
                let dom = self.dom.borrow();
                let h = dom.get_rect(idx).map(|r| r.3).unwrap_or(0);
                let borders = dom.get_border_widths(idx);
                Value::Number((h - borders.0 - borders.2).max(0) as f64)
            }
            "offsetLeft" => {
                Value::Number(self.dom.borrow().get_rect(idx).map(|r| r.0).unwrap_or(0) as f64)
            }
            "offsetTop" => {
                Value::Number(self.dom.borrow().get_rect(idx).map(|r| r.1).unwrap_or(0) as f64)
            }
            // `element.offsetParent`（HTML5。丸ごと未対応だった。`offsetLeft`/
            // `offsetTop` と組み合わせて祖先からの相対位置を計算する定番
            // パターンで使われる）。
            "offsetParent" => match self.dom.borrow().offset_parent(idx) {
                Some(pi) => Value::Object(Obj::dom(pi)),
                None => Value::Null,
            },
            "scrollWidth" => {
                let dom = self.dom.borrow();
                let v = dom.scroll_widths.get(&idx).copied().unwrap_or_else(|| {
                    dom.get_rect(idx).map(|r| r.2).unwrap_or(0)
                });
                Value::Number(v as f64)
            }
            "scrollHeight" => {
                let dom = self.dom.borrow();
                let v = dom.scroll_heights.get(&idx).copied().unwrap_or_else(|| {
                    dom.get_rect(idx).map(|r| r.3).unwrap_or(0)
                });
                Value::Number(v as f64)
            }
            "scrollTop" => {
                let v = self.dom.borrow().scroll_tops.get(&idx).copied().unwrap_or(0);
                Value::Number(v as f64)
            }
            "scrollLeft" => {
                let v = self.dom.borrow().scroll_lefts.get(&idx).copied().unwrap_or(0);
                Value::Number(v as f64)
            }
            "clientLeft" => {
                let borders = self.dom.borrow().get_border_widths(idx);
                Value::Number(borders.3 as f64)
            }
            "clientTop" => {
                let borders = self.dom.borrow().get_border_widths(idx);
                Value::Number(borders.0 as f64)
            }
            // `nodeType` が常に `1`（ELEMENT_NODE）固定で、テキストノードでも
            // `3`（TEXT_NODE）を返さないバグだった。`nodeName` も同様にテキストノードで
            // 仕様どおりの `"#text"` ではなく空文字列（`tag` がテキストノードでは
            // 空のため）になっていた。
            "nodeType" => {
                let tag = self.dom.borrow().nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
                let is_text = self.dom.borrow().nodes.get(idx).map(|n| n.is_text).unwrap_or(false);
                let num = if is_text {
                    3.0
                } else if tag == "#comment" {
                    8.0
                } else if tag == "#document-fragment" || tag == "#fragment" {
                    11.0
                } else {
                    1.0
                };
                Value::Number(num)
            }
            "nodeName" => {
                let dom = self.dom.borrow();
                let name = match dom.nodes.get(idx) {
                    Some(n) if n.is_text => String::from("#text"),
                    Some(n) if n.tag == "#comment" => String::from("#comment"),
                    Some(n) if n.tag == "#document-fragment" || n.tag == "#fragment" => String::from("#document-fragment"),
                    Some(n) => n.tag.to_uppercase(),
                    None => String::new(),
                };
                Value::str(name)
            }
            // `node.nodeValue`（テキストノードでは自身のテキスト、要素ノードでは
            // 仕様どおり `null`）が `nodeType`/`nodeName` と同じ理由で丸ごと未対応
            // だった。`childNodes` 経由で得たテキストノードの中身を読む定番パターンで
            // 使われる。
            "nodeValue" => {
                let dom = self.dom.borrow();
                match dom.nodes.get(idx) {
                    Some(n) if n.is_text || n.tag == "#comment" => Value::str(dom.get_text_content(idx)),
                    _ => Value::Null,
                }
            }
            // `CharacterData.data`/`.length`（テキストノードの生データ
            // アクセサ。丸ごと未対応だった。`nodeValue`と同じ値を指す
            // エイリアスだが、`textNode.data`単体で読み書きする定番
            // イディオムには`nodeValue`だけでは対応できていなかった。
            // 2026-07-16 発見）。文字数は他の文字列系メソッド群
            // （`str_slice`/`str_substring`）と同じ char 単位の簡略実装。
            "data" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::str(self.dom.borrow().get_text_content(idx))
            }
            "length" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::Number(self.dom.borrow().get_text_content(idx).chars().count() as f64)
            }
            // `CharacterData.appendData`/`.deleteData`/`.insertData`/
            // `.replaceData`/`.substringData`（丸ごと未対応だった。
            // 2026-07-16 発見）。テキストノード以外では no-op/空文字列を
            // 返す誠実な簡略実装。
            "appendData" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::Object(Obj::native("appendData", super::super::builtins::dom_char_data_append))
            }
            "deleteData" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::Object(Obj::native("deleteData", super::super::builtins::dom_char_data_delete))
            }
            "insertData" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::Object(Obj::native("insertData", super::super::builtins::dom_char_data_insert))
            }
            "replaceData" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::Object(Obj::native("replaceData", super::super::builtins::dom_char_data_replace))
            }
            "substringData" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false) => {
                Value::Object(Obj::native("substringData", super::super::builtins::dom_char_data_substring))
            }
            // `Text.splitText(offset)`（丸ごと未対応だった。2026-07-16 発見・実装）。
            "splitText" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text).unwrap_or(false) => {
                Value::Object(Obj::native("splitText", super::super::builtins::dom_split_text))
            }
            // `Text.wholeText`（丸ごと未対応だった。`splitText`と対をなす
            // 逆操作の読み取りプロパティ。2026-07-16 発見・実装）。連続する
            // テキストノード兄弟（`splitText`で分割した直後等）の`data`を
            // 全て連結した文字列を返す。
            "wholeText" if self.dom.borrow().nodes.get(idx).map(|n| n.is_text).unwrap_or(false) => {
                let dom = self.dom.borrow();
                let parent = dom.nodes.get(idx).and_then(|n| n.parent);
                let out = match parent {
                    Some(p) => {
                        let is_text = |c: usize| dom.nodes.get(c).map(|n| n.is_text).unwrap_or(false);
                        let children = &dom.nodes[p].children;
                        let pos = children.iter().position(|&c| c == idx).unwrap_or(0);
                        let mut start = pos;
                        while start > 0 && is_text(children[start - 1]) {
                            start -= 1;
                        }
                        let mut end = pos;
                        while end + 1 < children.len() && is_text(children[end + 1]) {
                            end += 1;
                        }
                        children[start..=end].iter().map(|&c| dom.get_text_content(c)).collect()
                    }
                    None => dom.get_text_content(idx),
                };
                Value::str(out)
            }
            // `childNodes`/`firstChild`/`lastChild`/`nextSibling`/`previousSibling`
            // （テキストノードも含む Node レベルの走査 API）が丸ごと未対応だった。
            // `children`/`firstElementChild`/.../`nextElementSibling` 等（要素のみに
            // 絞る Element レベルの API）は既に対応済みだったが、対をなす Node 版が
            // 漏れていた。
            "childNodes" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let kids = if is_template {
                    Vec::new()
                } else {
                    self.dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.children.clone())
                        .unwrap_or_default()
                };
                Value::Object(Obj::array(
                    kids.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                ))
            }
            "firstChild" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let first = if is_template {
                    None
                } else {
                    self.dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .and_then(|n| n.children.first().copied())
                };
                match first {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            "lastChild" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let last = if is_template {
                    None
                } else {
                    self.dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .and_then(|n| n.children.last().copied())
                };
                match last {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            "nextSibling" | "previousSibling" => {
                let dom = self.dom.borrow();
                let sib = dom.nodes.get(idx).and_then(|n| n.parent).and_then(|p| {
                    let kids = &dom.nodes.get(p)?.children;
                    let pos = kids.iter().position(|&c| c == idx)?;
                    if key == "nextSibling" {
                        kids.get(pos + 1).copied()
                    } else if pos > 0 {
                        kids.get(pos - 1).copied()
                    } else {
                        None
                    }
                });
                match sib {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            "hidden" => Value::Bool(self.dom.borrow().has_attr(idx, "hidden")),
            "querySelector" => Value::Object(Obj::native(
                "querySelector",
                super::super::builtins::dom_element_query_selector,
            )),
            "querySelectorAll" => Value::Object(Obj::native(
                "querySelectorAll",
                super::super::builtins::dom_element_query_selector_all,
            )),
            // `document.getElementsByClassName`/`.getElementsByTagName` は対応済み
            // だったが、要素インスタンス版（自身の子孫のみに絞り込む）が丸ごと
            // 未対応だった。
            "getElementsByClassName" => Value::Object(Obj::native(
                "getElementsByClassName",
                super::super::builtins::dom_element_get_elements_by_class_name,
            )),
            "getElementsByTagName" => Value::Object(Obj::native(
                "getElementsByTagName",
                super::super::builtins::dom_element_get_elements_by_tag_name,
            )),
            "getElementsByTagNameNS" => Value::Object(Obj::native(
                "getElementsByTagNameNS",
                super::super::builtins::dom_element_get_elements_by_tag_name_ns,
            )),
            "appendChild" => Value::Object(Obj::native(
                "appendChild",
                super::super::builtins::dom_append_child,
            )),
            "insertBefore" => Value::Object(Obj::native(
                "insertBefore",
                super::super::builtins::dom_insert_before,
            )),
            // `parent.moveBefore(movedNode, referenceNode)`（丸ごと未対応
            // だった。詳細は`dom_move_before`参照。2026-07-18 発見・実装）。
            "moveBefore" => Value::Object(Obj::native(
                "moveBefore",
                super::super::builtins::dom_move_before,
            )),
            "replaceChild" => Value::Object(Obj::native(
                "replaceChild",
                super::super::builtins::dom_replace_child,
            )),
            "cloneNode" => Value::Object(Obj::native("cloneNode", super::super::builtins::dom_clone_node)),
            "contains" => Value::Object(Obj::native("contains", super::super::builtins::dom_contains)),
            "compareDocumentPosition" => Value::Object(Obj::native(
                "compareDocumentPosition",
                super::super::builtins::dom_compare_document_position,
            )),
            "getRootNode" => Value::Object(Obj::native(
                "getRootNode",
                super::super::builtins::dom_get_root_node,
            )),
            // `lookupNamespaceURI`/`lookupPrefix`/`isDefaultNamespace`（丸ごと
            // 未対応だった。この処理系は XML 名前空間を一切モデル化していない
            // ため常に「名前空間なし」を返す簡略実装。詳細は builtins.rs 参照。
            "lookupNamespaceURI" => Value::Object(Obj::native(
                "lookupNamespaceURI",
                super::super::builtins::dom_lookup_namespace_uri,
            )),
            "lookupPrefix" => Value::Object(Obj::native(
                "lookupPrefix",
                super::super::builtins::dom_lookup_prefix,
            )),
            // `element.checkVisibility()`（DOM 標準。丸ごと未対応だった）。
            "checkVisibility" => Value::Object(Obj::native(
                "checkVisibility",
                super::super::builtins::dom_check_visibility,
            )),
            "isDefaultNamespace" => Value::Object(Obj::native(
                "isDefaultNamespace",
                super::super::builtins::dom_is_default_namespace,
            )),
            // `element.requestFullscreen()`（Fullscreen API + ベンダープレフィックス別名）。
            // 詳細は `builtins::dom_request_fullscreen` 参照。
            "requestFullscreen"
            | "webkitRequestFullscreen"
            | "webkitRequestFullScreen"
            | "mozRequestFullScreen"
            | "msRequestFullscreen" => Value::Object(Obj::native(
                "requestFullscreen",
                super::super::builtins::dom_request_fullscreen,
            )),
            // `element.requestPointerLock()`（Pointer Lock API。丸ごと未対応
            // だった）。詳細は `builtins::dom_request_pointer_lock` 参照。
            "requestPointerLock" => Value::Object(Obj::native(
                "requestPointerLock",
                super::super::builtins::dom_request_pointer_lock,
            )),
            // `<video>.requestPictureInPicture()`（Picture-in-Picture API。丸ごと
            // 未対応だった）。詳細は `builtins::dom_request_picture_in_picture` 参照。
            "requestPictureInPicture" => Value::Object(Obj::native(
                "requestPictureInPicture",
                super::super::builtins::dom_request_picture_in_picture,
            )),
            "append" => Value::Object(Obj::native("append", super::super::builtins::dom_append)),
            "prepend" => Value::Object(Obj::native("prepend", super::super::builtins::dom_prepend)),
            // `element.replaceChildren(...nodes)`（`innerHTML=''; append(...)` の
            // 1行版として使われる定番イディオム）が丸ごと未対応だった。
            "replaceChildren" => Value::Object(Obj::native(
                "replaceChildren",
                super::super::builtins::dom_replace_children,
            )),
            "before" => Value::Object(Obj::native("before", super::super::builtins::dom_before)),
            "after" => Value::Object(Obj::native("after", super::super::builtins::dom_after)),
            "replaceWith" => Value::Object(Obj::native(
                "replaceWith",
                super::super::builtins::dom_replace_with,
            )),
            "insertAdjacentHTML" => Value::Object(Obj::native(
                "insertAdjacentHTML",
                super::super::builtins::dom_insert_adjacent_html,
            )),
            // `element.getHTML()`/`.setHTMLUnsafe()`（丸ごと未対応だった。
            // 詳細は`dom_get_html`/`dom_set_html_unsafe`参照。2026-07-18
            // 発見・実装）。
            "getHTML" => Value::Object(Obj::native("getHTML", super::super::builtins::dom_get_html)),
            "setHTMLUnsafe" => Value::Object(Obj::native(
                "setHTMLUnsafe",
                super::super::builtins::dom_set_html_unsafe,
            )),
            "insertAdjacentElement" => Value::Object(Obj::native(
                "insertAdjacentElement",
                super::super::builtins::dom_insert_adjacent_element,
            )),
            "insertAdjacentText" => Value::Object(Obj::native(
                "insertAdjacentText",
                super::super::builtins::dom_insert_adjacent_text,
            )),
            "toggleAttribute" => Value::Object(Obj::native(
                "toggleAttribute",
                super::super::builtins::dom_toggle_attribute,
            )),
            // `dialog.show()`/`.showModal()`/`.close(returnValue?)`（`<dialog>` が丸ごと
            // 未対応だった）。`open` 属性の付け外しのみを行う簡略実装（`::backdrop` 描画・
            // モーダルフォーカストラップ・ESC キーでの自動 close は対象外）。
            "show" => Value::Object(Obj::native("show", super::super::builtins::dom_dialog_show)),
            "showModal" => {
                Value::Object(Obj::native("showModal", super::super::builtins::dom_dialog_show_modal))
            }
            "close" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "dialog").unwrap_or(false) => {
                Value::Object(Obj::native("close", super::super::builtins::dom_dialog_close))
            }
            // `dialog.requestClose(returnValue?)`（`.close()`と違い、閉じる
            // 直前に取消可能な`cancel`イベントを発火する。丸ごと未対応
            // だった。2026-07-18 発見・実装）。
            "requestClose"
                if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "dialog").unwrap_or(false) =>
            {
                Value::Object(Obj::native("requestClose", super::super::builtins::dom_dialog_request_close))
            }
            // Popover API（`popover` グローバル属性。丸ごと未対応だった）。`dialog`
            // の `show`/`close` と同じ「内部専用属性の付け外しのみ」の簡略実装。
            "showPopover" => Value::Object(Obj::native(
                "showPopover",
                super::super::builtins::dom_show_popover,
            )),
            "hidePopover" => Value::Object(Obj::native(
                "hidePopover",
                super::super::builtins::dom_hide_popover,
            )),
            "togglePopover" => Value::Object(Obj::native(
                "togglePopover",
                super::super::builtins::dom_toggle_popover,
            )),
            "removeChild" => Value::Object(Obj::native(
                "removeChild",
                super::super::builtins::dom_remove_child,
            )),
            "remove" => Value::Object(Obj::native("remove", super::super::builtins::dom_remove)),
            // `node.ownerDocument`（`element.ownerDocument.createElement(...)` という
            // 定番イディオムや単純な機能検出で使われる）が丸ごと未対応だった。この
            // エンジンには document は常に1つしか無いため、グローバルの `document`
            // オブジェクトをそのまま返せばよい。
            "ownerDocument" => match self.global.borrow().vars.get("document") {
                Some(d) => d.clone(),
                None => Value::Null,
            },
            // `node.isConnected`（現在 document に接続されているかの真偽値。
            // `createElement` 直後や `remove()` 済みのノードで `false` になる。
            // click-outside 判定等で `contains`/`querySelector` と並んでよく使われる）が
            // 丸ごと未対応だった。既存の `is_attached`（`getElementById` 等が内部で
            // 使っていた到達可能性チェック）をそのまま公開すれば実装できる。
            "isConnected" => Value::Bool(self.dom.borrow().is_attached(idx)),
            // ナビゲーション系プロパティ（メソッドではなく値）。
            "parentElement" | "parentNode" => {
                let p = self.dom.borrow().nodes.get(idx).and_then(|n| n.parent);
                match p {
                    Some(pi) => Value::Object(Obj::dom(pi)),
                    None => Value::Null,
                }
            }
            "children" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let kids = if is_template { Vec::new() } else { self.dom.borrow().element_children(idx) };
                super::super::builtins::make_html_collection(self, kids)
            }
            "childElementCount" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let count = if is_template { 0 } else { self.dom.borrow().element_children(idx).len() };
                Value::Number(count as f64)
            }
            "firstElementChild" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let first = if is_template { None } else { self.dom.borrow().element_children(idx).first().copied() };
                match first {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            "lastElementChild" => {
                let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                let last = if is_template { None } else { self.dom.borrow().element_children(idx).last().copied() };
                match last {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            "nextElementSibling" | "previousElementSibling" => {
                let dom = self.dom.borrow();
                let sib = dom.nodes.get(idx).and_then(|n| n.parent).and_then(|p| {
                    let kids = dom.element_children(p);
                    let pos = kids.iter().position(|&c| c == idx);
                    match pos {
                        Some(pi) if key == "nextElementSibling" => kids.get(pi + 1).copied(),
                        Some(pi) if pi > 0 => kids.get(pi - 1).copied(),
                        _ => None,
                    }
                });
                match sib {
                    Some(i) => Value::Object(Obj::dom(i)),
                    None => Value::Null,
                }
            }
            "click" => Value::Object(Obj::native("click", super::super::builtins::dom_click)),
            // `form.requestSubmit(submitter?)`/`form.submit()`（HTML5）が丸ごと
            // 未対応だった（`submit`type ボタンのクリック経由の送信は既に
            // `web_engine/render.rs` から動いていたが、JS から直接呼ぶ経路が
            // 無かった）。`requestSubmit` は仕様どおり `submit` イベントを発火
            // （`preventDefault()` で中止可能）。`submit` は仕様上イベント発火も
            // バリデーションもバイパスして直接送信するが、この処理系には実際の
            // フォーム送信/ページ遷移パイプライン自体が無いため、`focus`/`blur`/
            // `scrollIntoView` と同じ無害な no-op とする。
            "requestSubmit" => {
                Value::Object(Obj::native("requestSubmit", super::super::builtins::dom_request_submit))
            }
            "submit" => Value::Object(Obj::native("domNoop", |_, _, _| Ok(Value::Undefined))),
            "reset" => Value::Object(Obj::native("reset", super::super::builtins::dom_form_reset)),
            // `input.showPicker()`（HTML5。`<input type="date/color/file">` 等の
            // ネイティブピッカー UI を開く）が丸ごと未対応だった。この処理系には
            // そもそもネイティブピッカー UI 自体が無いため、`focus`/`blur`/
            // `scrollIntoView`/`submit` と同じ無害な no-op とする（仕様上の
            // `InvalidStateError`/`NotAllowedError` 例外条件はチェックしない
            // 簡略実装）。
            "showPicker" => Value::Object(Obj::native("domNoop", |_, _, _| Ok(Value::Undefined))),
            // `element.getAnimations()`（丸ごと未対応だった）。既存の
            // `.animate()` は呼び出しごとに使い捨ての no-op `Animation`
            // オブジェクトを返すだけで、要素側に一切保持していないため、
            // 実行中アニメーションが無いという誠実な空配列を返す簡略実装。
            "getAnimations" => Value::Object(Obj::native(
                "getAnimations",
                |_, _, _| Ok(Value::Object(Obj::array(alloc::vec![]))),
            )),
            // `input.stepUp(n?)`/`.stepDown(n?)`（HTML5）が丸ごと未対応だった
            // （詳細は builtins.rs の `dom_step_by` 実装コメント参照）。
            "stepUp" => Value::Object(Obj::native("stepUp", super::super::builtins::dom_step_up)),
            "stepDown" => Value::Object(Obj::native("stepDown", super::super::builtins::dom_step_down)),
            // `element.scrollTo(x,y)`/`.scrollBy(x,y)`/`.scroll(x,y)`（オブジェクト引数 `{top,left}`
            // 形式も含む）。`scroll` は W3C 仕様で `scrollTo` の同義エイリアス。
            "scroll" => Value::Object(Obj::native("scroll", super::super::builtins::dom_scroll_to)),
            "scrollTo" => Value::Object(Obj::native("scrollTo", super::super::builtins::dom_scroll_to)),
            "scrollBy" => Value::Object(Obj::native("scrollBy", super::super::builtins::dom_scroll_by)),
            // `scrollIntoView` は既存の`window.scrollTo`と同じ`pending_scroll_abs_y`
            // 機構を再利用して実装済み（2026-07-22。詳細は`dom_scroll_into_view`
            // のdocコメント参照）。
            "scrollIntoView" => Value::Object(Obj::native("scrollIntoView", super::super::builtins::dom_scroll_into_view)),
            "scrollIntoViewIfNeeded" => Value::Object(Obj::native("scrollIntoViewIfNeeded", super::super::builtins::dom_scroll_into_view)),
            // `element.focus()`/`.blur()`（HTML5。丸ごと未対応だった。以前は
            // `scrollIntoView` と同じ no-op 扱いで、`document.activeElement` が
            // 常に `null` 固定になる原因だった。詳細は `dom_focus`/`dom_blur` 参照）。
            "focus" => Value::Object(Obj::native("focus", super::super::builtins::dom_focus)),
            "blur" => Value::Object(Obj::native("blur", super::super::builtins::dom_blur)),
            // `<audio>`/`<video>` の `.play()`/`.pause()`/`.load()`/`.canPlayType()`
            // （HTMLMediaElement。丸ごと未対応だった。呼ぶだけで
            // `TypeError: not a function` になっていた）。実際の音声/映像出力までは
            // 配線しない無害な簡略実装（`focus`/`blur` と同種の割り切り）だが、
            // `.play()` は仕様どおり Promise を返す必要があるため専用の関数とする
            // （`.then()`/`await` する定番パターンで別種のエラーになるのを防ぐ）。
            "play" => Value::Object(Obj::native("play", super::super::builtins::dom_media_play)),
            "pause" => Value::Object(Obj::native("pause", super::super::builtins::dom_media_pause)),
            "load" => Value::Object(Obj::native("domNoop", |_, _, _| Ok(Value::Undefined))),
            // `canPlayType(type)`（W3C HTML5 §4.8.14.4）
            // AtmOS のメディアデコーダ機能に基づき "probably" / "maybe" / "" を返す。
            "canPlayType" => {
                Value::Object(Obj::native("canPlayType", |_, _, args| {
                    let type_str = args.first().map(|v| v.to_js_string()).unwrap_or_default();
                    let res = crate::os_lib::web_engine::media_controls::can_play_type(&type_str);
                    Ok(Value::str(res))
                }))
            }
            // Element.animate() → no-op Animation オブジェクトを返す
            "animate" => Value::Object(Obj::native("animate", |_, _, _| {
                let anim = Obj::plain();
                {
                    let mut b = anim.borrow_mut();
                    b.props.insert(
                        "play".into(),
                        Value::Object(Obj::native("play", |_, _, _| Ok(Value::Undefined))),
                    );
                    b.props.insert(
                        "pause".into(),
                        Value::Object(Obj::native("pause", |_, _, _| Ok(Value::Undefined))),
                    );
                    b.props.insert(
                        "cancel".into(),
                        Value::Object(Obj::native("cancel", |_, _, _| Ok(Value::Undefined))),
                    );
                    // `reverse()`/`finish()`（丸ごと未対応だった。`play`/
                    // `pause`/`cancel`と同じ「実際のアニメーション実行機構が
                    // 無いno-op」の簡略方針。2026-07-17 発見・実装）。
                    b.props.insert(
                        "reverse".into(),
                        Value::Object(Obj::native("reverse", |_, _, _| Ok(Value::Undefined))),
                    );
                    b.props.insert(
                        "finish".into(),
                        Value::Object(Obj::native("finish", |_, _, _| Ok(Value::Undefined))),
                    );
                    b.props.insert(
                        "finished".into(),
                        Value::Object(super::super::builtins::make_resolved_promise(Value::Undefined)),
                    );
                    b.props.insert("playState".into(), Value::str("finished"));
                    b.props.insert("currentTime".into(), Value::Number(0.0));
                    // `playbackRate`（丸ごと未対応だった。読み書き可能な
                    // 単純プロパティとして反映するのみで、実際の再生速度への
                    // 影響は対象外）。
                    b.props.insert("playbackRate".into(), Value::Number(1.0));
                }
                Ok(Value::Object(anim))
            })),
            // --- HTML5 制約バリデーション ---
            "checkValidity" => Value::Object(Obj::native(
                "checkValidity",
                super::super::builtins::dom_check_validity,
            )),
            "reportValidity" => Value::Object(Obj::native(
                "reportValidity",
                super::super::builtins::dom_check_validity,
            )),
            "setCustomValidity" => Value::Object(Obj::native(
                "setCustomValidity",
                super::super::builtins::dom_set_custom_validity,
            )),
            "validationMessage" => {
                let v = self.dom.borrow().effective_form_value(idx);
                Value::str(
                    self.dom
                        .borrow()
                        .validate_field(idx, &v)
                        .unwrap_or_default(),
                )
            }
            "willValidate" => {
                // 仕様上「制約検証の対象候補」になれるのは`button`/`input`/
                // `select`/`textarea`の4タグのみ（`output`は明示的に対象外、
                // `fieldset`/`object`等の非フォームコントロールも対象外）。
                // 以前はタグを一切見ておらず、`type`/`disabled`だけで判定
                // していたため、`<output>`や`<div>`のような本来常に`false`
                // であるべき要素まで`type`属性が無い（`ty==""`）ことで
                // 除外リストに引っかからず`true`になってしまう実害のある
                // バグだった。2026-07-18 発見・修正）。
                let dom = self.dom.borrow();
                let tag = dom.nodes.get(idx).map(|n| n.tag.as_str()).unwrap_or("");
                let is_candidate_tag = matches!(tag, "button" | "input" | "select" | "textarea");
                let disabled = dom.has_attr(idx, "disabled");
                let ty = dom.get_attr(idx, "type").unwrap_or_default().to_lowercase();
                let excluded_type = matches!(
                    ty.as_str(),
                    "submit" | "button" | "reset" | "hidden" | "image"
                );
                Value::Bool(is_candidate_tag && !disabled && !excluded_type)
            }
            // `element.validity` が `valid`/`valueMissing`/`customError` の3つしか
            // 公開しておらず、`.validity.patternMismatch`/`.typeMismatch`/
            // `.rangeOverflow`/`.rangeUnderflow`/`.stepMismatch`/`.tooLong`/
            // `.tooShort`/`.badInput` という特定の制約を狙い撃ちしてエラーメッセージを
            // 出し分ける ValidityState の標準的な使い方（`patternMismatch` だけ拾って
            // 独自メッセージを出す等）が常に `undefined`（falsy）になっていたバグ。
            "validity" => {
                let v = self.dom.borrow().effective_form_value(idx);
                let flags = self.dom.borrow().validity_flags(idx, &v);
                let vs = Obj::plain();
                {
                    let mut b = vs.borrow_mut();
                    b.props.insert("valid".into(), Value::Bool(flags.valid()));
                    b.props
                        .insert("valueMissing".into(), Value::Bool(flags.value_missing));
                    b.props
                        .insert("typeMismatch".into(), Value::Bool(flags.type_mismatch));
                    b.props
                        .insert("patternMismatch".into(), Value::Bool(flags.pattern_mismatch));
                    b.props.insert("tooLong".into(), Value::Bool(flags.too_long));
                    b.props.insert("tooShort".into(), Value::Bool(flags.too_short));
                    b.props
                        .insert("rangeOverflow".into(), Value::Bool(flags.range_overflow));
                    b.props
                        .insert("rangeUnderflow".into(), Value::Bool(flags.range_underflow));
                    b.props
                        .insert("stepMismatch".into(), Value::Bool(flags.step_mismatch));
                    b.props.insert("badInput".into(), Value::Bool(flags.bad_input));
                    b.props
                        .insert("customError".into(), Value::Bool(flags.custom_error));
                }
                Value::Object(vs)
            }
            // ARIA 反映 IDL 属性（`element.role`/`.ariaLabel`/`.ariaChecked` 等）が
            // 丸ごと未対応だった。`aria-*` 属性は複合語内部にハイフンを持たない
            // （例: `aria-valuenow`。`aria-value-now` ではない）ため、`dataset` と
            // 同じ単純な camelCase⇄kebab-case変換は使えず、`aria_attr_name` の
            // 固定対応表で個別に引く。未設定なら（`dataset` の空文字列とは異なり）
            // 仕様どおり `null`。
            key if aria_attr_name(key).is_some() => {
                let attr = aria_attr_name(key).unwrap_or_default();
                match self.dom.borrow().get_attr(idx, attr) {
                    Some(v) => Value::str(v),
                    None => Value::Null,
                }
            }
            // GlobalEventHandlers（element.onchange/element.onclick 等）。
            // 【2026-07-23】関数値は`Obj::dom(idx)`（呼び出す度に使い捨てで新規生成
            // される）の`.props`ではなく、永続ストレージ`DomBridge::on_handlers`
            // から読む（詳細は`dom_bridge.rs`の`on_handlers`フィールドコメント参照）。
            key if key.starts_with("on") && key.len() > 2 => {
                if let Some(val) = self.dom.borrow().get_on_handler(idx, key) {
                    if !matches!(val, Value::Undefined) {
                        return val;
                    }
                }
                match self.dom.borrow().get_attr(idx, key) {
                    Some(v) => Value::str(v),
                    None => Value::Null,
                }
            }
            // 組込みに無い名前は原型の連鎖（HTMLXxxElement.prototype → … → Node.prototype →
            // EventTarget.prototype）から引く。アクセサは要素を this にして呼ぶ。
            // 【2026-10-19】ShadyDOM（YouTube の視聴ページ）が原型に定義する `__shady_native_*` 等が
            // 要素から見えず「is not a function」で止まっていた。
            _ if builtin_only => Value::Undefined,
            _ => self.dom_proto_chain_get(idx, key),
        }
    }

    /// DOM 要素の原型の連鎖から `key` を引く（無ければ undefined）。
    fn dom_proto_chain_get(&mut self, idx: usize, key: &str) -> Value {
        let recv = Value::Object(Obj::dom(idx));
        let mut cur = self.get_dom_node_proto(idx);
        let mut guard = 0;
        while let Some(p) = cur {
            let getter = p.borrow().accessors.get(key).map(|a| a.get.clone());
            if let Some(g) = getter {
                return match g {
                    Some(g) => self.call_value(&g, recv, &[]).unwrap_or(Value::Undefined),
                    None => Value::Undefined,
                };
            }
            if let Some(v) = p.borrow().props.get(key).cloned() {
                return v;
            }
            guard += 1;
            if guard > 64 {
                break;
            }
            cur = p.borrow().proto.clone();
        }
        // 連鎖の終端は Object.prototype（組込みのメソッドは実体から解決する方式なので、ここで補う）。
        // 【2026-10-20】Polymer の iron-iconset-svg が `this.hasOwnProperty(…)` で落ちていた。
        super::super::builtins::object_get(&Obj::plain(), key)
    }

    pub(crate) fn dom_set_property(&mut self, disp: DomDisp, key: &str, val: Value) {
        let s = val.to_js_string();
        // `textContent`/`innerHTML`/`innerText`/`nodeValue` は WebIDL 上 nullable な
        // `DOMString?`（または `[LegacyNullToEmptyString]`）として定義されており、
        // `null`/`undefined` の代入は通常の `ToString`（`"null"`/`"undefined"` という
        // 文字列）ではなく空文字列に変換されるべき。以前は他のプロパティ（`id`/
        // `className` 等、nullable でない通常の `DOMString`）と同じ `to_js_string()`
        // を無条件で使っており、`el.textContent = null` が空にする代わりに文字通り
        // "null" というテキストを設定してしまう静かなバグだった。
        let s_nullable = if matches!(val, Value::Null | Value::Undefined) {
            String::new()
        } else {
            s.clone()
        };
        match disp {
            DomDisp::Element(idx) => match key {
                "textContent" | "innerText" | "text" => {
                    self.dom.borrow_mut().set_text_content(idx, &s_nullable)
                }
                // `element.outerText`（丸ごと未対応だった。読み出しは
                // `innerText`と同じだが、書き込みは`innerText`と違って
                // 自身の中身ではなく自身「そのもの」をテキストノードへ
                // 置き換える点が違う。親が無ければ仕様上例外だが、他の
                // 簡略実装と同じ方針でno-opにする）。2026-07-18
                // 発見・実装）。
                "outerText" => {
                    let parent = self.dom.borrow().nodes.get(idx).and_then(|n| n.parent);
                    if let Some(parent) = parent {
                        let text_idx = self.dom.borrow_mut().create_text_node(&s_nullable);
                        self.dom.borrow_mut().replace_child(parent, text_idx, idx);
                    }
                }
                // `nodeValue` の代入は仕様上テキストノードのみ効果を持つ（要素ノードへの
                // 代入は no-op）。`textContent` と違い要素の子を丸ごと差し替えるわけでは
                // ないため、`set_text_content` をそのまま流用してはいけない
                // （テキストノード自身は子を持たないため結果的に同じ関数で正しく効くが、
                // 要素ノードでは意図的に何もしない点が異なる）。
                "nodeValue" => {
                    let has_val = self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false);
                    if has_val {
                        self.dom.borrow_mut().set_text_content(idx, &s_nullable);
                    }
                }
                // `object.data`（読み出し側と対になる書き込み。
                // `CharacterData.data`と衝突するためタグ限定で先に判定する。
                // 2026-07-17 発見・実装）。
                "data" if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "object").unwrap_or(false) => {
                    self.dom.borrow_mut().set_attr(idx, "data", &s);
                }
                // `CharacterData.data`（`nodeValue`と対になる書き込み側。
                // 2026-07-16 発見・実装）。
                "data" => {
                    let has_data = self.dom.borrow().nodes.get(idx).map(|n| n.is_text || n.tag == "#comment").unwrap_or(false);
                    if has_data {
                        self.dom.borrow_mut().set_text_content(idx, &s_nullable);
                    }
                }
                "innerHTML" => {
                    let is_template = self.dom.borrow().nodes.get(idx).map(|n| n.tag == "template").unwrap_or(false);
                    if is_template {
                        let frag_val = self.dom_element_get(idx, "content");
                        if let Some(fi) = this_dom_idx(&frag_val) {
                            self.dom.borrow_mut().set_inner_html(fi, &s_nullable);
                        } else {
                            self.dom.borrow_mut().set_inner_html(idx, &s_nullable);
                        }
                    } else {
                        self.dom.borrow_mut().set_inner_html(idx, &s_nullable);
                    }
                }
                "outerHTML" => self.dom.borrow_mut().set_outer_html(idx, &s_nullable),
                "id" => self.dom.borrow_mut().set_attr(idx, "id", &s),
                "className" => self.dom.borrow_mut().set_attr(idx, "class", &s),
                "value" => {
                    let tag = self.dom.borrow().nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
                    if tag == "select" {
                        self.dom.borrow_mut().set_select_value(idx, &s);
                    } else if tag == "input" || tag == "textarea" {
                        let sanitized = if tag == "input"
                            && self.dom.borrow().get_attr(idx, "type").as_deref() == Some("color")
                        {
                            let is_valid_hex = s.len() == 7
                                && s.starts_with('#')
                                && s.chars().skip(1).all(|c| c.is_ascii_hexdigit());
                            if is_valid_hex {
                                s.to_lowercase()
                            } else {
                                String::from("#000000")
                            }
                        } else {
                            s
                        };
                        self.dom.borrow_mut().set_attr(idx, "_live_value", &sanitized);
                    } else {
                        self.dom.borrow_mut().set_attr(idx, "value", &s);
                    }
                }
                "valueAsNumber" => {
                    let n = val.to_number();
                    let mut dom = self.dom.borrow_mut();
                    if n.is_nan() {
                        dom.set_attr(idx, "_live_value", "");
                        dom.set_attr(idx, "value", "");
                    } else {
                        let str_v = Value::Number(n).to_js_string();
                        dom.set_attr(idx, "_live_value", &str_v);
                        dom.set_attr(idx, "value", &str_v);
                    }
                }
                "valueAsDate" => {
                    let ty = self.dom.borrow().get_attr(idx, "type").unwrap_or_default();
                    let mut dom = self.dom.borrow_mut();
                    if matches!(val, Value::Null | Value::Undefined) {
                        dom.set_attr(idx, "_live_value", "");
                        dom.set_attr(idx, "value", "");
                    } else {
                        let ms = super::super::builtins::date_value_ms(&val);
                        if let Some(s) = super::super::builtins::input_date_ms_to_value(&ty, ms) {
                            dom.set_attr(idx, "_live_value", &s);
                            dom.set_attr(idx, "value", &s);
                        } else {
                            dom.set_attr(idx, "_live_value", "");
                            dom.set_attr(idx, "value", "");
                        }
                    }
                }
                "selectedIndex" => {
                    let n = val.to_number() as i32;
                    self.dom.borrow_mut().set_select_selected_index(idx, n);
                }
                // `select.length = n`（`select.options.length`と対になる書き込み側。
                // 仕様どおり負数・NaNは`0`扱い。丸ごと未対応だった）。`<select>`
                // 以外への誤代入で無関係な`<option>`子孫が操作されないよう
                // タグ判定でガードする。
                "length"
                    if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false) =>
                {
                    let n = val.to_number();
                    let n = if n.is_finite() && n > 0.0 { n as usize } else { 0 };
                    self.dom.borrow_mut().set_select_length(idx, n);
                }
                // `selectionStart`/`selectionEnd`/`selectionDirection`
                // （読み出し側と対になる書き込み。内部専用属性へそのまま
                // 保存するだけの状態追跡のみの簡略実装）。
                "selectionStart" => self.dom.borrow_mut().set_attr(idx, "_selection_start", &s),
                "selectionEnd" => self.dom.borrow_mut().set_attr(idx, "_selection_end", &s),
                "selectionDirection" => self.dom.borrow_mut().set_attr(idx, "_selection_direction", &s),
                "type" => self.dom.borrow_mut().set_attr(idx, "type", &s),
                // `input`/`textarea.defaultValue`/`input.defaultChecked`/`option.defaultSelected`
                // （読み出し側と対になる書き込み。2026-07-17 発見・実装）。
                "defaultValue" => self.dom.borrow_mut().set_attr(idx, "value", &s),
                "defaultChecked" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "checked", "checked");
                    } else {
                        dom.remove_attr(idx, "checked");
                    }
                }
                "defaultSelected" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "selected", "selected");
                    } else {
                        dom.remove_attr(idx, "selected");
                    }
                }
                // `checkbox.checked = true` に加え、`radio.checked = true` も
                // `element.click()` と同じくラジオボタングループの排他選択
                // （同じ `name` を持つ他の radio の `checked` を外す）を効かせる。
                "checked" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "_live_checked", "true");
                        dom.uncheck_radio_group_siblings(idx);
                    } else {
                        dom.set_attr(idx, "_live_checked", "false");
                    }
                }
                // `dialog.open = true/false`（`show()`/`close()` と同じ効果の直接プロパティ
                // 代入）。
                "open" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "open", "open");
                    } else {
                        dom.remove_attr(idx, "open");
                    }
                }
                // `element.inert = true/false`（属性の付け外し）。
                "inert" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "inert", "");
                    } else {
                        dom.remove_attr(idx, "inert");
                    }
                }
                // `dialog.returnValue = 'x'`（`close()` を介さない直接代入）。
                "returnValue" => {
                    self.dom
                        .borrow_mut()
                        .set_attr(idx, "_return_value", &val.to_js_string());
                }
                "indeterminate" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "_indeterminate", "true");
                    } else {
                        dom.remove_attr(idx, "_indeterminate");
                    }
                }
                "disabled" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "disabled", "disabled");
                    } else {
                        dom.remove_attr(idx, "disabled");
                    }
                }
                "selected" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "selected", "selected");
                    } else {
                        dom.remove_attr(idx, "selected");
                    }
                }

                "placeholder" => self.dom.borrow_mut().set_attr(idx, "placeholder", &s),
                // `input.pattern`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "pattern" => self.dom.borrow_mut().set_attr(idx, "pattern", &s),
                // `input.capture`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "capture" => self.dom.borrow_mut().set_attr(idx, "capture", &s),
                // `input.accept`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "accept" => self.dom.borrow_mut().set_attr(idx, "accept", &s),
                "name" => self.dom.borrow_mut().set_attr(idx, "name", &s),
                "required" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "required", "required");
                    } else {
                        dom.remove_attr(idx, "required");
                    }
                }
                "noValidate" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "novalidate", "novalidate");
                    } else {
                        dom.remove_attr(idx, "novalidate");
                    }
                }
                "formNoValidate" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "formnovalidate", "formnovalidate");
                    } else {
                        dom.remove_attr(idx, "formnovalidate");
                    }
                }
                // `ol.reversed`/`.start`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "reversed" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "reversed", "reversed");
                    } else {
                        dom.remove_attr(idx, "reversed");
                    }
                }
                "start" => self.dom.borrow_mut().set_attr(idx, "start", &s),
                "readOnly" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "readonly", "readonly");
                    } else {
                        dom.remove_attr(idx, "readonly");
                    }
                }
                // `element.hidden = true/false`（要素の表示/非表示を切り替える定番
                // イディオム。`classList.toggle` と並んでよく使われる）が丸ごと未対応
                // だった。getter（`hidden` 属性の有無を返す）は既に対応済みだったが、
                // 対をなす setter が漏れていた。
                "hidden" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "hidden", "hidden");
                    } else {
                        dom.remove_attr(idx, "hidden");
                    }
                }
                "multiple" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "multiple", "multiple");
                    } else {
                        dom.remove_attr(idx, "multiple");
                    }
                }
                "src" => {
                    let s_val = s.clone();
                    self.dom.borrow_mut().set_attr(idx, "src", &s);
                    let is_media = self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "video" || n.tag == "audio")
                        .unwrap_or(false);
                    if is_media && s_val.starts_with("blob:") {
                        let ms_val = match self.global.borrow().vars.get("__media_source_urls") {
                            Some(Value::Object(r)) => r.borrow().props.get(&s_val).cloned(),
                            _ => None,
                        };
                        if let Some(ms) = ms_val {
                            super::super::builtins::media_source_open_internal(self, &ms);
                        }
                    }
                }
                "srcObject" => {
                    let is_media = self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "video" || n.tag == "audio")
                        .unwrap_or(false);
                    if is_media {
                        let is_ms = if let Value::Object(o) = &val {
                            let b = o.borrow();
                            b.props.contains_key("sourceBuffers")
                                || b.props.get("_is_media_source").map(|v| v.truthy()).unwrap_or(false)
                        } else {
                            false
                        };
                        if is_ms {
                            super::super::builtins::media_source_open_internal(self, &val);
                        }
                    }
                }
                "alt" => self.dom.borrow_mut().set_attr(idx, "alt", &s),
                "autoplay" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "autoplay", "autoplay");
                    } else {
                        dom.remove_attr(idx, "autoplay");
                    }
                }
                "controls" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "controls", "controls");
                    } else {
                        dom.remove_attr(idx, "controls");
                    }
                }
                "loop" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "loop", "loop");
                    } else {
                        dom.remove_attr(idx, "loop");
                    }
                }
                "muted" => {
                    let is_muted = val.truthy();
                    {
                        let mut dom = self.dom.borrow_mut();
                        if is_muted {
                            dom.set_attr(idx, "muted", "muted");
                        } else {
                            dom.remove_attr(idx, "muted");
                        }
                    }
                    // 【2026-10-19】再生状態（全体で 1 つ）を変えるのは、再生中（またはこれから再生する）
                    // 要素だけ。YouTube は消音の設定の前に別の試験用 <video> の muted を反転させて
                    // 設定できるかを調べる（`Dd()`）ため、それで本物の再生まで消音されていた。
                    let src = self.dom.borrow().get_attr(idx, "src").unwrap_or_default();
                    let mut pb = crate::os_lib::mse::PLAYBACK.lock();
                    if !src.is_empty() && (pb.url.is_empty() || pb.url == src) {
                        pb.muted = is_muted;
                        drop(pb);
                        if is_muted {
                            crate::kernel::audio::Audio::mute();
                        }
                    }
                    // `.volume` と同じく仕様どおり `volumechange` を発火する。
                    let _ = self.dispatch_event_in_interp(idx, "volumechange", &[]);
                }
                "playsInline" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "playsinline", "playsinline");
                    } else {
                        dom.remove_attr(idx, "playsinline");
                    }
                }
                // `video.disablePictureInPicture`/`iframe.allowFullscreen`
                // （読み出し側と対になる書き込み。2026-07-17 発見・実装）。
                "disablePictureInPicture" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "disablepictureinpicture", "disablepictureinpicture");
                    } else {
                        dom.remove_attr(idx, "disablepictureinpicture");
                    }
                }
                // `video.disableRemotePlayback`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "disableRemotePlayback" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "disableremoteplayback", "disableremoteplayback");
                    } else {
                        dom.remove_attr(idx, "disableremoteplayback");
                    }
                }
                "allowFullscreen" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "allowfullscreen", "allowfullscreen");
                    } else {
                        dom.remove_attr(idx, "allowfullscreen");
                    }
                }
                // `iframe.credentialless`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "credentialless" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "credentialless", "credentialless");
                    } else {
                        dom.remove_attr(idx, "credentialless");
                    }
                }
                // `canvas`/`img`/`video.width`/`.height`（読み出し側と対になる
                // 書き込み。2026-07-17 発見・実装）。
                "width"
                    if self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "canvas" || n.tag == "img" || n.tag == "video")
                        .unwrap_or(false) =>
                {
                    self.dom.borrow_mut().set_attr(idx, "width", &s);
                }
                "height"
                    if self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "canvas" || n.tag == "img" || n.tag == "video")
                        .unwrap_or(false) =>
                {
                    self.dom.borrow_mut().set_attr(idx, "height", &s);
                }
                // `embed`/`object`/`iframe.width`/`.height`（読み出し側と対に
                // なる書き込み。単純な文字列反映。2026-07-17 発見・実装）。
                "width"
                    if self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "embed" || n.tag == "object" || n.tag == "iframe")
                        .unwrap_or(false) =>
                {
                    self.dom.borrow_mut().set_attr(idx, "width", &s);
                }
                "height"
                    if self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "embed" || n.tag == "object" || n.tag == "iframe")
                        .unwrap_or(false) =>
                {
                    self.dom.borrow_mut().set_attr(idx, "height", &s);
                }
                // `.currentTime`/`.volume`/`.playbackRate` の直接代入（`.play()`/
                // `.pause()`と同じ内部専用属性への状態保存のみの簡略実装）。
                // `.volume` の範囲外値（0〜1 外）は仕様上 `IndexSizeError` だが、
                // 他の簡略実装同様エラーは投げず `clamp` する。
                // 仕様どおり `.currentTime`/`.volume`/`.playbackRate` の直接代入は
                // それぞれ `seeked`/`volumechange`/`ratechange` イベントを発火する
                // （`.play()`/`.pause()`の `play`/`pause` イベント発火と対）。
                "currentTime" => {
                    let t = val.to_number();
                    self.dom.borrow_mut().set_attr(idx, "_current_time", &t.to_string());
                    // 実際にシークする（再生スレッドが取り出す。再生開始前の代入は開始時に効く）。
                    let has_src = self.dom.borrow().get_attr(idx, "src").is_some_and(|s| !s.is_empty());
                    if t.is_finite() && has_src {
                        *crate::os_lib::mse::SEEK_REQUEST.lock() = Some(t.max(0.0));
                        crate::os_lib::mse::PLAYBACK.lock().current_time = t.max(0.0);
                    }
                    let _ = self.dispatch_event_in_interp(idx, "seeking", &[]);
                    let _ = self.dispatch_event_in_interp(idx, "seeked", &[]);
                }
                "volume" => {
                    let v = val.to_number().clamp(0.0, 1.0);
                    self.dom.borrow_mut().set_attr(idx, "_volume", &v.to_string());
                    let _ = crate::os_lib::mse::PLAYBACK.lock().set_volume(v);
                    if v <= 0.0 {
                        crate::kernel::audio::Audio::mute();
                    }
                    let _ = self.dispatch_event_in_interp(idx, "volumechange", &[]);
                }
                "playbackRate" => {
                    let r = val.to_number();
                    self.dom.borrow_mut().set_attr(idx, "_playback_rate", &r.to_string());
                    let _ = crate::os_lib::mse::PLAYBACK.lock().set_playback_rate(r);
                    let _ = self.dispatch_event_in_interp(idx, "ratechange", &[]);
                }
                "defaultPlaybackRate" => self
                    .dom
                    .borrow_mut()
                    .set_attr(idx, "_default_playback_rate", &val.to_number().to_string()),
                "nonce" => self.dom.borrow_mut().set_attr(idx, "nonce", &s),
                // `element.role`/`.ariaLabel`等（読み出し側と対になる書き込み。
                // `null`代入は仕様上属性除去を意味するため`remove_attr`する。
                // 2026-07-18 発見・実装）。
                "role" => {
                    if matches!(val, Value::Null) {
                        self.dom.borrow_mut().remove_attr(idx, "role");
                    } else {
                        self.dom.borrow_mut().set_attr(idx, "role", &s);
                    }
                }
                // `ariaActiveDescendantElement`（読み出し側と対になる書き込み。
                // `popoverTargetElement`と同じidref解決パターン。汎用の
                // `aria-*`文字列反映アームより前に置く必要がある
                // （`starts_with("aria")`の汎用ガードに先に吸われてしまう
                // ため）。2026-07-18 発見・実装）。
                // `aria*Elements`（読み出し側と対になる書き込み。配列/
                // iterable な要素参照の並びをidref文字列へ空白区切りで
                // 直列化する。`null`/`undefined`代入は属性除去。要素が
                // `id`を持たない場合はそのエントリのみ無視する。
                // `ariaActiveDescendantElement`と同じ理由で汎用の
                // `aria-*`文字列反映アームより前に置く必要がある。
                // 2026-07-18 発見・実装）。
                _ if key.starts_with("aria") && key.ends_with("Elements") && key.len() > 12 => {
                    let suffix: String =
                        key.chars().skip(4).take(key.len() - 4 - 8).collect::<String>().to_lowercase();
                    let attr = alloc::format!("aria-{}", suffix);
                    if matches!(val, Value::Null | Value::Undefined) {
                        self.dom.borrow_mut().remove_attr(idx, &attr);
                    } else {
                        let items = self.iterate_values(&val, true);
                        let ids: Vec<String> = items
                            .iter()
                            .filter_map(|v| match v {
                                Value::Object(o) => match &o.borrow().kind {
                                    ObjKind::DomElement(ti) => {
                                        self.dom.borrow().nodes.get(*ti).map(|n| n.id.clone())
                                    }
                                    _ => None,
                                },
                                _ => None,
                            })
                            .filter(|s| !s.is_empty())
                            .collect();
                        self.dom.borrow_mut().set_attr(idx, &attr, &ids.join(" "));
                    }
                }
                "ariaActiveDescendantElement" => match val {
                    Value::Null => {
                        self.dom.borrow_mut().remove_attr(idx, "aria-activedescendant");
                    }
                    Value::Object(o) if matches!(&o.borrow().kind, ObjKind::DomElement(_)) => {
                        if let ObjKind::DomElement(ti) = &o.borrow().kind {
                            let target_id = self.dom.borrow().nodes.get(*ti).map(|n| n.id.clone());
                            if let Some(tid) = target_id.filter(|s| !s.is_empty()) {
                                self.dom.borrow_mut().set_attr(idx, "aria-activedescendant", &tid);
                            }
                        }
                    }
                    _ => {}
                },
                _ if key.starts_with("aria") && key.as_bytes().get(4).is_some_and(u8::is_ascii_uppercase) => {
                    let suffix: String = key.chars().skip(4).collect::<String>().to_lowercase();
                    let attr = alloc::format!("aria-{}", suffix);
                    if matches!(val, Value::Null) {
                        self.dom.borrow_mut().remove_attr(idx, &attr);
                    } else {
                        self.dom.borrow_mut().set_attr(idx, &attr, &s);
                    }
                }
                "preload" => self.dom.borrow_mut().set_attr(idx, "preload", &s),
                // `textarea.wrap`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "wrap" => self.dom.borrow_mut().set_attr(idx, "wrap", &s),
                "poster" => self.dom.borrow_mut().set_attr(idx, "poster", &s),
                // `track.kind`（読み出し側と対になる書き込み。2026-07-17 発見・実装）。
                "kind" => self.dom.borrow_mut().set_attr(idx, "kind", &s),
                // `option`/`optgroup`/`track.label`（読み出し側は個別に
                // タグ限定ゲッターがあるが、書き込み側の`label`セッター
                // 自体がどのタグに対しても丸ごと存在しなかった。単純な
                // 属性反映のため3タグ共通の1本にまとめる。`track.srclang`/
                // `.default`とあわせて2026-07-18 発見・実装）。
                "label" => self.dom.borrow_mut().set_attr(idx, "label", &s),
                "srclang" => self.dom.borrow_mut().set_attr(idx, "srclang", &s),
                "default" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "default", "default");
                    } else {
                        dom.remove_attr(idx, "default");
                    }
                }
                "ping" => self.dom.borrow_mut().set_attr(idx, "ping", &s),
                "hreflang" => self.dom.borrow_mut().set_attr(idx, "hreflang", &s),
                "srcset" => self.dom.borrow_mut().set_attr(idx, "srcset", &s),
                "sizes" => self.dom.borrow_mut().set_attr(idx, "sizes", &s),
                "media" => self.dom.borrow_mut().set_attr(idx, "media", &s),
                "useMap" => self.dom.borrow_mut().set_attr(idx, "usemap", &s),
                "isMap" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "ismap", "ismap");
                    } else {
                        dom.remove_attr(idx, "ismap");
                    }
                }
                "referrerPolicy" => self.dom.borrow_mut().set_attr(idx, "referrerpolicy", &s),
                // `link.as`（読み出し側と対になる書き込み。2026-07-18 発見・実装）。
                "as" => self.dom.borrow_mut().set_attr(idx, "as", &s),
                // `link.imageSrcset`/`.imageSizes`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "imageSrcset" => self.dom.borrow_mut().set_attr(idx, "imagesrcset", &s),
                "imageSizes" => self.dom.borrow_mut().set_attr(idx, "imagesizes", &s),
                "loading" => self.dom.borrow_mut().set_attr(idx, "loading", &s),
                "decoding" => self.dom.borrow_mut().set_attr(idx, "decoding", &s),
                "allow" => self.dom.borrow_mut().set_attr(idx, "allow", &s),
                // `iframe.srcdoc`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "srcdoc" => self.dom.borrow_mut().set_attr(idx, "srcdoc", &s),
                // `crossOrigin = null` は属性除去（仕様どおり）、それ以外は文字列化して設定。
                "crossOrigin" => {
                    if matches!(val, Value::Null) {
                        self.dom.borrow_mut().remove_attr(idx, "crossorigin");
                    } else {
                        self.dom.borrow_mut().set_attr(idx, "crossorigin", &s);
                    }
                }
                "fetchPriority" => self.dom.borrow_mut().set_attr(idx, "fetchpriority", &s),
                "integrity" => self.dom.borrow_mut().set_attr(idx, "integrity", &s),
                "async" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "async", "async");
                    } else {
                        dom.remove_attr(idx, "async");
                    }
                }
                "defer" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "defer", "defer");
                    } else {
                        dom.remove_attr(idx, "defer");
                    }
                }
                "noModule" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "nomodule", "nomodule");
                    } else {
                        dom.remove_attr(idx, "nomodule");
                    }
                }
                "href" => self.dom.borrow_mut().set_attr(idx, "href", &s),
                // `a`/`area.protocol`/`.host`/`.hostname`/`.port`/`.pathname`/
                // `.search`/`.hash`（`URLUtils`ミックスインの書き込み側。
                // ゲッターは既に`location_components`経由で実装済み
                // だったが、対になるセッターが丸ごと未対応だった。
                // `location.protocol`等の再構築ロジックと同じ「現在の
                // href を分解 → 対象コンポーネントだけ差し替え → 再結合
                // して href へ書き戻す」パターンを適用する。2026-07-18
                // 発見・実装）。
                "protocol" | "host" | "hostname" | "port" | "pathname" | "search" | "hash"
                | "username" | "password"
                    if self
                        .dom
                        .borrow()
                        .nodes
                        .get(idx)
                        .map(|n| n.tag == "a" || n.tag == "area")
                        .unwrap_or(false) =>
                {
                    let raw = self.dom.borrow().get_attr(idx, "href").unwrap_or_default();
                    let abs = self.resolve_url_against_page(&raw);
                    let comps = super::super::builtins::location_components(&abs);
                    let get = |k: &str| {
                        comps.iter().find(|(kk, _)| *kk == k).map(|(_, v)| v.clone()).unwrap_or_default()
                    };
                    let mut protocol = get("protocol");
                    let mut hostname = get("hostname");
                    let mut port = get("port");
                    let mut pathname = get("pathname");
                    let mut search = get("search");
                    let mut hash = get("hash");
                    let mut username = get("username");
                    let mut password = get("password");
                    match key {
                        "protocol" => protocol = if s.ends_with(':') { s.clone() } else { alloc::format!("{}:", s) },
                        "hostname" => hostname = s.clone(),
                        "port" => port = s.clone(),
                        "host" => match s.split_once(':') {
                            Some((h, p)) => {
                                hostname = String::from(h);
                                port = String::from(p);
                            }
                            None => {
                                hostname = s.clone();
                                port = String::new();
                            }
                        },
                        "pathname" => pathname = if s.starts_with('/') { s.clone() } else { alloc::format!("/{}", s) },
                        "search" => {
                            search = if s.is_empty() || s.starts_with('?') { s.clone() } else { alloc::format!("?{}", s) }
                        }
                        "hash" => {
                            hash = if s.is_empty() || s.starts_with('#') { s.clone() } else { alloc::format!("#{}", s) }
                        }
                        "username" => username = s.clone(),
                        "password" => password = s.clone(),
                        _ => {}
                    }
                    let hostport =
                        if port.is_empty() { hostname.clone() } else { alloc::format!("{}:{}", hostname, port) };
                    let userinfo = if username.is_empty() && password.is_empty() {
                        String::new()
                    } else {
                        alloc::format!("{}:{}@", username, password)
                    };
                    let new_href =
                        alloc::format!("{}//{}{}{}{}{}", protocol, userinfo, hostport, pathname, search, hash);
                    self.dom.borrow_mut().set_attr(idx, "href", &new_href);
                }
                "htmlFor" => self.dom.borrow_mut().set_attr(idx, "for", &s),
                // `form.acceptCharset`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "acceptCharset" => self.dom.borrow_mut().set_attr(idx, "accept-charset", &s),
                // `meta.httpEquiv`/`.content`/`.charset`（読み出し側と対になる
                // 書き込み。2026-07-17 発見・実装）。
                "httpEquiv" => self.dom.borrow_mut().set_attr(idx, "http-equiv", &s),
                "content" => self.dom.borrow_mut().set_attr(idx, "content", &s),
                "charset" => self.dom.borrow_mut().set_attr(idx, "charset", &s),
                // `blockquote`/`q`/`ins`/`del.cite`と`ins`/`del`/`time.dateTime`
                // （読み出し側と対になる書き込み。2026-07-17 発見・実装）。
                "cite" => self.dom.borrow_mut().set_attr(idx, "cite", &s),
                "dateTime" => self.dom.borrow_mut().set_attr(idx, "datetime", &s),
                "action" => self.dom.borrow_mut().set_attr(idx, "action", &s),
                "method" => self.dom.borrow_mut().set_attr(idx, "method", &s),
                // `form.enctype`/`.encoding`（読み出し側と対になる書き込み。
                // 両方とも同じ`enctype`属性を指す。2026-07-17 発見・実装）。
                "enctype" | "encoding" => self.dom.borrow_mut().set_attr(idx, "enctype", &s),
                // `formAction`/`formEnctype`/`formMethod`/`formTarget`（読み出し側と
                // 対になる書き込み。自身の`form*`属性に反映する。2026-07-17 発見・実装）。
                "formAction" => self.dom.borrow_mut().set_attr(idx, "formaction", &s),
                "formEnctype" => self.dom.borrow_mut().set_attr(idx, "formenctype", &s),
                "formMethod" => self.dom.borrow_mut().set_attr(idx, "formmethod", &s),
                "formTarget" => self.dom.borrow_mut().set_attr(idx, "formtarget", &s),
                "min" => self.dom.borrow_mut().set_attr(idx, "min", &s),
                "max" => self.dom.borrow_mut().set_attr(idx, "max", &s),
                // `meter.low`/`.high`/`.optimum`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "low" => self.dom.borrow_mut().set_attr(idx, "low", &s),
                "high" => self.dom.borrow_mut().set_attr(idx, "high", &s),
                "optimum" => self.dom.borrow_mut().set_attr(idx, "optimum", &s),
                // `td`/`th.colSpan`/`.rowSpan`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "colSpan" => self.dom.borrow_mut().set_attr(idx, "colspan", &s),
                "rowSpan" => self.dom.borrow_mut().set_attr(idx, "rowspan", &s),
                // `td`/`th.headers`/`th.scope`/`.abbr`（読み出し側と対になる
                // 書き込み。2026-07-17 発見・実装）。
                "headers" => self.dom.borrow_mut().set_attr(idx, "headers", &s),
                "scope" => self.dom.borrow_mut().set_attr(idx, "scope", &s),
                "abbr" => self.dom.borrow_mut().set_attr(idx, "abbr", &s),
                // `col`/`colgroup.span`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "span" => self.dom.borrow_mut().set_attr(idx, "span", &s),
                "step" => self.dom.borrow_mut().set_attr(idx, "step", &s),
                "maxLength" => self.dom.borrow_mut().set_attr(idx, "maxlength", &s),
                // `minLength`（`maxLength`と対になる書き込み側。ゲッターと同じく
                // 丸ごと未対応だった）。
                "minLength" => self.dom.borrow_mut().set_attr(idx, "minlength", &s),
                "target" => self.dom.borrow_mut().set_attr(idx, "target", &s),
                "rel" => self.dom.borrow_mut().set_attr(idx, "rel", &s),
                "download" => self.dom.borrow_mut().set_attr(idx, "download", &s),
                // `area.coords`/`.shape`（読み出し側と対になる書き込み。
                // 2026-07-17 発見・実装）。
                "coords" => self.dom.borrow_mut().set_attr(idx, "coords", &s),
                "shape" => self.dom.borrow_mut().set_attr(idx, "shape", &s),
                "lang" => self.dom.borrow_mut().set_attr(idx, "lang", &s),
                "dir" => self.dom.borrow_mut().set_attr(idx, "dir", &s),
                // `element.title`/`.accessKey`（読み出し側と対になる書き込み。
                // 2026-07-16 発見・実装）。
                "title" => self.dom.borrow_mut().set_attr(idx, "title", &s),
                "accessKey" => self.dom.borrow_mut().set_attr(idx, "accesskey", &s),
                // `element.translate = true/false`（`"yes"`/`"no"` へ反映する
                // 仕様どおりのブール属性）。
                "translate" => {
                    let v = if val.truthy() { "yes" } else { "no" };
                    self.dom.borrow_mut().set_attr(idx, "translate", v);
                }
                // `element.draggable = true/false`（`"true"`/`"false"` へ反映
                // する簡略ブール属性。読み出し側と対）。
                "draggable" => {
                    let v = if val.truthy() { "true" } else { "false" };
                    self.dom.borrow_mut().set_attr(idx, "draggable", v);
                }
                // `element.slot`（読み出し側と対になる書き込み）。
                "slot" => self.dom.borrow_mut().set_attr(idx, "slot", &s),
                // `element.contentEditable = "true"/"false"/"plaintext-only"`（無効値は
                // 仕様上 `SyntaxError` だが、この setter は `Result` を返さない既存の
                // 属性直結プロパティ群と同じ形のため、他の簡略実装同様エラーは投げず
                // 無効値は無視する）。
                "contentEditable" => {
                    if matches!(s.as_str(), "true" | "false" | "plaintext-only") {
                        self.dom.borrow_mut().set_attr(idx, "contenteditable", &s);
                    }
                }

                "tabIndex" => {
                    let n = val.to_number() as i64;
                    self.dom.borrow_mut().set_attr(idx, "tabindex", &n.to_string());
                }
                // `element.spellcheck = true/false`（`contentEditable` と同じ
                // 属性直結の簡略実装）。
                "spellcheck" => {
                    let b = val.truthy();
                    self.dom.borrow_mut().set_attr(idx, "spellcheck", if b { "true" } else { "false" });
                }
                "inputMode" => self.dom.borrow_mut().set_attr(idx, "inputmode", &s),
                // `select`/`input.size`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "size" => self.dom.borrow_mut().set_attr(idx, "size", &s),
                // `textarea.rows`/`.cols`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "rows" => self.dom.borrow_mut().set_attr(idx, "rows", &s),
                "cols" => self.dom.borrow_mut().set_attr(idx, "cols", &s),
                // `autocomplete`/`autofocus`（読み出し側と対になる書き込み。
                // 2026-07-18 発見・実装）。
                "autocomplete" => self.dom.borrow_mut().set_attr(idx, "autocomplete", &s),
                "autofocus" => {
                    let mut dom = self.dom.borrow_mut();
                    if val.truthy() {
                        dom.set_attr(idx, "autofocus", "autofocus");
                    } else {
                        dom.remove_attr(idx, "autofocus");
                    }
                }
                "enterKeyHint" => self.dom.borrow_mut().set_attr(idx, "enterkeyhint", &s),
                "autocapitalize" => self.dom.borrow_mut().set_attr(idx, "autocapitalize", &s),
                // `element.popover = null` は属性除去（仕様どおり）、それ以外は文字列化して設定。
                "popover" => {
                    if matches!(val, Value::Null) {
                        self.dom.borrow_mut().remove_attr(idx, "popover");
                    } else {
                        self.dom.borrow_mut().set_attr(idx, "popover", &s);
                    }
                }
                "popoverTargetAction" => {
                    self.dom.borrow_mut().set_attr(idx, "popovertargetaction", &s)
                }
                // `button.popoverTargetElement = el`（`null` で除去）。この処理系は
                // `popovertarget` を idref 文字列としてしか保持できないため、対象
                // 要素が `id` を持つ場合のみ `popovertarget` へその id を反映する
                // 簡略実装（`id` の無い要素を渡すケースは対象外）。
                "popoverTargetElement" => match val {
                    Value::Null => {
                        self.dom.borrow_mut().remove_attr(idx, "popovertarget");
                    }
                    Value::Object(o) if matches!(&o.borrow().kind, ObjKind::DomElement(_)) => {
                        if let ObjKind::DomElement(ti) = &o.borrow().kind {
                            let target_id = self.dom.borrow().nodes.get(*ti).map(|n| n.id.clone());
                            if let Some(tid) = target_id.filter(|s| !s.is_empty()) {
                                self.dom.borrow_mut().set_attr(idx, "popovertarget", &tid);
                            }
                        }
                    }
                    _ => {}
                },
                // `button.command`/`.commandForElement`（Invoker Commands API。
                // `popoverTargetAction`/`.popoverTargetElement`と全く同じ
                // 反映・idref解決パターン。2026-07-18 発見・実装）。
                "command" => self.dom.borrow_mut().set_attr(idx, "command", &s),
                "commandForElement" => match val {
                    Value::Null => {
                        self.dom.borrow_mut().remove_attr(idx, "commandfor");
                    }
                    Value::Object(o) if matches!(&o.borrow().kind, ObjKind::DomElement(_)) => {
                        if let ObjKind::DomElement(ti) = &o.borrow().kind {
                            let target_id = self.dom.borrow().nodes.get(*ti).map(|n| n.id.clone());
                            if let Some(tid) = target_id.filter(|s| !s.is_empty()) {
                                self.dom.borrow_mut().set_attr(idx, "commandfor", &tid);
                            }
                        }
                    }
                    _ => {}
                },
                // `table.tHead`/`.tFoot`/`.caption`（読み出し側は既に実装
                // 済みだったが、対になる書き込み側が丸ごと未対応だった。
                // 仕様上、代入すると既存の同名セクションを除去し、新しい
                // 要素（`null`なら除去のみ）を仕様上の正しい位置
                // （`thead`/`caption`は先頭子、`tfoot`は末尾）へ挿入する。
                // `insert_before`は内部で対象ノードを自動的に元の親から
                // detachするため、既にDOM内にある要素を渡しても正しく
                // 再配置される。2026-07-18 発見・実装）。
                "tHead" | "tFoot" | "caption"
                    if self.dom.borrow().nodes.get(idx).map(|n| n.tag == "table").unwrap_or(false) =>
                {
                    let want = match key {
                        "tHead" => "thead",
                        "tFoot" => "tfoot",
                        _ => "caption",
                    };
                    let existing = {
                        let dom = self.dom.borrow();
                        dom.nodes[idx].children.iter().find(|&&c| dom.nodes[c].tag == want).copied()
                    };
                    if let Some(old) = existing {
                        self.dom.borrow_mut().remove_node(old);
                    }
                    if let Value::Object(o) = &val {
                        if let ObjKind::DomElement(new_idx) = &o.borrow().kind {
                            let new_idx = *new_idx;
                            let ref_child = if want == "tfoot" {
                                None
                            } else {
                                self.dom.borrow().nodes[idx].children.first().copied()
                            };
                            self.dom.borrow_mut().insert_before(idx, new_idx, ref_child);
                        }
                    }
                }
                "scrollTop" => {
                    // JS が el.scrollTop を書き込んだ → scroll_tops に反映して再描画を要求。
                    let n = val.to_number() as i32;
                    let mut dom = self.dom.borrow_mut();
                    dom.scroll_tops.insert(idx, n.max(0));
                    dom.dirty = true;
                }
                "scrollLeft" => {
                    // JS が el.scrollLeft を書き込んだ → scroll_lefts に反映して再描画を要求。
                    let n = val.to_number() as i32;
                    let mut dom = self.dom.borrow_mut();
                    dom.scroll_lefts.insert(idx, n.max(0));
                    dom.dirty = true;
                }
                // ARIA 反映 IDL 属性の setter。`null`/`undefined` 代入は仕様どおり
                // 属性そのものを取り除く（`""` を設定するのとは異なる）。
                key if aria_attr_name(key).is_some() => {
                    let attr = aria_attr_name(key).unwrap_or_default();
                    let mut dom = self.dom.borrow_mut();
                    if matches!(val, Value::Null | Value::Undefined) {
                        dom.remove_attr(idx, attr);
                    } else {
                        dom.set_attr(idx, attr, &s);
                    }
                }
                // 【2026-07-23 発見・修正】以前は`Obj::dom(idx)`（呼び出す度に使い捨てで
                // 新規生成される、どこにも永続化されないラッパーオブジェクト）自身の
                // `.props`へ書き込んでいたため、代入直後にそのRcが解放されると値ごと
                // 消え、`dispatchEvent`（`Obj::dom(idx)`を新たに生成して読む）側からは
                // 常に見つからず、`element.onchange = fn`のような関数値代入が一切発火
                // しない静かなバグだった。`listeners`（addEventListener系）と同じく
                // DOM構造体側の永続ストレージ`on_handlers`へ書く。
                // `canvas.width` / `canvas.height` への代入。
                //
                // 以前は下の `_ => {}` に落ちて**完全に捨てられていた**ため、
                // 大きさを変えても面はそのままだった。仕様では、
                // 同じ値を入れ直しても内容と描画状態が初期化される
                // （`canvas.width = canvas.width` という消去の定型句が
                // これに依存している）。
                "width" | "height" if self.dom.borrow().nodes.get(idx)
                    .map(|n| n.tag == "canvas").unwrap_or(false) =>
                {
                    self.dom.borrow_mut().set_attr(idx, key, &s);
                    let id = self
                        .dom
                        .borrow()
                        .get_attr(idx, "_c2d_id")
                        .and_then(|v| v.parse::<u32>().ok());
                    if let Some(id) = id {
                        let get = |k: &str, d: u32| {
                            self.dom
                                .borrow()
                                .get_attr(idx, k)
                                .and_then(|v| v.trim().parse::<u32>().ok())
                                .unwrap_or(d)
                        };
                        let (w, h) = (get("width", 300), get("height", 150));
                        crate::os_lib::canvas2d::resize_context(id, w, h);
                    }
                }
                // `node.__proto__ = X.prototype`: 原型は要素側に持たせる（ハンドルは作り直すため）。
                // 【2026-10-20】ShadyDOM は DocumentFragment を `__proto__ = ShadowRoot.prototype`
                // にしてから `b.Qa(…)` を呼ぶ（YouTube の Polymer の attachShadow）。
                "__proto__" => {
                    if let Value::Object(p) = &val {
                        self.dom.borrow_mut().node_protos.insert(idx, p.clone());
                    }
                }
                _ if key.starts_with("on") && key.len() > 2 => {
                    self.dom.borrow_mut().set_on_handler(idx, key, val.clone());
                    if let Value::Str(s_val) = &val {
                        self.dom.borrow_mut().set_attr(idx, key, s_val);
                    }
                }
                // それ以外は要素の独自プロパティとして覚える（`DomBridge::expandos`）。
                // ただし原型の連鎖に setter があればそれを呼ぶ（カスタム要素のクラスの
                // プロパティ。Polymer はプロパティを prototype のアクセサとして定義する）。
                _ => {
                    let own = self.dom.borrow().expandos.get(&idx).is_some_and(|m| m.contains_key(key));
                    if !own {
                        let mut cur = self.get_dom_node_proto(idx);
                        let mut guard = 0;
                        while let Some(p) = cur {
                            let acc = p.borrow().accessors.get(key).map(|a| a.set.clone());
                            if let Some(setter) = acc {
                                if let Some(f) = setter {
                                    let _ = self.call_value(&f, Value::Object(Obj::dom(idx)), &[val]);
                                }
                                return;
                            }
                            if p.borrow().props.contains_key(key) {
                                break;
                            }
                            guard += 1;
                            if guard > 64 {
                                break;
                            }
                            cur = p.borrow().proto.clone();
                        }
                    }
                    self.dom
                        .borrow_mut()
                        .expandos
                        .entry(idx)
                        .or_default()
                        .insert(String::from(key), val);
                }
            },
            DomDisp::Host(tag) => {
                if let Some(rest) = tag.strip_prefix("style:") {
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    if key == "cssText" {
                        self.dom.borrow_mut().set_css_text(idx, &s);
                    } else {
                        // `style.cssFloat`（読み出し側と対になる書き込み。
                        // 2026-07-17 発見・実装）。
                        let key = if key == "cssFloat" { "float" } else { key };
                        self.dom.borrow_mut().set_style(idx, key, &s);
                    }
                } else if let Some(rest) = tag.strip_prefix("dataset:") {
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    let attr = camel_to_data_attr(key);
                    self.dom.borrow_mut().set_attr(idx, &attr, &s);
                } else if let Some(rest) = tag.strip_prefix("classList:") {
                    let idx: usize = rest.parse().unwrap_or(usize::MAX);
                    if key == "value" {
                        self.dom.borrow_mut().set_attr(idx, "class", &s);
                    }
                }
            }
        }
    }
}

pub(crate) fn template_fragment_clone_node(
    it: &mut Interp,
    this: Value,
    args: &[Value],
) -> Result<Value, Value> {
    let deep = args.get(0).map(|v| v.truthy()).unwrap_or(false);
    let new_frag = Obj::plain();
    new_frag.borrow_mut().props.insert("nodeType".into(), Value::Number(11.0));
    new_frag.borrow_mut().props.insert("nodeName".into(), Value::str("#document-fragment"));

    if let Value::Object(o) = &this {
        let child_vals = if let Some(Value::Object(arr_obj)) = o.borrow().props.get("childNodes") {
            if let ObjKind::Array(elems) = &arr_obj.borrow().kind {
                elems.clone()
            } else {
                alloc::vec::Vec::new()
            }
        } else {
            alloc::vec::Vec::new()
        };

        let mut cloned_children = alloc::vec::Vec::new();
        for child_val in child_vals {
            if let Value::Object(co) = &child_val {
                if let ObjKind::DomElement(c_idx) = co.borrow().kind {
                    let cloned_idx = it.dom.borrow_mut().clone_node(c_idx, deep);
                    cloned_children.push(Value::Object(Obj::dom(cloned_idx)));
                    continue;
                }
            }
            cloned_children.push(child_val.clone());
        }

        let cloned_arr = Obj::array(cloned_children);
        new_frag.borrow_mut().props.insert("childNodes".into(), Value::Object(cloned_arr.clone()));
        new_frag.borrow_mut().props.insert("children".into(), Value::Object(cloned_arr));
    }
    let clone_fn = Obj::native("cloneNode", template_fragment_clone_node);
    new_frag.borrow_mut().props.insert("cloneNode".into(), Value::Object(clone_fn));

    Ok(Value::Object(new_frag))
}