atmos/os_lib/js/interp/

properties.rs

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


impl Interp {
    /// `key in obj` 用: 自身 props → プロトタイプ連鎖を辿って存在判定。
    /// 配列の length / 数値インデックスも考慮する。
    // 循環プロトタイプ連鎖で再帰が無限に深くならないよう、他の連鎖走査と同じ上限
    // ガードを使った反復実装にしている（以前の素朴な再帰は無限再帰＝スタック
    // オーバーフローの危険があった）。
    pub(crate) fn has_property_chain(&self, o: &ObjRef, key: &str) -> bool {
        let mut cur = o.clone();
        let mut guard = 0u32;
        loop {
            let b = cur.borrow();
            if let ObjKind::Array(items) = &b.kind {
                if key == "length" {
                    return true;
                }
                if let Ok(idx) = key.parse::<usize>() {
                    return idx < items.len();
                }
            }
            // `accessors`（getter/setter 専用プロパティ）は `props` とは別マップで管理されて
            // いるため、`props.contains_key` だけでは `{get x(){}}` のような accessor 限定の
            // プロパティが `in` 演算子で「無い」ことになるバグがあった。
            if b.props.contains_key(key) || b.accessors.contains_key(key) {
                return true;
            }
            guard += 1;
            if guard > 1000 {
                return false;
            }
            let next = b.proto.clone();
            drop(b);
            match next {
                Some(p) => cur = p,
                None => return false,
            }
        }
    }

    /// `href`/`src`/`action` IDL プロパティ用: 現在のページURL基準で相対URLを
    /// 絶対URLへ解決する（`JsRuntime::new_interp` の base_url 解決と同じ真実源）。
    pub(crate) fn resolve_url_against_page(&self, raw: &str) -> String {
        if raw.is_empty() {
            return String::new();
        }
        let base = super::super::builtins::location_href(&self.global)
            .filter(|s| !s.is_empty())
            .unwrap_or_else(|| self.base_url.clone());
        if base.is_empty() {
            String::from(raw)
        } else {
            super::super::builtins::resolve_url(&base, raw)
        }
    }

    pub fn get_property(&mut self, recv: &Value, key: &str) -> EvalResult {
        match recv {
            Value::Undefined | Value::Null => Err(self.throw(format!(
                "Cannot read properties of {} (reading '{}')",
                recv.to_js_string(),
                key
            ))),
            Value::Str(s) => Ok(super::super::builtins::string_get(s, key)),
            Value::Number(n) => Ok(super::super::builtins::number_get(*n, key)),
            Value::BigInt(b) => Ok(super::super::builtins::bigint_get(b, key)),
            Value::Bool(b) => Ok(super::super::builtins::boolean_get(*b, key)),
            Value::Object(o) => {
                // Proxy: get トラップがあれば呼ぶ。無ければ target にフォワード。
                let proxy = match &o.borrow().kind {
                    ObjKind::Proxy { target, handler } => Some((target.clone(), handler.clone())),
                    _ => None,
                };
                if let Some((target, handler)) = proxy {
                    let trap = handler.borrow().props.get("get").cloned();
                    if let Some(trap) =
                        trap.filter(|t| matches!(t, Value::Object(f) if f.borrow().is_callable()))
                    {
                        let args = [Value::Object(target), Value::str(key), recv.clone()];
                        return self.call_value(&trap, Value::Object(handler), &args);
                    }
                    return self.get_property(&Value::Object(target), key);
                }
                // `obj.__proto__`（Annex B のレガシーアクセサだが、`{...obj, __proto__:
                // proto}` や `obj.__proto__ = null` という実務コードで極めて広く
                // 使われるイディオム）が丸ごと未対応だった。`Object.getPrototypeOf`
                // と同じ意味論（`Obj::proto` フィールドをそのまま読む）。ただし
                // `{['__proto__']: v}`（算出キー）で作られた通常の own データ
                // プロパティが既にある場合はそちらを優先する（そちらは特別扱い
                // されない普通のプロパティのため）。
                if key == "__proto__" && !o.borrow().props.contains_key("__proto__") {
                    return Ok(match o.borrow().proto.clone() {
                        Some(p) => Value::Object(p),
                        None => Value::Null,
                    });
                }
                // RadioNodeList.prototype.value（HTML Standard §4.10.21.1 getter）。
                if key == "value" && o.borrow().props.get("_is_radio_nodelist").map(|v| v.truthy()).unwrap_or(false) {
                    if let ObjKind::Array(ref items) = o.borrow().kind {
                        let dom = self.dom.borrow();
                        for item in items {
                            if let Value::Object(item_obj) = item {
                                if let ObjKind::DomElement(idx) = item_obj.borrow().kind {
                                    let is_radio = dom.nodes.get(idx).map(|n| n.tag == "input").unwrap_or(false)
                                        && dom.get_attr(idx, "type").as_deref() == Some("radio");
                                    if is_radio && dom.get_attr(idx, "checked").is_some() {
                                        let v = dom.get_attr(idx, "value").unwrap_or_else(|| String::from("on"));
                                        return Ok(Value::str(v));
                                    }
                                }
                            }
                        }
                    }
                    return Ok(Value::str(""));
                }
                if key == "selectedIndex" {
                    if let Some(Value::Number(select_idx)) = o.borrow().props.get("_select_idx") {
                        return Ok(Value::Number(self.dom.borrow().select_selected_index(*select_idx as usize) as f64));
                    }
                }
                // DOM プロキシ（要素ハンドル / style / classList）の動的プロパティ。
                let dom_kind = {
                    match &o.borrow().kind {
                        ObjKind::DomElement(i) => Some(DomDisp::Element(*i)),
                        ObjKind::Host(t)
                            if t.starts_with("style:")
                                || t.starts_with("classList:")
                                || t.starts_with("dataset:")
                                || t.starts_with("computed:")
                                || t.starts_with("stylesheet:") =>
                        {
                            Some(DomDisp::Host(t.clone()))
                        }
                        _ => None,
                    }
                };
                if let Some(d) = dom_kind {
                    return Ok(self.dom_get_property(d, key));
                }
                // localStorage / sessionStorage プロキシ。
                let storage_tag = {
                    match &o.borrow().kind {
                        ObjKind::Host(t) if t.starts_with("storage:") => Some(t.clone()),
                        _ => None,
                    }
                };
                if let Some(t) = storage_tag {
                    return Ok(super::super::builtins::storage_get_prop(&t, key));
                }
                // `entries`/`keys`/`values` が返す軽量イテレータ（`make_iterator()`。
                // `Obj::host("iterator")` + 内部 `_items`/`_pos` で近似）の `next`/
                // `Symbol.iterator` メソッド。
                let is_iterator = matches!(&o.borrow().kind, ObjKind::Host(t) if t == "iterator");
                if is_iterator {
                    // ES2025 Iterator Helpers（`map`/`filter`/`take`/`drop`/`toArray`/
                    // `forEach`/`reduce`）が丸ごと未対応だった。この軽量イテレータ表現の
                    // 上に、残り要素をまとめて処理する即時評価版として実装（詳細は
                    // `iterator_remaining()` のコメント参照）。
                    return Ok(match key {
                        "next" => {
                            Value::Object(Obj::native("next", super::super::builtins::iterator_next))
                        }
                        "Symbol(Symbol.iterator)" => Value::Object(Obj::native(
                            "[Symbol.iterator]",
                            super::super::builtins::iterator_self,
                        )),
                        "map" => Value::Object(Obj::native("map", super::super::builtins::iterator_map)),
                        "filter" => {
                            Value::Object(Obj::native("filter", super::super::builtins::iterator_filter))
                        }
                        "take" => {
                            Value::Object(Obj::native("take", super::super::builtins::iterator_take))
                        }
                        "drop" => {
                            Value::Object(Obj::native("drop", super::super::builtins::iterator_drop))
                        }
                        "toArray" => Value::Object(Obj::native(
                            "toArray",
                            super::super::builtins::iterator_to_array,
                        )),
                        "forEach" => Value::Object(Obj::native(
                            "forEach",
                            super::super::builtins::iterator_for_each,
                        )),
                        "reduce" => {
                            Value::Object(Obj::native("reduce", super::super::builtins::iterator_reduce))
                        }
                        // `some`/`every`/`find`（同じ ES2025 Iterator Helpers 提案に
                        // 含まれる残り3つが丸ごと未対応だった）。
                        "some" => Value::Object(Obj::native("some", super::super::builtins::iterator_some)),
                        "every" => {
                            Value::Object(Obj::native("every", super::super::builtins::iterator_every))
                        }
                        "find" => Value::Object(Obj::native("find", super::super::builtins::iterator_find)),
                        // `flatMap`（ES2025 Iterator Helpers 提案の最後の1つが丸ごと
                        // 未対応だった）。
                        "flatMap" => {
                            Value::Object(Obj::native("flatMap", super::super::builtins::iterator_flat_map))
                        }
                        _ => Value::Undefined,
                    });
                }
                // document.body / head / documentElement → 要素ハンドル。
                let is_document = matches!(&o.borrow().kind, ObjKind::Host(t) if t == "document");
                if is_document {
                    let sel = match key {
                        "body" => Some("body"),
                        "head" => Some("head"),
                        "documentElement" => Some("html"),
                        // `document.scrollingElement`（HTML5。丸ごと未対応だった）。
                        // この処理系は常に標準準拠モード（後述の `compatMode`
                        // 参照）で動作するため、仕様どおり `documentElement`
                        // （`<html>`）と同じ要素を返す簡略実装（quirks モードでの
                        // `<body>` フォールバックは対象外）。
                        "scrollingElement" => Some("html"),
                        // `document.firstElementChild`/`.lastElementChild`
                        // （`ParentNode`ミックスインが`Document`にも丸ごと
                        // 未配線だった。2026-07-17 発見）。整形式の文書は
                        // ルート要素`<html>`を唯一の要素子として持つため、
                        // `documentElement`と同じ要素を返す簡略実装。
                        "firstElementChild" | "lastElementChild" => Some("html"),
                        _ => None,
                    };
                    if let Some(sel) = sel {
                        let idx = self.dom.borrow().query(sel);
                        return Ok(match idx {
                            Some(i) => Value::Object(Obj::dom(i)),
                            None => Value::Null,
                        });
                    }
                    // `document.children`/`.childElementCount`（同じ
                    // `ParentNode`ミックスイン配線漏れ。`<html>`ルート要素
                    // 1件のみを要素として含む簡略実装）。
                    if key == "children" {
                        let idx = self.dom.borrow().query("html");
                        return Ok(Value::Object(Obj::array(match idx {
                            Some(i) => alloc::vec![Value::Object(Obj::dom(i))],
                            None => alloc::vec![],
                        })));
                    }
                    if key == "childElementCount" {
                        let idx = self.dom.borrow().query("html");
                        return Ok(Value::Number(if idx.is_some() { 1.0 } else { 0.0 }));
                    }
                    // `document.activeElement`（HTML5。丸ごと未対応だった。常に
                    // `null` 固定だったバグ）。`element.focus()`/`.blur()`（詳細は
                    // `builtins::dom_focus`/`dom_blur` 参照）が更新する
                    // `DomBridge::focused_idx` を真実源とし、何もフォーカスされて
                    // いなければ仕様どおり `document.body` にフォールバックする。
                    if key == "activeElement" {
                        let focused = self.dom.borrow().focused_idx;
                        let idx = focused.or_else(|| self.dom.borrow().query("body"));
                        return Ok(match idx {
                            Some(i) => Value::Object(Obj::dom(i)),
                            None => Value::Null,
                        });
                    }
                    if key == "styleSheets" {
                        let dom = self.dom.borrow();
                        let mut sheets = alloc::vec![];
                        for (i, node) in dom.nodes.iter().enumerate() {
                            if !node.is_text && node.tag == "style" {
                                sheets.push(Value::Object(Obj::host(&format!("stylesheet:{}", i))));
                            }
                        }
                        return Ok(Value::Object(Obj::array(sheets)));
                    }
                    // `document.title` が常に install 時の空文字列固定で、`<title>`
                    // 要素の実際の中身や代入結果と一切連動していなかったバグ。`<title>`
                    // 要素があればそれを真実源とし、無ければ（`<head>` 自体が無い場合の
                    // フォールバックとして）代入時に保存した内部プロパティ `_title` を返す。
                    if key == "title" {
                        let title_idx = self.dom.borrow().query("title");
                        let text = match title_idx {
                            Some(i) => self.dom.borrow().get_text_content(i),
                            None => o
                                .borrow()
                                .props
                                .get("_title")
                                .map(|v| v.to_js_string())
                                .unwrap_or_default(),
                        };
                        return Ok(Value::str(text));
                    }
                    // `document.URL`/`document.documentURI`（DOM 標準。丸ごと未対応
                    // だった）。この処理系に `<base>` タグ対応が無いため、常に
                    // `location.href` と同一の値を返す簡略実装。
                    if key == "URL" || key == "documentURI" {
                        return Ok(Value::str(
                            super::super::builtins::location_href(&self.global).unwrap_or_default(),
                        ));
                    }
                    // `document.readyState`（HTML5。丸ごと未対応だった。`if
                    // (document.readyState === 'complete') {...}` という定番の
                    // フィーチャー検出イディオムで使われる）。この処理系は
                    // ページ全体を同期的にパースしてから `<script>` を実行する
                    // ため「loading」/「interactive」の中間状態を持たず、常に
                    // `"complete"` を返す簡略実装。
                    if key == "readyState" {
                        return Ok(Value::str("complete"));
                    }
                    // `document.compatMode`（HTML5。丸ごと未対応だった。`if
                    // (document.compatMode === 'CSS1Compat')` という定番の
                    // 標準準拠モード判定イディオム）。この処理系に quirks モード
                    // 自体が無く常に標準準拠として扱うため固定値を返す簡略実装。
                    if key == "compatMode" {
                        return Ok(Value::str("CSS1Compat"));
                    }
                    // `document.characterSet`（別名 `charset`/`inputEncoding`。
                    // HTML5。丸ごと未対応だった）。この処理系は `<meta charset>`
                    // の宣言値に関わらず常に UTF-8 として扱うため固定値を返す
                    // 簡略実装。
                    if key == "characterSet" || key == "charset" || key == "inputEncoding" {
                        return Ok(Value::str("UTF-8"));
                    }
                    // `document.contentType`（HTML5。丸ごと未対応だった）。この
                    // 処理系は常に HTML 文書として扱うため固定値を返す簡略実装。
                    if key == "contentType" {
                        return Ok(Value::str("text/html"));
                    }
                    // `document.cookie`（丸ごと未対応だった。詳細は
                    // `builtins::cookie_string`/`cookie_set` 参照）。
                    if key == "cookie" {
                        return Ok(Value::str(super::super::builtins::cookie_string()));
                    }
                    // `document.referrer`（HTML5。丸ごと未対応だった。`if
                    // (document.referrer) {...}` という定番のリファラ有無判定
                    // イディオム）。この処理系にはページ遷移元を追跡する仕組みが
                    // 無いため、常に空文字列（仕様上「リファラ無し」を表す値）を
                    // 返す簡略実装。
                    if key == "referrer" {
                        return Ok(Value::str(""));
                    }
                    // `document.lastModified`（HTML5。丸ごと未対応だった）。実ファイル
                    // の mtime を追跡する仕組みが無いため、`Date.now()` と同じ
                    // `epoch_ms_now()` を仕様どおりの `"MM/DD/YYYY HH:MM:SS"` 形式へ
                    // 整形して返す簡略実装。
                    if key == "lastModified" {
                        return Ok(Value::str(super::super::builtins::format_last_modified()));
                    }
                    // `document.domain`（HTML5 legacy。丸ごと未対応だった）。この
                    // 処理系には同一オリジンポリシーの緩和機構自体が無いため、
                    // `location.hostname` をそのまま返す読み取り専用近似とする
                    // （代入は no-op のまま。`set_property` 側にも分岐を追加しない）。
                    if key == "domain" {
                        return Ok(Value::str(
                            super::super::builtins::location_hostname(&self.global).unwrap_or_default(),
                        ));
                    }
                    // Page Visibility API（`document.hidden`/`.visibilityState`）が
                    // 丸ごと未対応だった。この処理系にはタブ/バックグラウンド化の
                    // 概念自体が無く、ページは常に前面表示されているため、常に
                    // 「表示中」固定値を返す簡略実装（`visibilitychange` イベントは
                    // 発火する契機が無いため対象外のまま）。
                    if key == "hidden" {
                        return Ok(Value::Bool(false));
                    }
                    if key == "visibilityState" {
                        return Ok(Value::str("visible"));
                    }
                    // `document.forms`/`.images`/`.scripts`（文書全体をタグ横断で
                    // 集約する定番の HTMLCollection 群）が丸ごと未対応だった。既存の
                    // `query_all`（接続済みノードのみを対象にする `querySelectorAll`
                    // の実体）をそのまま再利用する。
                    let coll_sel = match key {
                        "forms" => Some("form"),
                        "images" => Some("img"),
                        "scripts" => Some("script"),
                        // `document.embeds`/`.plugins`（丸ごと未対応だった。仕様上
                        // 両者は同じ `<embed>` 集合を指すエイリアス）。2026-07-16 発見。
                        "embeds" | "plugins" => Some("embed"),
                        _ => None,
                    };
                    if let Some(sel) = coll_sel {
                        let indices = self.dom.borrow().query_all(sel);
                        return Ok(Value::Object(Obj::array(
                            indices.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                        )));
                    }
                    // `document.applets`（丸ごと未対応だった。Java アプレット廃止に
                    // 伴い仕様上は常に空の `HTMLCollection` を返す固定のレガシー
                    // スタブ。2026-07-16 発見）。
                    if key == "applets" {
                        return Ok(Value::Object(Obj::array(alloc::vec![])));
                    }
                    // `document.links`（仕様上 href 付きの a/area のみ）/`document.anchors`
                    // （`name` 属性付きの a のみ）も同じ理由で丸ごと未対応だった。この
                    // 処理系のセレクタには複合セレクタの OR 評価は無いが、`a[href]`/
                    // `area[href]` という属性セレクタ自体は対応済みのため、2回の
                    // `query_all` を結果マージ（node index はパース順＝文書順なので
                    // ソートで正しい順序になる）すれば OR 無しでも実現できる。
                    if key == "links" {
                        let dom = self.dom.borrow();
                        let mut indices = dom.query_all("a[href]");
                        indices.extend(dom.query_all("area[href]"));
                        indices.sort_unstable();
                        return Ok(Value::Object(Obj::array(
                            indices.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                        )));
                    }
                    if key == "anchors" {
                        let indices = self.dom.borrow().query_all("a[name]");
                        return Ok(Value::Object(Obj::array(
                            indices.into_iter().map(|i| Value::Object(Obj::dom(i))).collect(),
                        )));
                    }
                    // それ以外（getElementById 等のメソッド）は通常の props 解決へ。
                }
                // Map / Set の size とメソッド。
                let mapset = {
                    match &o.borrow().kind {
                        ObjKind::MapObj(e) => Some((true, e.len())),
                        ObjKind::SetObj(s) => Some((false, s.len())),
                        _ => None,
                    }
                };
                if let Some((is_map, len)) = mapset {
                    if key == "size" {
                        return Ok(Value::Number(len as f64));
                    }
                    return Ok(super::super::builtins::mapset_method(is_map, key));
                }
                // `URLSearchParams.prototype.size`（ES2023。エントリ数を返す）が
                // 丸ごと未対応だった。`_is_usp` マーカー（`FormData` は同じ `_query`
                // 内部表現を共有するが `size` は USP 固有の仕様のため、区別用に
                // `url_search_params_ctor` でのみ立てる）を持つオブジェクトに限り、
                // 都度クエリ文字列をパースしてエントリ数を返す（Map/Set の `size` と
                // 違い専用 ObjKind が無い plain object 実装のため）。
                if key == "size" && o.borrow().props.contains_key("_is_usp") {
                    let n = super::super::builtins::usp_entry_count(&Value::Object(o.clone()));
                    return Ok(Value::Number(n as f64));
                }
                // Promise のメソッド（then/catch/finally）。
                let is_promise = matches!(&o.borrow().kind, ObjKind::PromiseObj(_));
                if is_promise {
                    return Ok(super::super::builtins::promise_method(key));
                }
                // Generator のメソッド（next/return）。
                let is_gen = matches!(&o.borrow().kind, ObjKind::Generator(_));
                if is_gen {
                    if key == "Symbol(Symbol.iterator)" {
                        return Ok(super::super::builtins::gen_self_iterator_fn());
                    }
                    if key == "Symbol(Symbol.asyncIterator)" {
                        let is_async = if let ObjKind::Generator(g) = &o.borrow().kind {
                            g.borrow().func.is_async
                        } else {
                            false
                        };
                        return Ok(if is_async {
                            super::super::builtins::gen_self_iterator_fn()
                        } else {
                            Value::Undefined
                        });
                    }
                    return Ok(super::super::builtins::generator_method(key));
                }
                // RegExp のプロパティ/メソッド。
                let is_re = matches!(&o.borrow().kind, ObjKind::RegExpObj(_));
                if is_re {
                    return Ok(super::super::builtins::regexp_get(o, key));
                }
                // Date のメソッド。
                let is_date = matches!(&o.borrow().kind, ObjKind::DateObj(_));
                if is_date {
                    return Ok(super::super::builtins::date_get(key));
                }
                // 配列の length / 数値インデックス。
                {
                    let b = o.borrow();
                    if let ObjKind::Array(items) = &b.kind {
                        if key == "length" {
                            return Ok(Value::Number(items.len() as f64));
                        }
                        if let Ok(idx) = key.parse::<usize>() {
                            return Ok(items.get(idx).cloned().unwrap_or(Value::Undefined));
                        }
                    }
                }
                // 関数オブジェクトの call/apply/bind（Function.prototype 相当）。
                if matches!(key, "call" | "apply" | "bind") && o.borrow().is_callable() {
                    return Ok(super::super::builtins::function_method(key));
                }
                // 関数の `name`/`length`（ES1/ES3 以来の最も基礎的な関数メタデータ）。
                // 以前は生成時に props へ一切設定しておらず、通常の props/proto 探索でも
                // 見つからないため常に `undefined` になっていた。`length` は仕様どおり
                // 「デフォルト値/rest が現れる前までの引数の個数」。
                if key == "name" || key == "length" {
                    // `Function.prototype.bind()` が返す関数（`ObjKind::Bound`）は
                    // `.name`/`.length` を一切持たず、以前は `undefined` になっていた
                    // バグだった。仕様どおり `.name` は `"bound " + 元の名前`、
                    // `.length` は `元の length - 束縛済み引数の個数`（0未満にはならない）。
                    let bound_info = match &o.borrow().kind {
                        ObjKind::Bound { target, bound_args, .. } => {
                            Some((target.clone(), bound_args.len()))
                        }
                        _ => None,
                    };
                    if let Some((target, bound_count)) = bound_info {
                        return Ok(if key == "name" {
                            let inner = self
                                .get_property(&target, "name")
                                .map(|v| v.to_js_string())
                                .unwrap_or_default();
                            Value::str(format!("bound {}", inner))
                        } else {
                            let inner_len = self
                                .get_property(&target, "length")
                                .map(|v| v.to_number() as usize)
                                .unwrap_or(0);
                            Value::Number(inner_len.saturating_sub(bound_count) as f64)
                        });
                    }
                    let info = match &o.borrow().kind {
                        ObjKind::Function(fd) => {
                            let len = fd
                                .params
                                .iter()
                                .take_while(|p| p.default.is_none() && !p.is_rest)
                                .count();
                            Some((fd.name.clone(), len))
                        }
                        ObjKind::Native { name, .. } => Some((name.clone(), 0usize)),
                        _ => None,
                    };
                    if let Some((name, len)) = info {
                        return Ok(if key == "name" {
                            Value::str(name)
                        } else {
                            Value::Number(len as f64)
                        });
                    }
                }
                // 自身のプロパティ / アクセサ / プロトタイプ連鎖を辿って解決する。
                // アクセサの getter は必ず元の recv（レシーバ）を this として呼ぶ。
                // 以前はプロトタイプ連鎖を get_property の再帰で辿っていたため、
                // 継承した getter（class の `get x(){}` 等）を呼ぶ際に this が
                // プロトタイプ自身に化けてしまい、インスタンス側のフィールドを
                // 正しく読めない（`this.r` 等が常に undefined になる）バグがあった。
                // ここでは recv を固定したまま cur だけをプロトタイプ連鎖に沿って
                // 進めるループに書き換えている。
                let mut cur = o.clone();
                // `Object.setPrototypeOf` は循環（`setPrototypeOf(a,a)` 等）を検証
                // しないため、プロトタイプ連鎖に循環があるとこのループが無限になり得る
                // （`Proxy` チェーン解決ループで見つかったのと同型のバグ）。他の連鎖
                // 走査と同じ上限ガードで打ち切る。2026-07-11 に一度試みて「新しい
                // ハング」に見えたため撤回したが、2026-07-12 にそれが QEMU 起動側の
                // host タイミング変動による誤検知だったと判明したため再度追加する。
                let mut guard = 0u32;
                loop {
                    let has_accessor_entry = cur.borrow().accessors.contains_key(key);
                    if has_accessor_entry {
                        // アクセサはデータプロパティより優先される（仕様通り）。
                        // get が無ければ（set のみ定義）undefined を返して打ち切る。
                        let getter = cur.borrow().accessors.get(key).and_then(|a| a.get.clone());
                        return if let Some(g) = getter {
                            self.call_value(&g, recv.clone(), &[])
                        } else {
                            Ok(Value::Undefined)
                        };
                    }
                    let prop = cur.borrow().props.get(key).cloned();
                    if let Some(v) = prop {
                        return Ok(v);
                    }
                    guard += 1;
                    if guard > 1000 {
                        break;
                    }
                    let next = cur.borrow().proto.clone().or_else(|| {
                        if let ObjKind::DomElement(idx) = cur.borrow().kind {
                            self.get_dom_node_proto(idx)
                        } else {
                            None
                        }
                    });
                    match next {
                        Some(p) => cur = p,
                        None => break,
                    }
                }
                // `Object.create(null)`/`Object.groupBy()`等、明示的にnull
                // プロトタイプ化されたオブジェクト（`null_proto`）は、
                // `hasOwnProperty`/`toString`等の共通メソッドフォールバックも
                // 一切持たないのが仕様（`proto: None`が「単に通常オブジェクト
                // でチェーンが尽きた」のか「明示的にnull」なのかを区別する
                // ためのフラグ。2026-07-18 発見・実装）。
                if o.borrow().null_proto {
                    return Ok(Value::Undefined);
                }
                // 組込みメソッド（Array/Object 共通）。
                Ok(super::super::builtins::object_get(o, key))
            }
        }
    }

    pub fn set_property(&mut self, recv: &Value, key: &str, val: Value) {
        if let Value::Object(o) = recv {
            // `Object.freeze()` 済みなら黙殺（非 strict モード相当。以前は freeze 自体が
            // no-op で、このチェックが無かった）。
            if o.borrow().frozen {
                return;
            }
            // Proxy: set トラップがあれば呼ぶ。無ければ target にフォワード。
            let proxy = match &o.borrow().kind {
                ObjKind::Proxy { target, handler } => Some((target.clone(), handler.clone())),
                _ => None,
            };
            if let Some((target, handler)) = proxy {
                let trap = handler.borrow().props.get("set").cloned();
                if let Some(trap) =
                    trap.filter(|t| matches!(t, Value::Object(f) if f.borrow().is_callable()))
                {
                    let args = [Value::Object(target), Value::str(key), val, recv.clone()];
                    // `set_property` は `()` を返す設計なので例外を上へ返せない。
                    // 捨てずに報告する（トラップ内の例外が消えると、代入が
                    // 効かない理由が誰にも分からなくなる）。
                    let ctx = alloc::format!("Proxy set trap for '{}'", key);
                    self.call_listener(&trap, Value::Object(handler), &args, &ctx);
                    return;
                }
                self.set_property(&Value::Object(target), key, val);
                return;
            }
            // `obj.__proto__ = proto`（Annex B のレガシーアクセサ。`get_property`
            // 側の同名の欠落と対になるバグ）。`Object.setPrototypeOf` と同じ意味論
            // （`null`/非オブジェクトならプロトタイプ連鎖を切る）。ただし
            // `{['__proto__']: v}`（算出キー）で作られた通常の own データ
            // プロパティが既にある場合は `get_property` と同様そちらを優先し、
            // 普通のプロパティ代入として扱う。
            if key == "__proto__" && !o.borrow().props.contains_key("__proto__") {
                match val {
                    Value::Object(p) => o.borrow_mut().proto = Some(p),
                    _ => o.borrow_mut().proto = None,
                }
                return;
            }
            // RadioNodeList.prototype.value = val（HTML Standard §4.10.21.1 setter）。
            if key == "value" && o.borrow().props.get("_is_radio_nodelist").map(|v| v.truthy()).unwrap_or(false) {
                let target_val = val.to_js_string();
                if let ObjKind::Array(ref items) = o.borrow().kind {
                    let mut dom = self.dom.borrow_mut();
                    for item in items {
                        if let Value::Object(item_obj) = item {
                            if let ObjKind::DomElement(idx) = item_obj.borrow().kind {
                                let is_radio = dom.nodes.get(idx).map(|n| n.tag == "input").unwrap_or(false)
                                    && dom.get_attr(idx, "type").as_deref() == Some("radio");
                                if is_radio {
                                    let elem_val = dom.get_attr(idx, "value").unwrap_or_else(|| String::from("on"));
                                    if elem_val == target_val {
                                        dom.set_attr(idx, "checked", "");
                                    } else {
                                        dom.remove_attr(idx, "checked");
                                    }
                                }
                            }
                        }
                    }
                }
                return;
            }
            if key == "selectedIndex" {
                if let Some(Value::Number(select_idx)) = o.borrow().props.get("_select_idx") {
                    let idx = *select_idx as usize;
                    let n = val.to_number() as i32;
                    self.dom.borrow_mut().set_select_selected_index(idx, n);
                    return;
                }
            }
            // DOM プロキシへの代入。
            let dom_kind = {
                match &o.borrow().kind {
                    ObjKind::DomElement(i) => Some(DomDisp::Element(*i)),
                    ObjKind::Host(t)
                        if t.starts_with("style:")
                            || t.starts_with("dataset:")
                            || t.starts_with("classList:") =>
                    {
                        Some(DomDisp::Host(t.clone()))
                    }
                    _ => None,
                }
            };
            if let Some(d) = dom_kind {
                self.dom_set_property(d, key, val);
                return;
            }
            // `document.title = "..."` への代入が完全に無視され、常に空文字列固定
            // だったバグ（`<title>` 要素と一切連動していなかった）。既存の `<title>`
            // 要素があればそのテキストを更新し、`<head>` はあるが `<title>` が無ければ
            // 子として新規作成する（仕様は先頭子として挿入だが、この処理系の
            // `append_child` を使う末尾追加の簡略実装。表示上の見た目には影響しない）。
            // `<head>` 自体が無い場合（`JsRuntime` 生成直後は DOM が完全に空）は内部
            // プロパティ `_title` に保存し、getter 側のフォールバックで読めるようにする。
            let is_document = matches!(&o.borrow().kind, ObjKind::Host(t) if t == "document");
            if is_document && key == "title" {
                let s = val.to_js_string();
                let title_idx = self.dom.borrow().query("title");
                match title_idx {
                    Some(i) => self.dom.borrow_mut().set_text_content(i, &s),
                    None => {
                        let head_idx = self.dom.borrow().query("head");
                        match head_idx {
                            Some(head_idx) => {
                                let new_title = self.dom.borrow_mut().create_element("title");
                                self.dom.borrow_mut().set_text_content(new_title, &s);
                                self.dom.borrow_mut().append_child(head_idx, new_title);
                            }
                            None => {
                                o.borrow_mut().props.insert("_title".into(), Value::str(s.clone()));
                            }
                        }
                    }
                }
                return;
            }
            // `document.cookie = "name=value; ..."` への代入（丸ごと未対応
            // だった）。詳細は `builtins::cookie_set` 参照。
            if is_document && key == "cookie" {
                super::super::builtins::cookie_set(&val.to_js_string());
                return;
            }
            // localStorage / sessionStorage への代入。
            let storage_tag = {
                match &o.borrow().kind {
                    ObjKind::Host(t) if t.starts_with("storage:") => Some(t.clone()),
                    _ => None,
                }
            };
            if let Some(t) = storage_tag {
                super::super::builtins::storage_set_prop(&t, key, &val);
                return;
            }
            // レガシー DOM Level 0 の `event.returnValue`/`event.cancelBubble` への
            // 代入が丸ごと無視され、単なるプロパティ上書き（何の効果も持たない）に
            // なっていたバグ。仕様上これらは `preventDefault()`/`stopPropagation()`
            // と等価の副作用を持つべき。`preventDefault` プロパティ（callable）の
            // 有無で Event オブジェクトかどうかを判定する（このエンジンの
            // event_ctor/custom_event_ctor/DOM 要素側いずれも必ず持つ一意な目印）。
            if key == "returnValue" || key == "cancelBubble" {
                let is_event = matches!(
                    o.borrow().props.get("preventDefault"),
                    Some(Value::Object(f)) if f.borrow().is_callable()
                );
                if is_event {
                    if key == "returnValue" && !val.truthy() {
                        // `o.borrow()` の一時 Ref を `if let` の条件式に直接書くと
                        // ブロック終端までライフタイムが延び、`call_value` が呼ぶ
                        // `preventDefault` 内の `borrow_mut()` と衝突して
                        // 「RefCell already borrowed」パニックになる（実機/QEMU
                        // 起動時の自己テストで発覚）。先に所有値へ取り出してから
                        // 呼び出すことで借用を確実に解放する。
                        let pd = o.borrow().props.get("preventDefault").cloned();
                        if let Some(f) = pd {
                            self.call_listener(&f, recv.clone(), &[], "preventDefault()");
                        }
                        return;
                    }
                    if key == "cancelBubble" && val.truthy() {
                        let sp = o.borrow().props.get("stopPropagation").cloned();
                        if let Some(f) = sp {
                            self.call_listener(&f, recv.clone(), &[], "stopPropagation()");
                        }
                        return;
                    }
                    // `returnValue = true` や `cancelBubble = false` は一度止めた
                    // ものを元に戻す効果を持たない no-op だが、代入値自体は保持する。
                    o.borrow_mut().props.insert(key.to_string(), val);
                    return;
                }
            }
            // RegExp.lastIndex への代入（`g`/`y` フラグと組み合わせた手動シーク用）。
            // 特別扱いしないと汎用 props への書込みで終わり、実際のマッチ開始位置
            // （RegExpData.last_index）には反映されず sticky/global の再開位置制御が効かない。
            if key == "lastIndex" {
                if let ObjKind::RegExpObj(r) = &o.borrow().kind {
                    let n = val.to_number();
                    if n.is_finite() && n >= 0.0 {
                        r.borrow_mut().last_index = n as usize;
                    }
                    return;
                }
            }
            // アクセサ（setter）確認。`get_property` と同じ理由で、プロトタイプ連鎖
            // （class の `set x(v){}` は prototype 上にある）を this を固定したまま
            // ループで辿る（インスタンス自身だけしか見ていなかった旧実装は、継承した
            // setter が一切呼ばれず通常のプロパティ書込みにフォールバックしてしまう
            // バグだった）。
            let mut cur = o.clone();
            // `get_property` と同じ理由（`Object.setPrototypeOf` が循環プロトタイプ
            // 連鎖を検証しない）で上限ガードが必要。
            let mut guard = 0u32;
            loop {
                let has_accessor_entry = cur.borrow().accessors.contains_key(key);
                if has_accessor_entry {
                    let setter = cur.borrow().accessors.get(key).and_then(|a| a.set.clone());
                    if let Some(s) = setter {
                        let ctx = alloc::format!("setter for '{}'", key);
                        self.call_listener(&s, recv.clone(), &[val], &ctx);
                    }
                    // setter が無い（getter のみ）場合も、アクセサ定義がある以上は
                    // 通常のデータプロパティ書込みへフォールバックしない（仕様通り）。
                    return;
                }
                guard += 1;
                if guard > 1000 {
                    break;
                }
                let next = cur.borrow().proto.clone();
                match next {
                    Some(p) => cur = p,
                    None => break,
                }
            }
            let mut b = o.borrow_mut();
            if b.props.contains_key(key) {
                if let Some(attr) = b.attrs.get(key) {
                    if !attr.writable {
                        return;
                    }
                }
            }
            // TypedArray（`_ta_kind` タグ付きの `ObjKind::Array` 流用実装）の索引代入
            // `ta[i] = v` は、コンストラクタ/`set`/`fill` 経由と違って型変換
            // （ToInt8/ToUint8Clamp/... 相当。範囲外の値のラップ/クランプ）が一切
            // 効かず生の数値がそのまま入るバグだった（例: `new Int8Array(1); a[0]=200;`
            // が `200` のまま、本来は `-56` にラップされるべき）。
            let ta_kind_tag = b.props.get("_ta_kind").map(|v| v.to_js_string());
            if let ObjKind::Array(items) = &mut b.kind {
                if key == "length" {
                    let n = val.to_number();
                    if n.is_finite() && n >= 0.0 {
                        items.resize(n as usize, Value::Undefined);
                    }
                    return;
                }
                if let Ok(idx) = key.parse::<usize>() {
                    if idx >= items.len() {
                        items.resize(idx + 1, Value::Undefined);
                    }
                    let val = match &ta_kind_tag {
                        Some(tag) => Value::Number(super::super::builtins::ta_coerce_index_value(tag, &val)),
                        None => val,
                    };
                    items[idx] = val;
                    return;
                }
            }
            // `Object.seal()`/`Object.preventExtensions()` 済みなら新規プロパティの追加を
            // 拒否する（既存キーの値変更は許可。配列の数値インデックス拡張は対象外の簡略化）。
            if (b.sealed || b.non_extensible) && !b.props.contains_key(key) {
                return;
            }
            // location オブジェクトのナビゲーション系プロパティへの代入。
            // 例: location.href = "..." / location.hash = "#x" / location.pathname = "/p"。
            // ホストが take_pending_location() で回収し実ナビゲーションするよう要求を積む。
            // それ以外（origin 等の読取専用や href の文字列保持）は通常通り props に格納する。
            let is_location = b.props.contains_key("_is_location");
            if is_location {
                let new_val = val.to_js_string();
                match key {
                    "href" => {
                        b.props
                            .insert(String::from("_pending_location"), Value::str(&new_val));
                        b.props
                            .insert(String::from("_pending_location_mode"), Value::str("assign"));
                    }
                    "hash" => {
                        // 現在の href からフラグメントだけ差し替えた完全URLを要求に積む。
                        let cur = b
                            .props
                            .get("href")
                            .map(|v| v.to_js_string())
                            .unwrap_or_default();
                        let base = match cur.split_once('#') {
                            Some((b, _)) => String::from(b),
                            None => cur,
                        };
                        let frag = new_val.trim_start_matches('#');
                        let full = alloc::format!("{}#{}", base, frag);
                        b.props
                            .insert(String::from("_pending_location"), Value::str(&full));
                        b.props
                            .insert(String::from("_pending_location_mode"), Value::str("hash"));
                    }
                    "pathname" | "search" => {
                        // protocol+host を保ったまま path / query を差し替える。
                        let proto = b
                            .props
                            .get("protocol")
                            .map(|v| v.to_js_string())
                            .unwrap_or_else(|| String::from("https:"));
                        let host = b
                            .props
                            .get("host")
                            .map(|v| v.to_js_string())
                            .unwrap_or_default();
                        let pathname = if key == "pathname" {
                            new_val.clone()
                        } else {
                            b.props
                                .get("pathname")
                                .map(|v| v.to_js_string())
                                .unwrap_or_else(|| String::from("/"))
                        };
                        let search = if key == "search" {
                            if new_val.is_empty() || new_val.starts_with('?') {
                                new_val.clone()
                            } else {
                                alloc::format!("?{}", new_val)
                            }
                        } else {
                            b.props
                                .get("search")
                                .map(|v| v.to_js_string())
                                .unwrap_or_default()
                        };
                        let full = alloc::format!("{}//{}{}{}", proto, host, pathname, search);
                        b.props
                            .insert(String::from("_pending_location"), Value::str(&full));
                        b.props
                            .insert(String::from("_pending_location_mode"), Value::str("assign"));
                    }
                    // `location.protocol`/`.host`/`.hostname`/`.port`への代入も実際に
                    // 実 URL では再ナビゲーションを発生させる仕様だが、`href`/`hash`/
                    // `pathname`/`search`だけがこの`match`で処理されており、この4つは
                    // 常に`_ => {}`（後段で見かけ上の`.props`値は更新されるが、
                    // `_pending_location`が積まれずナビゲーション要求にならない）に
                    // 落ちていた。`pathname`/`search`分岐と同じ「他のコンポーネントは
                    // 現在値を保ったまま、変更対象だけ差し替えてhrefを再構成する」
                    // パターンをそのまま適用する。
                    "protocol" | "host" | "hostname" | "port" => {
                        let proto = if key == "protocol" {
                            if new_val.ends_with(':') { new_val.clone() } else { alloc::format!("{}:", new_val) }
                        } else {
                            b.props.get("protocol").map(|v| v.to_js_string()).unwrap_or_else(|| String::from("https:"))
                        };
                        let host = if key == "host" {
                            // `host`は`hostname`+`:`+`port`の合成値のため、`hostname`/
                            // `port`個別プロパティもここで分割して同期しておく（しないと
                            // `location.host='a.com:1'`の直後に`location.hostname`/
                            // `.port`を読んだ時だけ古い値のままという食い違いが起きる）。
                            let (hn, pt) = match new_val.split_once(':') {
                                Some((h, p)) => (String::from(h), String::from(p)),
                                None => (new_val.clone(), String::new()),
                            };
                            b.props.insert(String::from("hostname"), Value::str(&hn));
                            b.props.insert(String::from("port"), Value::str(&pt));
                            new_val.clone()
                        } else if key == "hostname" || key == "port" {
                            let hostname = if key == "hostname" {
                                new_val.clone()
                            } else {
                                b.props.get("hostname").map(|v| v.to_js_string()).unwrap_or_default()
                            };
                            let port = if key == "port" {
                                new_val.clone()
                            } else {
                                b.props.get("port").map(|v| v.to_js_string()).unwrap_or_default()
                            };
                            if port.is_empty() { hostname } else { alloc::format!("{}:{}", hostname, port) }
                        } else {
                            b.props.get("host").map(|v| v.to_js_string()).unwrap_or_default()
                        };
                        let pathname = b
                            .props
                            .get("pathname")
                            .map(|v| v.to_js_string())
                            .unwrap_or_else(|| String::from("/"));
                        let search = b.props.get("search").map(|v| v.to_js_string()).unwrap_or_default();
                        let full = alloc::format!("{}//{}{}{}", proto, host, pathname, search);
                        b.props
                            .insert(String::from("_pending_location"), Value::str(&full));
                        b.props
                            .insert(String::from("_pending_location_mode"), Value::str("assign"));
                    }
                    _ => {}
                }
                // href 等の見かけ上の値も更新しておく（同期読取のため）。
                b.props.insert(String::from(key), val);
                return;
            }
            b.props.insert(String::from(key), val);
        }
    }

    // ============ DOM プロキシのプロパティ ============

}