atmos/os_lib/js/builtins/

window_api.rs

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

// ===== window.confirm / window.prompt =====
/// `window.confirm(message)`（丸ごと未対応だった。`window.alert`は`console_
/// log`で無害に代替されていたが、対になる`confirm`/`prompt`自体がグローバル
/// にも`window`にも一切登録されておらず、呼び出すと`ReferenceError`/
/// `TypeError`になっていた。2026-07-16 発見・実装）。この処理系にはブロッキング
/// モーダルダイアログ機構が無いため、メッセージを`console_log`と同じ経路へ
/// 出力したうえで、常に「OK」を選択したものとして`true`を返す（`alert`と
/// 同じ「実際のUIは出さないが呼び出し自体は安全に完了させる」簡略方針）。
pub(crate) fn window_confirm(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let _ = console_log(it, this, a);
    Ok(Value::Bool(true))
}
/// `window.prompt(message, default)`（丸ごと未対応だった。理由は`window_
/// confirm`と同じ）。`default`引数があればそれをそのまま返す（ユーザーが
/// 何も変更せず「OK」を押した相当）。無指定時は仕様どおり`null`。
pub(crate) fn window_prompt(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let _ = console_log(it, this, a);
    match a.get(1) {
        Some(v) if !matches!(v, Value::Undefined) => Ok(v.clone()),
        _ => Ok(Value::Null),
    }
}

// ===== window.open / window.close / window.focus / window.blur =====
/// `window.open(url, target, features)`（丸ごと未対応だった。`confirm`/
/// `prompt`と同じ監査で発見。`typeof window.open === 'function'`という
/// 定番のフィーチャー検出ガードや、ポップアップを試みるコードが
/// `TypeError`で丸ごと落ちる状態だった。2026-07-16 発見・実装）。この処理系
/// には複数ウィンドウ/ポップアップを新規に開く仕組みが無いため、実際には
/// 何も開かず、仕様上「開けなかった（ポップアップブロック等）」場合と
/// 同じ`null`を返す誠実な簡略実装（ブラウザのポップアップブロッカーが
/// `window.open()`を拒否した場合の正規の戻り値と同じ形）。
pub(crate) fn window_open(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Null)
}
/// `window.close()`（丸ごと未対応だった。理由は`window_open`と同じ）。
/// この処理系にはウィンドウを閉じる操作自体が無いため無害な no-op
/// （`window.print()`と同方針）。
pub(crate) fn window_close(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}
/// `window.stop()`（丸ごと未対応だった。ブラウザの「読み込み中止」ボタン
/// に相当する定番API。2026-07-17 発見）。この処理系はページ全体を同期的に
/// パースしてから`<script>`を実行するため、途中で中断できる非同期の
/// 読み込み処理自体が無く、`window.close`/`.print`と同じ無害なno-op。
pub(crate) fn window_stop(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}
/// `window.focus()`/`.blur()`（丸ごと未対応だった。理由は`window_open`と
/// 同じ）。この処理系にはウィンドウ/タブという概念自体が無く（
/// `document.hasFocus()`が常に`true`固定なのと同じ理由）、フォーカス要求
/// 先も存在しないため無害な no-op。
pub(crate) fn window_focus(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}

// ===== window.scrollY / scrollTo / scrollBy / scrollIntoView =====

/// `window.scrollTo(x, y)`/`window.scroll(x, y)`（丸ごと未対応だった。以前は
/// `SCROLL_Y` という孤立した `static` へ書き込むだけの実装で、`window.
/// scrollY`（`fire_scroll`経由でレンダラが更新する別経路）にも実際の描画位置
/// にも一切反映されない死んだ経路だった。2026-07-16 発見・修正）。
/// `DomBridge::pending_scroll_abs_y`へ保留し、`render.rs`の`draw()`冒頭で
/// 消費・`WebEngine::scroll_y`へ適用・`fire_scroll()`呼び出しまで行う。
pub(crate) fn window_scroll_to(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let y = if let Some(Value::Object(o)) = a.first() {
        o.borrow()
            .props
            .get("top")
            .map(|v| v.to_number())
            .unwrap_or(0.0)
    } else {
        arg(a, 1).to_number()
    };
    it.dom.borrow_mut().pending_scroll_abs_y = Some(y as i32);
    Ok(Value::Undefined)
}
/// `window.scrollBy(x, y)`（丸ごと未対応だった。`dom_noop`のまま何もせず、
/// 相対スクロールが一切機能しなかった。2026-07-16 発見・実装）。複数回
/// 呼ばれた場合は次の描画までの分を加算する。
pub(crate) fn window_scroll_by(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let dy = if let Some(Value::Object(o)) = a.first() {
        o.borrow()
            .props
            .get("top")
            .map(|v| v.to_number())
            .unwrap_or(0.0)
    } else {
        arg(a, 1).to_number()
    };
    let mut dom = it.dom.borrow_mut();
    dom.pending_scroll_by_y = Some(dom.pending_scroll_by_y.unwrap_or(0) + dy as i32);
    Ok(Value::Undefined)
}
pub(crate) fn element_scroll_into_view(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined) // ページ内スクロール：AtmOS web_engine が管理するため no-op
}

// ===== window.matchMedia =====
pub(crate) fn window_match_media(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let query = arg(a, 0).to_js_string();
    // `window.matchMedia()` は `max-width`/`min-width` の狭い専用判定のみで、
    // 同じ `@media` 構文を対象とする CSS 側の `css::media_query_matches`
    // （`prefers-color-scheme`/`hover`/`pointer`/`resolution`/`monochrome`/
    // `forced-colors`/`inverted-colors`/`color-gamut`/複合条件/カンマ区切り等、
    // 多数のバグ修正を経て充実済み）と食い違う非対称なバグだった。同じ判定
    // ロジックを再利用して一致させる。
    let matches = crate::os_lib::css::media_query_matches(&query);
    let mql = Obj::plain();
    {
        let mut b = mql.borrow_mut();
        b.props.insert("matches".into(), Value::Bool(matches));
        b.props.insert("media".into(), Value::str(query));
        b.props
            .insert("addEventListener".into(), nv("addEventListener", dom_noop));
        b.props
            .insert("addListener".into(), nv("addListener", dom_noop));
        b.props
            .insert("removeListener".into(), nv("removeListener", dom_noop));
        b.props.insert(
            "removeEventListener".into(),
            nv("removeEventListener", dom_noop),
        );
    }
    Ok(Value::Object(mql))
}

/// window の隠し props 配列（ObjKind::Array）へリスナを追記する。
/// scroll/popstate など、eval をまたいで永続させたいリスナの保存に使う
/// （Interp ローカルだと eval 毎に破棄されるため window オブジェクトに退避）。
/// エントリは `addEventListener` の `{signal}` 対応（2026-07-14 発見・実装）
/// のため `[cb, signal]` 形式で格納する（`event_target_*` 系の `[cb, once,
/// signal]` と同系統。`window` 系イベントには `once` 概念が無いためこちら
/// は2要素）。`window_listeners`（interp.rs）/`_message_listeners`/
/// `_error_listeners` の発火経路側で `event_target_listener_cb`/
/// `window_listener_aborted` を使って読み解く。
pub(crate) fn push_window_listener(it: &mut Interp, key: &str, cb: Value, signal: Option<Value>) {
    let w = match it.global.borrow().vars.get("window") {
        Some(Value::Object(w)) => w.clone(),
        _ => return,
    };
    let entry = Value::Object(Obj::array(alloc::vec![cb, signal.unwrap_or(Value::Undefined)]));
    let existing = w.borrow().props.get(key).cloned();
    match existing {
        Some(Value::Object(arr)) if matches!(arr.borrow().kind, ObjKind::Array(_)) => {
            if let ObjKind::Array(items) = &mut arr.borrow_mut().kind {
                items.push(entry);
            }
        }
        _ => {
            let arr = Obj::array(alloc::vec![entry]);
            w.borrow_mut().props.insert(key.into(), Value::Object(arr));
        }
    }
}
/// `push_window_listener` の格納エントリ `[cb, signal]` の `signal` が
/// abort 済みかどうか。
pub(crate) fn window_listener_aborted(entry: &Value) -> bool {
    if let Value::Object(o) = entry {
        if let ObjKind::Array(items) = &o.borrow().kind {
            if let Some(sig) = items.get(1) {
                return super::super::dom_bridge::is_signal_aborted(sig);
            }
        }
    }
    false
}

/// window.addEventListener('load'|'DOMContentLoaded', cb) → load は即時発火。
/// 'scroll' は window の隠し props `_scroll_listeners`、'popstate' は `_popstate_listeners`、
/// 'hashchange' は `_hashchange_listeners`、'resize' は `_resize_listeners`
/// 配列へ永続記録（該当イベント発生時にホストが発火）。
pub(crate) fn window_add_event_listener(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let event = arg(a, 0).to_js_string();
    let cb = arg(a, 1);
    // `{signal}`（丸ごと未対応だった。`AbortController` でリスナを一括解除する
    // 定番パターン。2026-07-14 発見・実装）。既に abort 済みなら登録自体を
    // 行わない（DOM 仕様どおり）。
    let signal = parse_listener_signal(&arg(a, 2));
    if signal.as_ref().is_some_and(super::super::dom_bridge::is_signal_aborted) {
        return Ok(Value::Undefined);
    }
    match event.as_str() {
        // `readystatechange`（丸ごと未対応だった。`document.readyState`は
        // 常に `"complete"` を返す簡略実装のため、`load`/`DOMContentLoaded`
        // と同じく登録時点で即時発火する）。
        "load" | "DOMContentLoaded" | "readystatechange" => {
            // 例外を捨てるとページ初期化が途中で止まった理由が消える。
            it.call_listener(&cb, Value::Undefined, &[], "window load listener");
        }
        "scroll" => {
            push_window_listener(it, "_scroll_listeners", cb, signal);
        }
        "popstate" => {
            push_window_listener(it, "_popstate_listeners", cb, signal);
        }
        "hashchange" => {
            push_window_listener(it, "_hashchange_listeners", cb, signal);
        }
        "resize" => {
            push_window_listener(it, "_resize_listeners", cb, signal);
        }
        // `online`/`offline`（丸ごと未対応だった。`navigator.onLine` は既に
        // 実装済みだったが、対応するイベント種別自体が登録経路すら無く
        // `addEventListener('online', ...)` が黙って何もしないバグだった。
        // この処理系には実際のネットワーク接続状態変化検知機構が無いため、
        // 実発火は無い（`window.dispatchEvent()` 経由の手動シミュレーション
        // のみサポート）。
        "online" => {
            push_window_listener(it, "_online_listeners", cb, signal);
        }
        "offline" => {
            push_window_listener(it, "_offline_listeners", cb, signal);
        }
        // `beforeunload`/`unload`/`pageshow`/`pagehide`/`visibilitychange`/
        // `languagechange`（丸ごと未対応だった。`online`/`offline` と同じ
        // 理由で登録経路自体が無かった）。この処理系にはページ遷移/タブ
        // 可視性変化/言語設定変更のいずれの検知機構も無いため、`online`/
        // `offline` と同じく実発火は無く手動シミュレーションのみサポート。
        "beforeunload" => {
            push_window_listener(it, "_beforeunload_listeners", cb, signal);
        }
        "unload" => {
            push_window_listener(it, "_unload_listeners", cb, signal);
        }
        "pageshow" => {
            push_window_listener(it, "_pageshow_listeners", cb, signal);
        }
        "pagehide" => {
            push_window_listener(it, "_pagehide_listeners", cb, signal);
        }
        "visibilitychange" => {
            push_window_listener(it, "_visibilitychange_listeners", cb, signal);
        }
        "languagechange" => {
            push_window_listener(it, "_languagechange_listeners", cb, signal);
        }
        // `storage`（他タブ/ウィンドウでの `localStorage`/`sessionStorage`
        // 変更通知。丸ごと未対応だった。`StorageEvent` コンストラクタ自体は
        // 既に対応済みだったが、対応するイベント種別の登録経路が無かった）。
        // この処理系には実際の複数タブ間通知機構が無いため、`online`/
        // `offline` と同じく手動シミュレーションのみサポート。
        "storage" => {
            push_window_listener(it, "_storage_listeners", cb, signal);
        }
        // `beforeprint`/`afterprint`（`window.print()`の前後に発火する
        // 印刷ダイアログ連動イベント。丸ごと未対応だった）。この処理系には
        // 実際の印刷パイプライン自体が無いため、`online`/`offline` と同じく
        // 手動シミュレーションのみサポート。
        "beforeprint" => {
            push_window_listener(it, "_beforeprint_listeners", cb, signal);
        }
        "afterprint" => {
            push_window_listener(it, "_afterprint_listeners", cb, signal);
        }
        // `window.postMessage()` の受信側。`_message_listeners` は
        // `window_post_message` が同期的に配送する。
        "message" => {
            push_window_listener(it, "_message_listeners", cb, signal);
        }
        // `reportError()`/未捕捉例外の受信側。`_error_listeners` は
        // `report_error` が同期的に配送する。
        "error" => {
            push_window_listener(it, "_error_listeners", cb, signal);
        }
        _ => {}
    }
    Ok(Value::Undefined)
}

/// `window.removeEventListener(type, cb)`（丸ごと未対応だった。以前は
/// 無害な `domNoop` のままで、`window.addEventListener` で登録した
/// リスナが `AbortSignal` 経由以外では二度と解除できないバグだった）。
/// `window_add_event_listener` と同じ6種の固定イベント種別に限り対応する
/// 隠し配列から、参照が一致するエントリを取り除く（`event_target_remove_
/// event_listener` と同じ `Rc::ptr_eq` 比較パターン）。
pub(crate) fn window_remove_event_listener(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let event = arg(a, 0).to_js_string();
    let cb = arg(a, 1);
    let key = match event.as_str() {
        "scroll" => "_scroll_listeners",
        "popstate" => "_popstate_listeners",
        "hashchange" => "_hashchange_listeners",
        "resize" => "_resize_listeners",
        "online" => "_online_listeners",
        "offline" => "_offline_listeners",
        "beforeunload" => "_beforeunload_listeners",
        "unload" => "_unload_listeners",
        "pageshow" => "_pageshow_listeners",
        "pagehide" => "_pagehide_listeners",
        "visibilitychange" => "_visibilitychange_listeners",
        "languagechange" => "_languagechange_listeners",
        "storage" => "_storage_listeners",
        "beforeprint" => "_beforeprint_listeners",
        "afterprint" => "_afterprint_listeners",
        "message" => "_message_listeners",
        "error" => "_error_listeners",
        _ => return Ok(Value::Undefined),
    };
    let w = match it.global.borrow().vars.get("window") {
        Some(Value::Object(w)) => w.clone(),
        _ => return Ok(Value::Undefined),
    };
    let arr = match w.borrow().props.get(key) {
        Some(Value::Object(arr)) => arr.clone(),
        _ => return Ok(Value::Undefined),
    };
    if let ObjKind::Array(items) = &mut arr.borrow_mut().kind {
        items.retain(|entry| {
            let stored_cb = match entry {
                Value::Object(o) => match &o.borrow().kind {
                    ObjKind::Array(pair) => pair.first().cloned().unwrap_or(Value::Undefined),
                    _ => entry.clone(),
                },
                _ => entry.clone(),
            };
            match (&stored_cb, &cb) {
                (Value::Object(x), Value::Object(y)) => !Rc::ptr_eq(x, y),
                _ => true,
            }
        });
    }
    Ok(Value::Undefined)
}
/// `window.dispatchEvent(event)`（丸ごと未対応だった。`window` オブジェクトに
/// `addEventListener`/`removeEventListener` はあったが `dispatchEvent` 自体が
/// 存在せず、`window.dispatchEvent(new HashChangeEvent(...))` のような JS 側
/// からのイベントシミュレーションが一切できなかった。`window_add_event_
/// listener` が対応する6種の固定イベント種別（`scroll`/`popstate`/
/// `hashchange`/`resize`/`message`/`error`）に限り、対応する隠し配列
/// （`push_window_listener`が書き込む先）からリスナを読み出し、渡された
/// `event` オブジェクトをそのまま転送して呼び出す（`fire_window_listeners`
/// のような独自 Event 再構築は行わず、JS 側が構築した実際のオブジェクトを
/// そのまま渡す）。対応外の種別は無害に無視する（`addEventListener`側の
/// 未対応種別の扱いと同じ）。`window.onerror`（`report_error`側で既に
/// 対応済み）と同様に、`window.on<type>`（`window.onhashchange = fn`等の
/// IDL属性スタイルのハンドラ）が設定されていればそれも合わせて呼び出す。
pub(crate) fn window_dispatch_event(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let event = arg(a, 0);
    let event_type = obj_prop(&event, "type").map(|v| v.to_js_string()).unwrap_or_default();
    let key = match event_type.as_str() {
        "scroll" => "_scroll_listeners",
        "popstate" => "_popstate_listeners",
        "hashchange" => "_hashchange_listeners",
        "resize" => "_resize_listeners",
        "online" => "_online_listeners",
        "offline" => "_offline_listeners",
        "beforeunload" => "_beforeunload_listeners",
        "unload" => "_unload_listeners",
        "pageshow" => "_pageshow_listeners",
        "pagehide" => "_pagehide_listeners",
        "visibilitychange" => "_visibilitychange_listeners",
        "languagechange" => "_languagechange_listeners",
        "storage" => "_storage_listeners",
        "beforeprint" => "_beforeprint_listeners",
        "afterprint" => "_afterprint_listeners",
        "message" => "_message_listeners",
        "error" => "_error_listeners",
        _ => return Ok(Value::Bool(true)),
    };
    let w = match it.global.borrow().vars.get("window") {
        Some(Value::Object(w)) => w.clone(),
        _ => return Ok(Value::Bool(true)),
    };
    // dispatch 対象（`window.dispatchEvent` なら window、`document.dispatchEvent`
    // なら document）を `event.target`/`srcElement`/`currentTarget` に設定する
    // （`event_target_dispatch_event` と同じイディオム。以前はこれらを一切
    // 設定せず、リスナ内で `e.target` を読むと常に `undefined` だった）。
    // `this` が取れない経路では window にフォールバックする。
    let target = if matches!(this, Value::Object(_)) {
        this.clone()
    } else {
        Value::Object(w.clone())
    };
    if let Value::Object(eo) = &event {
        let mut e = eo.borrow_mut();
        e.props.insert("target".into(), target.clone());
        e.props.insert("srcElement".into(), target.clone());
        e.props.insert("currentTarget".into(), target);
        // window/document には DOM ツリーの伝播フェーズが無いため AT_TARGET(2)。
        e.props.insert("eventPhase".into(), Value::Number(2.0));
    }
    let on_handler = w.borrow().props.get(&alloc::format!("on{event_type}")).cloned();
    if let Some(f) = on_handler.and_then(callable_or_none) {
        // `window.onerror` は HTML 仕様上 `GlobalEventHandlers.onerror` として
        // 特別扱いされ、`ErrorEvent` 経由でディスパッチされた場合もレガシー
        // 5引数シグネチャ `(message, source, lineno, colno, error)` で呼ばれる
        // （`reportError()`〔`report_error`〕は既にこの形で呼んでいたが、
        // `window.dispatchEvent(new ErrorEvent(...))`/`document.dispatchEvent
        // (new ErrorEvent(...))` 経由では Event オブジェクトをそのまま1引数で
        // 渡してしまい、2経路で `onerror` の呼び出し形が食い違っていた。
        // 2026-07-16 発見・修正）。
        if event_type == "error" {
            let (message, filename, lineno, colno, err) = if let Value::Object(eo) = &event {
                let b = eo.borrow();
                (
                    b.props.get("message").cloned().unwrap_or_else(|| Value::str("")),
                    b.props.get("filename").cloned().unwrap_or_else(|| Value::str("")),
                    b.props.get("lineno").cloned().unwrap_or(Value::Number(0.0)),
                    b.props.get("colno").cloned().unwrap_or(Value::Number(0.0)),
                    b.props.get("error").cloned().unwrap_or(Value::Null),
                )
            } else {
                (Value::str(""), Value::str(""), Value::Number(0.0), Value::Number(0.0), Value::Null)
            };
            it.call_listener(
                &f,
                Value::Undefined,
                &[message, filename, lineno, colno, err],
                "window.onerror",
            );
        } else {
            it.call_listener(
                &f,
                Value::Undefined,
                core::slice::from_ref(&event),
                "window.onerror",
            );
        }
    }
    let entries = match w.borrow().props.get(key) {
        Some(Value::Object(arr)) => match &arr.borrow().kind {
            ObjKind::Array(items) => items.clone(),
            _ => alloc::vec::Vec::new(),
        },
        _ => alloc::vec::Vec::new(),
    };
    for entry in entries {
        let (cb, signal) = match &entry {
            Value::Object(o) => match &o.borrow().kind {
                ObjKind::Array(items) => (items.first().cloned().unwrap_or(Value::Undefined), items.get(1).cloned()),
                _ => (entry.clone(), None),
            },
            _ => (entry.clone(), None),
        };
        if signal.as_ref().is_some_and(super::super::dom_bridge::is_signal_aborted) {
            continue;
        }
        it.call_listener(
            &cb,
            Value::Undefined,
            core::slice::from_ref(&event),
            "window listener",
        );
    }
    // 発火完了後は仕様どおり `currentTarget: null` / `eventPhase: NONE(0)` へ戻す
    // （`target` は発火後の `event.target` 参照用にそのまま残す）。
    if let Value::Object(eo) = &event {
        let mut e = eo.borrow_mut();
        e.props.insert("currentTarget".into(), Value::Null);
        e.props.insert("eventPhase".into(), Value::Number(0.0));
    }
    // 仕様どおり `!event.defaultPrevented` を返す。以前は無条件 `true` を返して
    // おり、リスナが `preventDefault()` を呼んでも `window.dispatchEvent()`/
    // `document.dispatchEvent()` が常に `true` を返すバグだった（要素用
    // `dom_dispatch_event`/`event_target_dispatch_event` は正しく実装済みで、
    // window/document 経路にだけ同型バグが残っていた）。
    let default_prevented = if let Value::Object(eo) = &event {
        matches!(eo.borrow().props.get("defaultPrevented"), Some(Value::Bool(true)))
    } else {
        false
    };
    Ok(Value::Bool(!default_prevented))
}

/// `document.addEventListener`/`removeEventListener`/`dispatchEvent` が
/// `window` と共有する固定イベント種別の集合（`window_add_event_listener`の
/// match armと同じ）。
fn is_window_shared_event_type(t: &str) -> bool {
    matches!(
        t,
        "load"
            | "DOMContentLoaded"
            | "readystatechange"
            | "scroll"
            | "popstate"
            | "hashchange"
            | "resize"
            | "online"
            | "offline"
            | "beforeunload"
            | "unload"
            | "pageshow"
            | "pagehide"
            | "visibilitychange"
            | "languagechange"
            | "storage"
            | "beforeprint"
            | "afterprint"
            | "message"
            | "error"
    )
}

/// `document.addEventListener(type, fn, options)`。`window` 固有の固定
/// イベント種別（`scroll`/`hashchange`/`error`等）は従来どおり `window`と
/// 共有する隠し配列へ登録するが、それ以外の汎用種別（`click`/`keydown`等）は
/// `document`自身が持つ`EventTarget`風の`_listeners`（`event_target_add_
/// event_listener`と同じ格納形式）へ登録する。実クリック等の実DOMイベント
/// バブリングの最終到達点として`dispatch_event_in_interp`
/// （`interp/calls.rs`）がこちらを読み出す（丸ごと未対応だった。以前は
/// 固定種別以外を`window_add_event_listener`の`_ => {}`アームで黙って
/// 破棄しており、`document.addEventListener('click', fn)`という定番の
/// イベント委譲パターンが登録すら行われず一切機能しなかった。2026-07-16
/// 発見・実装）。
pub(crate) fn document_add_event_listener(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let etype = arg(a, 0).to_js_string();
    if is_window_shared_event_type(&etype) {
        return window_add_event_listener(it, this, a);
    }
    event_target_add_event_listener(it, this, a)
}
/// `document.removeEventListener`。`document_add_event_listener`と対になる
/// 振り分け（丸ごと未対応だった。2026-07-16 発見・実装）。
pub(crate) fn document_remove_event_listener(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let etype = arg(a, 0).to_js_string();
    if is_window_shared_event_type(&etype) {
        return window_remove_event_listener(it, this, a);
    }
    event_target_remove_event_listener(it, this, a)
}
/// `document.dispatchEvent(event)`。JS側から直接`document.dispatchEvent(new
/// Event('click'))`のように合成発火する経路（実クリックのDOMバブリング経由の
/// 到達は`dispatch_event_in_interp`側の別経路）。固定種別以外は`document`
/// 自身をターゲットとして`event_target_dispatch_event`と同じロジックで
/// 発火する（丸ごと未対応だった。2026-07-16 発見・実装）。
pub(crate) fn document_dispatch_event(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let event = arg(a, 0);
    let etype = obj_prop(&event, "type").map(|v| v.to_js_string()).unwrap_or_default();
    if is_window_shared_event_type(&etype) {
        return window_dispatch_event(it, this, a);
    }
    event_target_dispatch_event(it, this, a)
}

/// `element.requestFullscreen()`（Fullscreen API。丸ごと未対応だった）。
/// 実際の画面占有切り替えは行わず、`document.fullscreenElement` を更新する
/// だけの簡略実装（`fullscreenchange` イベントは対象外）。CSS `:fullscreen`
/// 疑似クラス（丸ごと未対応だった。2026-07-18 発見・実装）が対象要素を
/// 判定できるよう、`:indeterminate`の`_indeterminate`と同じ内部専用属性
/// `_fullscreen`もあわせて書き込む。
pub fn dom_request_fullscreen(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        if let Some(Value::Object(doc)) = it.global.borrow().vars.get("document").cloned() {
            doc.borrow_mut().props.insert("fullscreenElement".into(), this.clone());
        }
        it.dom.borrow_mut().set_attr(idx, "_fullscreen", "1");
    }
    Ok(resolved_promise(it, Value::Undefined))
}

/// `document.exitFullscreen()`（対をなす解除メソッド。丸ごと未対応だった）。
pub(crate) fn document_exit_fullscreen(it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(Value::Object(doc)) = it.global.borrow().vars.get("document").cloned() {
        let prev = doc.borrow().props.get("fullscreenElement").cloned();
        if let Some(prev_val) = prev {
            if let Some(idx) = this_dom_idx(&prev_val) {
                it.dom.borrow_mut().remove_attr(idx, "_fullscreen");
            }
        }
        doc.borrow_mut().props.insert("fullscreenElement".into(), Value::Null);
    }
    Ok(resolved_promise(it, Value::Undefined))
}

/// `element.requestPointerLock()`（Pointer Lock API。丸ごと未対応だった）。
/// `requestFullscreen`/`fullscreenElement` と全く同じ「実際のロック/画面占有
/// までは行わず状態のみ追跡する」簡略方針（`pointerlockchange` イベントは
/// 対象外）。
pub fn dom_request_pointer_lock(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if this_dom_idx(&this).is_some() {
        if let Some(Value::Object(doc)) = it.global.borrow().vars.get("document").cloned() {
            doc.borrow_mut().props.insert("pointerLockElement".into(), this.clone());
        }
    }
    Ok(Value::Undefined)
}
/// `document.exitPointerLock()`（対をなす解除メソッド。丸ごと未対応だった）。
pub(crate) fn document_exit_pointer_lock(it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(Value::Object(doc)) = it.global.borrow().vars.get("document").cloned() {
        doc.borrow_mut().props.insert("pointerLockElement".into(), Value::Null);
    }
    Ok(Value::Undefined)
}

/// `<video>` の `.requestPictureInPicture()`（Picture-in-Picture API。丸ごと
/// 未対応だった）。`requestFullscreen`/`requestPointerLock` と全く同じ
/// 「状態のみ追跡する」簡略方針。仕様どおり解決済み Promise（
/// `PictureInPictureWindow` 相当のダミーオブジェクトで解決）を返す。
pub fn dom_request_picture_in_picture(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if this_dom_idx(&this).is_some() {
        if let Some(Value::Object(doc)) = it.global.borrow().vars.get("document").cloned() {
            doc.borrow_mut()
                .props
                .insert("pictureInPictureElement".into(), this.clone());
        }
    }
    Ok(resolved_promise(it, Value::Object(Obj::plain())))
}
/// `document.exitPictureInPicture()`（対をなす解除メソッド。丸ごと未対応
/// だった）。
pub(crate) fn document_exit_picture_in_picture(it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(Value::Object(doc)) = it.global.borrow().vars.get("document").cloned() {
        doc.borrow_mut()
            .props
            .insert("pictureInPictureElement".into(), Value::Null);
    }
    Ok(resolved_promise(it, Value::Undefined))
}

/// `document.createTreeWalker(root, whatToShow?, filter?)`（DOM 標準。
/// 丸ごと未対応だった。DOM 部分木を走査する定番パターン）。`whatToShow`/
/// `filter` は保持のみで実際の絞り込みは行わない簡略実装（`:where()` を
/// `:is()` と同一視するのと同じ「フィルタは常に通過」方針）。
pub(crate) fn document_create_tree_walker(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let root = arg(a, 0);
    let root_idx = this_dom_idx(&root).unwrap_or(0);
    let tw = Obj::plain();
    {
        let mut b = tw.borrow_mut();
        b.props.insert("root".into(), root.clone());
        b.props.insert("currentNode".into(), root);
        b.props.insert("_tw_root".into(), Value::Number(root_idx as f64));
        b.props.insert(
            "whatToShow".into(),
            if a.len() > 1 { arg(a, 1) } else { Value::Number(0xFFFF_FFFFu32 as f64) },
        );
        b.props.insert("filter".into(), arg(a, 2));
        b.props.insert("nextNode".into(), nv("nextNode", tree_walker_next_node));
        b.props.insert("previousNode".into(), nv("previousNode", tree_walker_previous_node));
        b.props.insert("parentNode".into(), nv("parentNode", tree_walker_parent_node));
        b.props.insert("firstChild".into(), nv("firstChild", tree_walker_first_child));
        b.props.insert("lastChild".into(), nv("lastChild", tree_walker_last_child));
        b.props.insert("nextSibling".into(), nv("nextSibling", tree_walker_next_sibling));
        b.props
            .insert("previousSibling".into(), nv("previousSibling", tree_walker_previous_sibling));
    }
    Ok(Value::Object(tw))
}
pub(crate) fn tw_current_idx(this: &Value) -> Option<usize> {
    let Value::Object(o) = this else { return None };
    let cur = o.borrow().props.get("currentNode").cloned();
    cur.and_then(|v| this_dom_idx(&v))
}
pub(crate) fn tw_root_idx(this: &Value) -> Option<usize> {
    let Value::Object(o) = this else { return None };
    o.borrow().props.get("_tw_root").map(|v| v.to_number() as usize)
}
pub(crate) fn tw_set_current(this: &Value, idx: usize) {
    if let Value::Object(o) = this {
        o.borrow_mut().props.insert("currentNode".into(), Value::Object(Obj::dom(idx)));
    }
}
/// 部分木内で最も深い「最後の子孫」（`previousNode` の下降先探索用）。
pub(crate) fn deepest_last_descendant(dom: &super::super::dom_bridge::DomBridge, mut idx: usize) -> usize {
    while let Some(&c) = dom.nodes.get(idx).and_then(|n| n.children.last()) {
        idx = c;
    }
    idx
}
/// `TreeWalker.prototype.nextNode()`。文書順で次のノードへ移動する（`root`
/// を越えない）。
pub(crate) fn tree_walker_next_node(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let root = tw_root_idx(&this).unwrap_or(cur);
    let dom = it.dom.borrow();
    if let Some(&c) = dom.nodes.get(cur).and_then(|n| n.children.first()) {
        drop(dom);
        tw_set_current(&this, c);
        return Ok(Value::Object(Obj::dom(c)));
    }
    let mut node = cur;
    loop {
        if node == root {
            return Ok(Value::Null);
        }
        let Some(p) = dom.nodes.get(node).and_then(|n| n.parent) else {
            return Ok(Value::Null);
        };
        let kids = dom.nodes.get(p).map(|n| n.children.clone()).unwrap_or_default();
        if let Some(pos) = kids.iter().position(|&c| c == node) {
            if let Some(&next) = kids.get(pos + 1) {
                drop(dom);
                tw_set_current(&this, next);
                return Ok(Value::Object(Obj::dom(next)));
            }
        }
        if p == root {
            return Ok(Value::Null);
        }
        node = p;
    }
}
/// `TreeWalker.prototype.previousNode()`。
pub(crate) fn tree_walker_previous_node(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let root = tw_root_idx(&this).unwrap_or(cur);
    if cur == root {
        return Ok(Value::Null);
    }
    let dom = it.dom.borrow();
    let Some(p) = dom.nodes.get(cur).and_then(|n| n.parent) else {
        return Ok(Value::Null);
    };
    let kids = dom.nodes.get(p).map(|n| n.children.clone()).unwrap_or_default();
    let target = match kids.iter().position(|&c| c == cur) {
        Some(pos) if pos > 0 => Some(deepest_last_descendant(&dom, kids[pos - 1])),
        Some(_) => Some(p),
        None => None,
    };
    drop(dom);
    match target {
        Some(t) => {
            tw_set_current(&this, t);
            Ok(Value::Object(Obj::dom(t)))
        }
        None => Ok(Value::Null),
    }
}
/// `TreeWalker.prototype.parentNode()`。
pub(crate) fn tree_walker_parent_node(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let root = tw_root_idx(&this).unwrap_or(cur);
    if cur == root {
        return Ok(Value::Null);
    }
    let parent = it.dom.borrow().nodes.get(cur).and_then(|n| n.parent);
    match parent {
        Some(p) => {
            tw_set_current(&this, p);
            Ok(Value::Object(Obj::dom(p)))
        }
        None => Ok(Value::Null),
    }
}
/// `TreeWalker.prototype.firstChild()`。
pub(crate) fn tree_walker_first_child(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let first = it.dom.borrow().nodes.get(cur).and_then(|n| n.children.first().copied());
    match first {
        Some(c) => {
            tw_set_current(&this, c);
            Ok(Value::Object(Obj::dom(c)))
        }
        None => Ok(Value::Null),
    }
}
/// `TreeWalker.prototype.lastChild()`。
pub(crate) fn tree_walker_last_child(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let last = it.dom.borrow().nodes.get(cur).and_then(|n| n.children.last().copied());
    match last {
        Some(c) => {
            tw_set_current(&this, c);
            Ok(Value::Object(Obj::dom(c)))
        }
        None => Ok(Value::Null),
    }
}
/// `TreeWalker.prototype.nextSibling()`。
pub(crate) fn tree_walker_next_sibling(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let root = tw_root_idx(&this).unwrap_or(cur);
    if cur == root {
        return Ok(Value::Null);
    }
    let dom = it.dom.borrow();
    let Some(p) = dom.nodes.get(cur).and_then(|n| n.parent) else {
        return Ok(Value::Null);
    };
    let kids = dom.nodes.get(p).map(|n| n.children.clone()).unwrap_or_default();
    let target = kids.iter().position(|&c| c == cur).and_then(|pos| kids.get(pos + 1).copied());
    drop(dom);
    match target {
        Some(t) => {
            tw_set_current(&this, t);
            Ok(Value::Object(Obj::dom(t)))
        }
        None => Ok(Value::Null),
    }
}
/// `TreeWalker.prototype.previousSibling()`。
pub(crate) fn tree_walker_previous_sibling(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = tw_current_idx(&this) else { return Ok(Value::Null) };
    let root = tw_root_idx(&this).unwrap_or(cur);
    if cur == root {
        return Ok(Value::Null);
    }
    let dom = it.dom.borrow();
    let Some(p) = dom.nodes.get(cur).and_then(|n| n.parent) else {
        return Ok(Value::Null);
    };
    let kids = dom.nodes.get(p).map(|n| n.children.clone()).unwrap_or_default();
    let target = kids
        .iter()
        .position(|&c| c == cur)
        .filter(|&pos| pos > 0)
        .and_then(|pos| kids.get(pos - 1).copied());
    drop(dom);
    match target {
        Some(t) => {
            tw_set_current(&this, t);
            Ok(Value::Object(Obj::dom(t)))
        }
        None => Ok(Value::Null),
    }
}

/// `document.createNodeIterator(root, whatToShow?, filter?)`。
pub(crate) fn document_create_node_iterator(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let root = arg(a, 0);
    let root_idx = this_dom_idx(&root).unwrap_or(0);
    let ni = Obj::plain();
    {
        let mut b = ni.borrow_mut();
        b.props.insert("root".into(), root.clone());
        b.props.insert("referenceNode".into(), root);
        b.props.insert("pointerBeforeReferenceNode".into(), Value::Bool(true));
        b.props.insert("_ni_root".into(), Value::Number(root_idx as f64));
        b.props.insert(
            "whatToShow".into(),
            if a.len() > 1 { arg(a, 1) } else { Value::Number(0xFFFF_FFFFu32 as f64) },
        );
        b.props.insert("filter".into(), arg(a, 2));
        b.props
            .insert("nextNode".into(), nv("nextNode", node_iterator_next_node));
        b.props.insert(
            "previousNode".into(),
            nv("previousNode", node_iterator_previous_node),
        );
        b.props.insert("detach".into(), nv("detach", dom_noop));
    }
    Ok(Value::Object(ni))
}
pub(crate) fn ni_ref_idx(this: &Value) -> Option<usize> {
    let Value::Object(o) = this else { return None };
    let r = o.borrow().props.get("referenceNode").cloned();
    r.and_then(|v| this_dom_idx(&v))
}
pub(crate) fn ni_root_idx(this: &Value) -> Option<usize> {
    let Value::Object(o) = this else { return None };
    o.borrow()
        .props
        .get("_ni_root")
        .map(|v| v.to_number() as usize)
}
pub(crate) fn ni_pointer_before(this: &Value) -> bool {
    let Value::Object(o) = this else { return false };
    matches!(
        o.borrow().props.get("pointerBeforeReferenceNode"),
        Some(Value::Bool(true))
    )
}
pub(crate) fn ni_set_state(this: &Value, idx: usize, before: bool) {
    if let Value::Object(o) = this {
        let mut b = o.borrow_mut();
        b.props
            .insert("referenceNode".into(), Value::Object(Obj::dom(idx)));
        b.props
            .insert("pointerBeforeReferenceNode".into(), Value::Bool(before));
    }
}
/// pre-order で `idx` の次のノード（`root` 部分木の範囲内）。
pub(crate) fn node_iterator_step_next(
    dom: &super::super::dom_bridge::DomBridge,
    root: usize,
    idx: usize,
) -> Option<usize> {
    if let Some(&c) = dom.nodes.get(idx).and_then(|n| n.children.first()) {
        return Some(c);
    }
    let mut node = idx;
    loop {
        if node == root {
            return None;
        }
        let p = dom.nodes.get(node).and_then(|n| n.parent)?;
        let kids = dom
            .nodes
            .get(p)
            .map(|n| n.children.clone())
            .unwrap_or_default();
        if let Some(pos) = kids.iter().position(|&c| c == node) {
            if let Some(&next) = kids.get(pos + 1) {
                return Some(next);
            }
        }
        if p == root {
            return None;
        }
        node = p;
    }
}
/// `NodeIterator.prototype.nextNode()`。
pub(crate) fn node_iterator_next_node(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(cur) = ni_ref_idx(&this) else {
        return Ok(Value::Null);
    };
    let root = ni_root_idx(&this).unwrap_or(cur);
    if ni_pointer_before(&this) {
        ni_set_state(&this, cur, false);
        return Ok(Value::Object(Obj::dom(cur)));
    }
    let dom = it.dom.borrow();
    let next = node_iterator_step_next(&dom, root, cur);
    drop(dom);
    match next {
        Some(n) => {
            ni_set_state(&this, n, false);
            Ok(Value::Object(Obj::dom(n)))
        }
        None => Ok(Value::Null),
    }
}
/// `NodeIterator.prototype.previousNode()`。
pub(crate) fn node_iterator_previous_node(
    it: &mut Interp,
    this: Value,
    _a: &[Value],
) -> Result<Value, Value> {
    let Some(cur) = ni_ref_idx(&this) else {
        return Ok(Value::Null);
    };
    let root = ni_root_idx(&this).unwrap_or(cur);
    if !ni_pointer_before(&this) {
        ni_set_state(&this, cur, true);
        return Ok(Value::Object(Obj::dom(cur)));
    }
    if cur == root {
        return Ok(Value::Null);
    }
    let dom = it.dom.borrow();
    let Some(p) = dom.nodes.get(cur).and_then(|n| n.parent) else {
        return Ok(Value::Null);
    };
    let kids = dom
        .nodes
        .get(p)
        .map(|n| n.children.clone())
        .unwrap_or_default();
    let target = match kids.iter().position(|&c| c == cur) {
        Some(pos) if pos > 0 => Some(deepest_last_descendant(&dom, kids[pos - 1])),
        Some(_) => Some(p),
        None => None,
    };
    drop(dom);
    match target {
        Some(t) => {
            ni_set_state(&this, t, true);
            Ok(Value::Object(Obj::dom(t)))
        }
        None => Ok(Value::Null),
    }
}

/// `document.hasStorageAccess()`（Storage Access API。丸ごと未対応
/// だった）。この処理系にはサードパーティ Cookie 分離/ブロック機構自体が
/// 無くストレージは常にアクセス可能なため、常に `true` を返す簡略実装。
pub(crate) fn document_has_storage_access(it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(resolved_promise(it, Value::Bool(true)))
}
/// `document.requestStorageAccess()`（対をなす要求メソッド。丸ごと未対応
/// だった）。理由は `hasStorageAccess` と同じで、常に成功を返す。
pub(crate) fn document_request_storage_access(it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(resolved_promise(it, Value::Undefined))
}

/// `screen.orientation.lock(orientation)`（Screen Orientation API。丸ごと
/// 未対応だった）。実際にディスプレイの向きを固定する機構は無いため、
/// `fullscreenElement` 等と同じ「要求された値へ `type` を書き換えるだけ」の
/// 簡略実装。
pub(crate) fn screen_orientation_lock(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        o.borrow_mut().props.insert("type".into(), Value::str(arg(a, 0).to_js_string()));
    }
    Ok(resolved_promise(it, Value::Undefined))
}
/// `screen.orientation.unlock()`（対をなす解除メソッド。丸ごと未対応
/// だった）。現在のビューポート寸法から求めた自然な向きへ `type` を戻す
/// （`window.screen` 初期化時の判定ロジックと同じ）。
pub(crate) fn screen_orientation_unlock(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let vw = super::super::super::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let vh = super::super::super::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        let otype = if vw >= vh { "landscape-primary" } else { "portrait-primary" };
        o.borrow_mut().props.insert("type".into(), Value::str(otype));
    }
    Ok(Value::Undefined)
}

/// `window.postMessage(data, targetOrigin)`（丸ごと未対応だった）。詳細は
/// `window.props.insert("postMessage", ...)` 箇所のコメント参照。
pub(crate) fn window_post_message(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let data = structured_clone(it, Value::Undefined, a)?;
    let href = location_href(&it.global).unwrap_or_default();
    let origin = location_components(&href)
        .into_iter()
        .find(|(k, _)| *k == "origin")
        .map(|(_, v)| v)
        .unwrap_or_default();
    let ev = Obj::plain();
    ev.borrow_mut().props.insert("type".into(), Value::str("message"));
    ev.borrow_mut().props.insert("data".into(), data);
    ev.borrow_mut().props.insert("origin".into(), Value::str(origin));
    ev.borrow_mut().props.insert("source".into(), Value::Null);
    let listeners = match it.global.borrow().vars.get("window") {
        Some(Value::Object(w)) => w.borrow().props.get("_message_listeners").cloned(),
        _ => None,
    };
    if let Some(Value::Object(arr)) = listeners {
        let entries: Vec<Value> = match &arr.borrow().kind {
            ObjKind::Array(items) => items.clone(),
            _ => Vec::new(),
        };
        for entry in entries {
            if window_listener_aborted(&entry) {
                continue;
            }
            let cb = event_target_listener_cb(&entry);
            it.call_listener(
                &cb,
                Value::Undefined,
                &[Value::Object(ev.clone())],
                "window listener",
            );
        }
    }
    Ok(Value::Undefined)
}

/// `reportError(error)`（丸ごと未対応だった。未捕捉例外と同じ経路で
/// `window.onerror`（レガシー5引数シグネチャ）/
/// `window.addEventListener('error', fn)`（ErrorEvent 風オブジェクト）へ
/// 同期的に通知する。仕様上のイベントループ経由の非同期報告・
/// `event.preventDefault()` によるコンソール抑制は簡略化し、常に
/// `console.error` へも出力する）。
pub(crate) fn report_error(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let err = arg(a, 0);
    let message = if let Value::Object(o) = &err {
        o.borrow()
            .props
            .get("message")
            .map(|v| v.to_js_string())
            .unwrap_or_else(|| err.to_js_string())
    } else {
        err.to_js_string()
    };
    let _ = console_log(it, Value::Undefined, &[Value::str(&message)]);
    let ev = Obj::plain();
    {
        let mut e = ev.borrow_mut();
        e.props.insert("type".into(), Value::str("error"));
        e.props.insert("message".into(), Value::str(&message));
        e.props.insert("error".into(), err.clone());
        e.props.insert("filename".into(), Value::str(""));
        e.props.insert("lineno".into(), Value::Number(0.0));
        e.props.insert("colno".into(), Value::Number(0.0));
    }
    let window = match it.global.borrow().vars.get("window") {
        Some(Value::Object(w)) => Some(w.clone()),
        _ => None,
    };
    if let Some(w) = &window {
        let onerror = w.borrow().props.get("onerror").cloned();
        if let Some(f) = onerror.and_then(callable_or_none) {
            it.call_listener(
                &f,
                Value::Undefined,
                &[
                    Value::str(&message),
                    Value::str(""),
                    Value::Number(0.0),
                    Value::Number(0.0),
                    err.clone(),
                ],
                "window.onerror",
            );
        }
        let listeners = w.borrow().props.get("_error_listeners").cloned();
        if let Some(Value::Object(arr)) = listeners {
            let entries: Vec<Value> = match &arr.borrow().kind {
                ObjKind::Array(items) => items.clone(),
                _ => Vec::new(),
            };
            for entry in entries {
                if window_listener_aborted(&entry) {
                    continue;
                }
                let cb = event_target_listener_cb(&entry);
                it.call_listener(
                &cb,
                Value::Undefined,
                &[Value::Object(ev.clone())],
                "window listener",
            );
            }
        }
    }
    Ok(Value::Undefined)
}

/// `AbortSignal` 用の既定の中断理由（`DOMException("AbortError")` の簡易近似）。
pub(crate) fn make_abort_error() -> Value {
    make_dom_exception("AbortError", "signal is aborted without reason")
}
/// `new DOMException(message?, name?)`。仕様どおり既定値は `message=""`/
/// `name="Error"`。
pub(crate) fn dom_exception_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let message = match arg(a, 0) {
        Value::Undefined => String::new(),
        v => v.to_js_string(),
    };
    let name = match arg(a, 1) {
        Value::Undefined => String::from("Error"),
        v => v.to_js_string(),
    };
    Ok(make_dom_exception(&name, &message))
}
/// `name` から DOM Level 4 のレガシー数値定数（`err.code`）を引く。未知の
/// 名前は仕様どおり `0`。
pub(crate) fn dom_exception_legacy_code(name: &str) -> f64 {
    match name {
        "IndexSizeError" => 1.0,
        "HierarchyRequestError" => 3.0,
        "WrongDocumentError" => 4.0,
        "InvalidCharacterError" => 5.0,
        "NoModificationAllowedError" => 7.0,
        "NotFoundError" => 8.0,
        "NotSupportedError" => 9.0,
        "InUseAttributeError" => 10.0,
        "InvalidStateError" => 11.0,
        "SyntaxError" => 12.0,
        "InvalidModificationError" => 13.0,
        "NamespaceError" => 14.0,
        "InvalidAccessError" => 15.0,
        "SecurityError" => 18.0,
        "NetworkError" => 19.0,
        "AbortError" => 20.0,
        "TimeoutError" => 23.0,
        "DataCloneError" => 25.0,
        _ => 0.0,
    }
}
/// `DOMException` インスタンスを構築する共通ヘルパー。`AbortController.
/// abort()` 等、エンジン内部で例外を作る箇所からも再利用する（詳細は
/// `dom_exception_ctor` 参照）。
pub(crate) fn make_dom_exception(name: &str, message: &str) -> Value {
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("name".into(), Value::str(name));
        b.props.insert("message".into(), Value::str(message));
        b.props
            .insert("code".into(), Value::Number(dom_exception_legacy_code(name)));
        b.props.insert("toString".into(), nv("toString", dom_exception_to_string));
    }
    Value::Object(o)
}
pub(crate) fn dom_exception_to_string(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let b = o.borrow();
        let name = b.props.get("name").map(|v| v.to_js_string()).unwrap_or_default();
        let message = b.props.get("message").map(|v| v.to_js_string()).unwrap_or_default();
        return Ok(Value::str(if message.is_empty() {
            name
        } else {
            alloc::format!("{}: {}", name, message)
        }));
    }
    Ok(Value::str("DOMException"))
}
/// `controller.abort(reason?)`。以前は `signal.aborted` を立てるだけで、(1) 既に中断済み
/// の場合の二重発火防止、(2) 仕様どおりの `signal.reason`、(3) `signal.addEventListener
/// ('abort', fn)`/`signal.onabort` によるコールバック通知、のいずれも欠けていた
/// （`addEventListener` 自体が単なる no-op だったため、`abort()` を呼んでも登録した
/// リスナが一切発火しないサイレントなバグ）。
pub(crate) fn abort_controller_abort(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let sig = o.borrow().props.get("signal").cloned();
        if let Some(Value::Object(s)) = sig {
            let already_aborted = matches!(s.borrow().props.get("aborted"), Some(Value::Bool(true)));
            if already_aborted {
                return Ok(Value::Undefined);
            }
            let reason = match arg(a, 0) {
                Value::Undefined => make_abort_error(),
                r => r,
            };
            {
                let mut b = s.borrow_mut();
                b.props.insert("aborted".into(), Value::Bool(true));
                b.props.insert("reason".into(), reason);
            }
            let cb = s.borrow().props.get("onabort").cloned();
            if let Some(f) = cb.and_then(callable_or_none) {
                it.call_listener(&f, Value::Object(s.clone()), &[], "AbortSignal onabort");
            }
        }
    }
    Ok(Value::Undefined)
}
/// `signal.addEventListener('abort', fn)`。以前は無条件 no-op で、リスナが一切
/// 保持/発火されなかった。他の `EventTarget` 風オブジェクト（XHR 等）と同じ
/// 「`on<type>` プロパティへ格納する単一リスナ」簡略方式で対応する。
pub(crate) fn abort_signal_add_event_listener(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        o.borrow_mut()
            .props
            .insert(format!("on{}", arg(a, 0).to_js_string()), arg(a, 1));
    }
    Ok(Value::Undefined)
}
/// `signal.removeEventListener('abort', fn)`。`addEventListener` は実装済みなのに
/// 対をなす削除側が無条件 no-op のままだったバグ（登録したリスナを外すつもりが
/// 何も起きず、後から `abort()` すると外したはずのリスナがまだ発火する）。
/// 「`on<type>` に単一リスナを格納する」既存の簡略方式に合わせ、渡された関数が
/// 現在登録済みのものと同一参照の場合のみ消す（別の関数参照を渡した場合は
/// 仕様どおり no-op のまま）。
pub(crate) fn abort_signal_remove_event_listener(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let key = format!("on{}", arg(a, 0).to_js_string());
        let target = arg(a, 1);
        let matches = match (o.borrow().props.get(&key), &target) {
            (Some(Value::Object(stored)), Value::Object(t)) => Rc::ptr_eq(stored, t),
            _ => false,
        };
        if matches {
            o.borrow_mut().props.shift_remove(&key);
        }
    }
    Ok(Value::Undefined)
}
pub(crate) fn abort_controller_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let signal = Obj::plain();
    {
        let mut s = signal.borrow_mut();
        s.props.insert("aborted".into(), Value::Bool(false));
        s.props.insert("reason".into(), Value::Undefined);
        s.props.insert(
            "addEventListener".into(),
            nv("addEventListener", abort_signal_add_event_listener),
        );
        s.props.insert(
            "removeEventListener".into(),
            nv("removeEventListener", abort_signal_remove_event_listener),
        );
        s.props.insert(
            "throwIfAborted".into(),
            nv("throwIfAborted", abort_signal_throw_if_aborted),
        );
    }
    let ctrl = Obj::plain();
    {
        let mut c = ctrl.borrow_mut();
        c.props.insert("signal".into(), Value::Object(signal));
        c.props
            .insert("abort".into(), nv("abort", abort_controller_abort));
    }
    Ok(Value::Object(ctrl))
}
/// `signal.throwIfAborted()`（ES2022/DOM。既に中断済みなら `reason` を投げ、
/// そうでなければ何もしない、fetch 等のループ内チェックで頻出のイディオム）が
/// 丸ごと未対応だった。`AbortSignal.timeout()`/`.any()` は内部で
/// `new AbortController()` を経由するため、`abort_controller_ctor`/
/// `abort_signal_abort_static` の2箇所にさえ追加すれば全生成経路をカバーする。
pub(crate) fn abort_signal_throw_if_aborted(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let aborted = matches!(o.borrow().props.get("aborted"), Some(Value::Bool(true)));
        if aborted {
            let reason = o.borrow().props.get("reason").cloned().unwrap_or(Value::Undefined);
            return Err(reason);
        }
    }
    Ok(Value::Undefined)
}
/// `AbortSignal.abort(reason?)`（ES2022）。既に中断済みの状態で signal を返す
/// 静的ファクトリ。`AbortController` を経由せず即座に中断済み signal が欲しい
/// 場合（引数バリデーション失敗時の早期中断等）に使われる。
pub(crate) fn abort_signal_abort_static(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let signal = Obj::plain();
    {
        let mut s = signal.borrow_mut();
        s.props.insert("aborted".into(), Value::Bool(true));
        let reason = match arg(a, 0) {
            Value::Undefined => make_abort_error(),
            r => r,
        };
        s.props.insert("reason".into(), reason);
        s.props.insert(
            "addEventListener".into(),
            nv("addEventListener", abort_signal_add_event_listener),
        );
        s.props.insert(
            "removeEventListener".into(),
            nv("removeEventListener", abort_signal_remove_event_listener),
        );
        s.props.insert(
            "throwIfAborted".into(),
            nv("throwIfAborted", abort_signal_throw_if_aborted),
        );
    }
    Ok(Value::Object(signal))
}
/// `AbortSignal.timeout(ms)`（ES2022）。指定ミリ秒後に自動的に abort する
/// AbortSignal を返す、fetch のタイムアウト実装で最頻出のイディオム。この
/// エンジンの `setTimeout` は実時間を計測せずマクロタスクキューに積むだけの
/// 簡略実装のため、正確な実時間待機ではなくキュー順序に従った近似になる
/// （既存の `setTimeout` 全体の簡略化と同じ水準）。ネイティブ関数はクロージャで
/// `ms` を束縛できないため、`AbortController`/`setTimeout` を組み合わせる
/// JS ソースを組み立てて `eval_source` で実行する。
/// `AbortSignal.timeout(ms)`。以前は `c.abort()` を引数無しで呼んでおり、
/// `signal.reason` が仕様どおりの `TimeoutError`（DOM Level 4 legacy code
/// 23）ではなく既定の `AbortError`（code 20）になっていたバグ。
/// `abort_signal_any` と同じ「グローバル一時変数経由で Rust 側の値を JS へ
/// 渡す」パターンで、事前に構築した `TimeoutError` の `DOMException` を
/// 束縛してから `c.abort(reason)` を呼ぶ。
pub(crate) fn abort_signal_timeout(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let ms = arg(a, 0).to_number();
    let reason = make_dom_exception("TimeoutError", "signal timed out");
    it.global
        .borrow_mut()
        .vars
        .insert("__abort_signal_timeout_reason".into(), reason);
    let src = alloc::format!(
        "(function(){{ var c = new AbortController(); var r = __abort_signal_timeout_reason; \
         setTimeout(function(){{ c.abort(r); }}, {}); return c.signal; }})()",
        ms
    );
    let result = it.eval_source(&src);
    it.global.borrow_mut().vars.remove("__abort_signal_timeout_reason");
    result
}
/// `AbortSignal.any(iterable)`（ES2024）。渡した signal 群のいずれかが中断された
/// 時点で中断される合成 signal を返す（複数の中断条件を1つの signal にまとめる
/// 定番パターン）。既存の `addEventListener('abort', fn)` は「`on<type>` に単一
/// リスナを格納する」簡略実装のため、入力 signal 側に別のリスナが既に登録済みだと
/// 上書きしてしまう制約がある（この処理系の EventTarget 系オブジェクト全般に
/// 共通の既知の簡略化）。`abort_signal_timeout` と同じ理由（ネイティブ関数は
/// クロージャで値を束縛できない）で、入力配列をグローバルの一時変数経由で
/// 渡した上で `eval_source` に組み立てた JS を実行する。
pub(crate) fn abort_signal_any(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let signals = it.iter_to_vec(&arg(a, 0));
    it.global
        .borrow_mut()
        .vars
        .insert("__abort_signal_any_input".into(), Value::Object(Obj::array(signals)));
    let src = "(function(){ \
        var c = new AbortController(); \
        var arr = __abort_signal_any_input; \
        for (var i = 0; i < arr.length; i++) { \
            if (arr[i].aborted) { c.abort(arr[i].reason); return c.signal; } \
        } \
        for (var i = 0; i < arr.length; i++) { \
            (function(s){ \
                s.addEventListener('abort', function(){ if (!c.signal.aborted) c.abort(s.reason); }); \
            })(arr[i]); \
        } \
        return c.signal; \
    })()";
    let result = it.eval_source(src);
    it.global.borrow_mut().vars.remove("__abort_signal_any_input");
    result
}