atmos/os_lib/js/builtins/

static_classlist.rs

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

// ===== String / Array 静的 =====
/// `String.fromCharCode(...codes)`（ES1）が `String.fromCodePoint`（ES2015）と全く同じ
/// 実装を共有しており、2つのバグがあった。(1) 各引数を 16bit コード単位へマスクしておらず、
/// 仕様上 `fromCharCode(0x1F600)` は単一の UTF-16 コード単位（`0xF600` 相当）になるべき
/// ところ絵文字そのものになっていた。(2) サロゲートペア（`fromCharCode(0xD83D,0xDE00)` で
/// 絵文字1文字を表す ES1 以来の定番イディオム）を一切結合しておらず、個々の値は単独では
/// 無効な Unicode スカラー値のため `char::from_u32` が `None` を返し無音で消えていた。
/// UTF-16 コード単位列として正しくデコードする（`String::from_utf16_lossy` がサロゲート
/// ペアの結合を担う）ことで両方解消する。
pub(crate) fn string_from_char_code(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let units: Vec<u16> = a
        .iter()
        .map(|v| (v.to_number() as i64 as u32 & 0xFFFF) as u16)
        .collect();
    Ok(Value::str(String::from_utf16_lossy(&units)))
}
/// `String.fromCodePoint(...codePoints)`（ES2015）。`fromCharCode` と異なり各引数は
/// フルの Unicode コードポイント（〜0x10FFFF）で、16bit マスクやサロゲートペア結合は
/// 行わない。不正なコードポイントは仕様どおり `RangeError` 相当の例外にする。
pub(crate) fn string_from_code_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut s = String::new();
    for v in a {
        let n = v.to_number();
        if !n.is_finite() || n < 0.0 || n > 0x10FFFF as f64 || libm::floor(n) != n {
            return Err(it.error("Invalid code point"));
        }
        match char::from_u32(n as u32) {
            Some(c) => s.push(c),
            None => return Err(it.error("Invalid code point")),
        }
    }
    Ok(Value::str(s))
}
pub(crate) fn array_of(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Object(Obj::array(a.to_vec())))
}
/// `String.raw({raw: [...]}, ...substitutions)`（ES2015）。タグ付きテンプレートの
/// `` String.raw`a\nb${x}c` `` で使う定番の組込みタグ関数。`raw` 配列の要素を
/// エスケープ解決せずそのまま連結し、間に `substitutions` を挟む。
pub(crate) fn string_raw(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let strings = arg(a, 0);
    let raw = it.get_property(&strings, "raw").unwrap_or(Value::Undefined);
    let raw_items: Vec<Value> = match &raw {
        Value::Object(o) => match &o.borrow().kind {
            ObjKind::Array(items) => items.clone(),
            _ => Vec::new(),
        },
        _ => Vec::new(),
    };
    let mut out = String::new();
    for (i, r) in raw_items.iter().enumerate() {
        out.push_str(&r.to_js_string());
        if let Some(sub) = a.get(i + 1) {
            out.push_str(&sub.to_js_string());
        }
    }
    Ok(Value::str(out))
}

// ===== classList 追加（item / value / toString）=====
pub fn dom_classlist_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let i = arg(a, 0).to_number() as usize;
        let cls = it
            .dom
            .borrow()
            .nodes
            .get(idx)
            .and_then(|n| n.classes.get(i).cloned());
        return Ok(match cls {
            Some(c) => Value::str(c),
            None => Value::Null,
        });
    }
    Ok(Value::Null)
}
pub fn dom_classlist_to_string(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        return Ok(Value::str(
            it.dom
                .borrow()
                .nodes
                .get(idx)
                .map(|n| n.classes.join(" "))
                .unwrap_or_default(),
        ));
    }
    Ok(Value::str(""))
}

/// グローバルの location オブジェクトの各成分を url から更新する（メソッドは保持）。
pub fn update_location(global: &Rc<RefCell<Scope>>, url: &str) {
    let loc = match global.borrow().vars.get("location") {
        Some(Value::Object(o)) => o.clone(),
        _ => return,
    };
    let mut b = loc.borrow_mut();
    for (k, v) in location_components(url) {
        b.props.insert(String::from(k), Value::str(v));
    }
}

/// 相対URLを base（現在ページの絶対URL）基準で解決する。
/// 絶対(http/https)・`data:` はそのまま。`/...` は scheme+host 直下、その他はディレクトリ相対。
/// `string_slice` lint 回避のため split_once / str::get のみ使用。
/// パスセグメントの `.`/`..` を解決する（`RFC 3986 §5.2.4` の簡略版）。
/// 以前は `resolve_url` がディレクトリ相対結合のみで `.`/`..` をそのまま
/// 文字列結合していたため、`new URL('../style.css', 'https://h.com/a/b/c')`
/// のような（相対URLで最も頻繁に使われる）親ディレクトリ参照が
/// `https://h.com/a/b/../style.css` のように未解決のまま残るバグだった。
pub(crate) fn normalize_dot_segments(path: &str) -> String {
    let mut segs: alloc::vec::Vec<&str> = alloc::vec::Vec::new();
    for seg in path.split('/') {
        match seg {
            "" | "." => {}
            ".." => {
                segs.pop();
            }
            s => segs.push(s),
        }
    }
    alloc::format!("/{}", segs.join("/"))
}

pub fn resolve_url(base: &str, url: &str) -> String {
    if url.starts_with("http://") || url.starts_with("https://") || url.starts_with("data:") {
        return String::from(url);
    }
    // スキームを持つ URL（RFC 3986: ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) ":"）は絶対 URL。
    // 【2026-10-17】従来は http/https/data 以外（`blob:`・`mailto:`・`about:` 等）を相対パスとして
    // ベースに連結しており、`video.src = URL.createObjectURL(ms)` の読み出しが
    // `http://host/blob:mediasource-…` に化けていた。
    if let Some((scheme, _)) = url.split_once(':') {
        let mut cs = scheme.chars();
        if cs.next().is_some_and(|c| c.is_ascii_alphabetic())
            && cs.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
            && !scheme.contains('/')
        {
            return String::from(url);
        }
    }
    // プロトコル相対URL（`//host/path`。`<script src="//cdn.example.com/x.js">`
    // 等の定番パターン）が丸ごと未対応で、ベースのホスト配下の相対パスとして
    // 誤解決されるバグだった（`//cdn.example.com/x.js` が本来
    // `https://cdn.example.com/x.js`（別ホスト）になるべきところ、
    // `https://e.com/cdn.example.com/x.js`（元のホスト配下のパス）という
    // 壊れた結果になっていた）。ベースのスキームを引き継ぎ、残りをそのまま
    // ホスト+パスとして使う。
    if let Some(rest) = url.strip_prefix("//") {
        let scheme = if base.starts_with("https://") { "https://" } else { "http://" };
        return alloc::format!("{scheme}{rest}");
    }
    let (scheme, after) = if let Some(a) = base.strip_prefix("https://") {
        ("https://", a)
    } else if let Some(a) = base.strip_prefix("http://") {
        ("http://", a)
    } else {
        return String::from(url); // base が使えない → そのまま（後段でエラー判定）
    };
    let (host, path) = match after.split_once('/') {
        Some((h, p)) => (h, p), // p は先頭スラッシュ無しのパス
        None => (after, ""),
    };
    // クエリのみ（`?x=2`）/フラグメントのみ（`#frag`）の相対参照は、仕様上
    // ベースのパス（`?` のみの場合はクエリより前の部分）を保持したまま該当
    // 部分だけ置き換える必要があるが、以前は他の相対パスと同じ「ディレクトリ
    // 相対」ロジックに落ちてベースのパスの最後のセグメント（ファイル名）ごと
    // 消えてしまうバグだった（`new URL('?x=2', 'https://e.com/a/b?x=1').href`
    // が `https://e.com/a/?x=2` という `b` の消えた壊れた結果になっていた）。
    if let Some(rest) = url.strip_prefix('?') {
        let base_path = path.split('?').next().unwrap_or("").split('#').next().unwrap_or("");
        return alloc::format!("{scheme}{host}/{base_path}?{rest}");
    }
    if let Some(rest) = url.strip_prefix('#') {
        let base_path_and_query = path.split('#').next().unwrap_or("");
        return alloc::format!("{scheme}{host}/{base_path_and_query}#{rest}");
    }
    let raw_path = if let Some(rooted) = url.strip_prefix('/') {
        alloc::format!("/{rooted}")
    } else {
        // ディレクトリ相対: path の最後のセグメント（ファイル名）を捨てる。
        let dir = match path.rfind('/') {
            Some(i) => path.get(..i).unwrap_or(""),
            None => "",
        };
        if dir.is_empty() {
            alloc::format!("/{url}")
        } else {
            alloc::format!("/{dir}/{url}")
        }
    };
    alloc::format!("{scheme}{host}{}", normalize_dot_segments(&raw_path))
}

/// 同期 HTTP リクエストの共通処理。(status, body) を返す。`data:` と `http(s):` 対応（fetch/XHR 共有）。
/// `base` が非空なら相対URLを解決。method は GET/POST/PUT/DELETE/PATCH/HEAD 等を任意に通す
/// （web_request 内で英大文字トークン検証）。
pub(crate) fn do_http_request(
    base: &str,
    url: &str,
    method: &str,
    body: &str,
    content_type: &str,
) -> Result<(u16, String), &'static str> {
    do_http_request_raw(base, url, method, body.as_bytes(), content_type, &[]).map(|(s, b, _)| (s, b))
}

/// fetch/XHR の本文をバイト列にする。文字列は UTF-8、TypedArray・ArrayBuffer・DataView・Blob は
/// その中身のバイト列、FormData/URLSearchParams は `k=v&…`、それ以外は文字列化。
/// 【2026-10-17】従来は常に文字列化しており、YouTube player の gzip 圧縮した要求本文
/// （Uint8Array）が "31,139,8,…" という文字列で送られ 400 になっていた。
pub(crate) fn body_to_bytes(v: &Value) -> Vec<u8> {
    match v {
        Value::Undefined | Value::Null => Vec::new(),
        Value::Str(s) => s.as_bytes().to_vec(),
        Value::Object(o) => {
            let (is_binary, ta_bytes) = {
                let b = o.borrow();
                let ta = b.props.get("BYTES_PER_ELEMENT").map(|v| v.to_number() as usize).filter(|_| b.props.contains_key("_ta_kind"));
                let kind = b.props.get("_ta_kind").map(|v| v.to_js_string()).unwrap_or_default();
                let binary = ta.is_some()
                    || b.props.contains_key("_blob_bytes")
                    || b.props.contains_key("_bytes")
                    || b.props.contains_key("_dv_bytes");
                (binary, ta.map(|n| (n, kind)))
            };
            if !is_binary {
                if o.borrow().props.contains_key("_query") {
                    return body_to_string(v).into_bytes();
                }
                return v.to_js_string().into_bytes();
            }
            if let Some((n, kind)) = ta_bytes {
                if n > 1 {
                    // 要素をリトルエンディアンのバイト列に（Float32/Float64 は IEEE 754）。
                    let mut out = Vec::new();
                    if let ObjKind::Array(items) = &o.borrow().kind {
                        for x in items {
                            let f = x.to_number();
                            match (kind.as_str(), n) {
                                ("Float32Array", _) => out.extend_from_slice(&(f as f32).to_le_bytes()),
                                ("Float64Array", _) => out.extend_from_slice(&f.to_le_bytes()),
                                (_, 2) => out.extend_from_slice(&(f as i64 as u16).to_le_bytes()),
                                (_, 4) => out.extend_from_slice(&(f as i64 as u32).to_le_bytes()),
                                _ => out.extend_from_slice(&(f as i64 as u64).to_le_bytes()),
                            }
                        }
                    }
                    return out;
                }
            }
            let mut f = Vec::new();
            super::typed_array::blob_part_bytes(v, &mut f);
            f.into_iter().map(|x| x as i64 as u8).collect()
        }
        other => other.to_js_string().into_bytes(),
    }
}

/// 送ってよい要求ヘッダか（fetch 仕様の禁止ヘッダ・改行を含むものは除く）。
fn request_header_allowed(name: &str, value: &str) -> bool {
    const FORBIDDEN: &[&str] = &[
        "host", "content-length", "connection", "accept-encoding", "accept-charset", "cookie", "cookie2",
        "date", "dnt", "expect", "keep-alive", "origin", "referer", "te", "trailer", "transfer-encoding",
        "upgrade", "via", "content-type", "user-agent",
    ];
    let n = name.trim();
    !n.is_empty()
        && n.bytes().all(|c| c.is_ascii_graphic() && c != b':')
        && !value.bytes().any(|c| c == b'\r' || c == b'\n')
        && !FORBIDDEN.iter().any(|f| n.eq_ignore_ascii_case(f))
        && !n.to_ascii_lowercase().starts_with("proxy-")
        && !n.to_ascii_lowercase().starts_with("sec-")
}

/// `do_http_request` の本文の生バイト列付き版（バイナリ応答の fetch/XHR 用）。
pub(crate) fn do_http_request_raw(
    base: &str,
    url: &str,
    method: &str,
    body: &[u8],
    content_type: &str,
    headers: &[(String, String)],
) -> Result<(u16, String, Vec<u8>), &'static str> {
    do_http_request_full(base, url, method, body, content_type, headers).map(|(s, b, raw, _)| (s, b, raw))
}

/// `do_http_request_raw` の応答ヘッダ付き版。ページの URL（`base`）から `Origin`（GET/HEAD 以外）と
/// 参照元ポリシーに沿った `Referer` を付ける（ブラウザと同じ）。
pub(crate) fn do_http_request_full(
    base: &str,
    url: &str,
    method: &str,
    body: &[u8],
    content_type: &str,
    headers: &[(String, String)],
) -> Result<(u16, String, Vec<u8>, alloc::collections::BTreeMap<String, String>), &'static str> {
    let resolved = resolve_url(base, url);
    if resolved.starts_with("data:") {
        return match data_url_body(&resolved) {
            Some(b) => {
                let bytes = b.as_bytes().to_vec();
                Ok((200, b, bytes, alloc::collections::BTreeMap::new()))
            }
            None => Err("malformed data URL"),
        };
    }
    let (is_https, host, path) = match split_http_url(&resolved) {
        Some(t) => t,
        None => return Err("only absolute http(s) and data URLs are supported"),
    };
    let stack = crate::kernel::net_stack::TcpIpStack::new();
    // ページ（`base`）の origin と参照元。
    let mut hdrs: Vec<(String, String)> = headers
        .iter()
        .filter(|(k, v)| request_header_allowed(k, v))
        .cloned()
        .collect();
    if let Some((b_https, b_host, b_path)) = split_http_url(base) {
        let m = method.to_ascii_uppercase();
        if m != "GET" && m != "HEAD" {
            hdrs.push((String::from("Origin"), format!("{}://{}", if b_https { "https" } else { "http" }, b_host)));
        }
        if let Some(r) = crate::os_lib::web_engine::referrer::referrer_for(b_https, &b_host, &b_path, is_https, &host) {
            hdrs.push((String::from("Referer"), r));
        }
    }
    let hdr_refs: Vec<(&str, &str)> = hdrs.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
    match stack.web_request(
        is_https,
        &host,
        &path,
        method,
        content_type,
        body,
        &hdr_refs,
    ) {
        Ok(resp) => {
            if resp.status_code >= 400 {
                crate::warn!(
                    "[XHR] HTTP {} {} {}: {}",
                    resp.status_code,
                    method,
                    resolved.chars().take(120).collect::<String>(),
                    String::from_utf8_lossy(&resp.body_bytes).chars().take(200).collect::<String>().replace('\n', " ")
                );
            }
            // 途中で切れた応答を記録する（Content-Length より本文が短い）。150KB の
            // papers.json が切れると jQuery の JSON 解析が黙って失敗し、論文リストが出ない。
            let declared = resp
                .headers
                .iter()
                .find(|(k, _)| k.eq_ignore_ascii_case("content-length"))
                .and_then(|(_, v)| v.trim().parse::<usize>().ok());
            if let Some(len) = declared {
                if resp.body.len() < len {
                    crate::warn!("[XHR] 途中切れ url={} 受信={} Content-Length={}", resolved, resp.body.len(), len);
                }
            }
            Ok((resp.status_code, resp.body, resp.body_bytes, resp.headers))
        }
        Err(_) => Err("network error"),
    }
}

/// Value::Object のプロパティを取得（非オブジェクトは None）。
pub(crate) fn obj_prop(v: &Value, key: &str) -> Option<Value> {
    if let Value::Object(o) = v {
        o.borrow().props.get(key).cloned()
    } else {
        None
    }
}

/// `Headers`（Fetch API。`new Headers(init)`/`response.headers.get(...)` という
/// 定番パターンで使われる get/set/has/append/delete 付きの専用クラス）が丸ごと
/// 未対応で、`headers` は単なるプレーンオブジェクトとしてしか扱えなかった。
/// ヘッダ名は仕様どおり大小無視・小文字正規化して格納する（プロパティキー自体を
/// 小文字化したヘッダ名として使う。メソッド名 "get"/"set" 等と衝突するヘッダ名
/// は理論上あり得るが実用上まず出現しないため簡略化として許容する）。
pub(crate) fn headers_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(make_headers(arg(a, 0)))
}
/// `headers_ctor` の実体（`Interp` を必要としないため `response.headers` の
/// 生成箇所からも直接呼べる）。
pub(crate) fn make_headers(init: Value) -> Value {
    let o = Obj::plain();
    // init: 別の Headers（`_is_headers` マーカーで判別）/ プレーンオブジェクト /
    // `[[k,v], ...]` 形式の配列、のいずれも受け付ける。
    if let Value::Object(io) = &init {
        let is_headers_like = io.borrow().props.contains_key("_is_headers");
        let is_array = matches!(&io.borrow().kind, ObjKind::Array(_));
        if is_array {
            if let ObjKind::Array(items) = &io.borrow().kind {
                for pair in items {
                    if let Value::Object(p) = pair {
                        if let ObjKind::Array(kv) = &p.borrow().kind {
                            if kv.len() >= 2 {
                                let k = kv[0].to_js_string().to_lowercase();
                                o.borrow_mut().props.insert(k, Value::str(kv[1].to_js_string()));
                            }
                        }
                    }
                }
            }
        } else {
            let entries: Vec<(String, Value)> =
                io.borrow().props.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
            for (k, v) in entries {
                // Headers 自身のメソッドプロパティ（callable）は値としてコピーしない。
                if matches!(&v, Value::Object(f) if f.borrow().is_callable()) {
                    continue;
                }
                let key = k.to_lowercase();
                o.borrow_mut().props.insert(key, Value::str(v.to_js_string()));
            }
            let _ = is_headers_like;
        }
    }
    {
        let mut b = o.borrow_mut();
        b.props.insert("_is_headers".into(), Value::Bool(true));
        b.props.insert("get".into(), nv("get", headers_get));
        b.props.insert("set".into(), nv("set", headers_set));
        b.props.insert("append".into(), nv("append", headers_append));
        b.props.insert("has".into(), nv("has", headers_has));
        b.props.insert("delete".into(), nv("delete", headers_delete));
        b.props
            .insert("forEach".into(), nv("forEach", headers_for_each));
        // `entries`/`keys`/`values`/`Symbol.iterator`（`for (const [k,v] of headers)`
        // という定番イディオムを含む）が丸ごと未対応だった。
        b.props.insert("entries".into(), nv("entries", headers_entries));
        b.props.insert("keys".into(), nv("keys", headers_keys));
        b.props.insert("values".into(), nv("values", headers_values));
        b.props.insert(
            "getSetCookie".into(),
            nv("getSetCookie", headers_get_set_cookie),
        );
        b.props.insert(
            "Symbol(Symbol.iterator)".into(),
            nv("[Symbol.iterator]", headers_entries),
        );
    }
    Value::Object(o)
}
pub(crate) fn headers_key(a: &[Value]) -> String {
    arg(a, 0).to_js_string().to_lowercase()
}
pub(crate) fn headers_get_set_cookie(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        if let Some(v) = o.borrow().props.get("set-cookie") {
            if !matches!(v, Value::Object(f) if f.borrow().is_callable()) {
                let val_str = v.to_js_string();
                if !val_str.is_empty() {
                    let cookies: Vec<Value> = val_str
                        .split(", ")
                        .map(|s| Value::str(s.to_string()))
                        .collect();
                    return Ok(Value::Object(Obj::array(cookies)));
                }
            }
        }
    }
    Ok(Value::Object(Obj::array(Vec::new())))
}
/// `Headers` の実データ（メソッド/内部マーカーを除いた header 名/値）を、仕様どおり
/// 名前順にソートして返す（`forEach`/`entries`/`keys`/`values`/`Symbol.iterator`
/// が共有する）。
pub(crate) fn headers_entries_sorted(this: &Value) -> Vec<(String, String)> {
    let mut entries: Vec<(String, String)> = match this {
        Value::Object(o) => o
            .borrow()
            .props
            .iter()
            .filter(|(k, v)| {
                k.as_str() != "_is_headers" && !matches!(v, Value::Object(f) if f.borrow().is_callable())
            })
            .map(|(k, v)| (k.clone(), v.to_js_string()))
            .collect(),
        _ => Vec::new(),
    };
    entries.sort_by(|a, b| a.0.cmp(&b.0));
    entries
}
pub(crate) fn headers_get(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        if let Some(v) = o.borrow().props.get(&headers_key(a)) {
            if !matches!(v, Value::Object(f) if f.borrow().is_callable()) {
                return Ok(v.clone());
            }
        }
    }
    Ok(Value::Null)
}
pub(crate) fn headers_set(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        o.borrow_mut()
            .props
            .insert(headers_key(a), Value::str(arg(a, 1).to_js_string()));
    }
    Ok(Value::Undefined)
}
/// `append(name, value)`。既存値があれば `", "` 区切りで連結する（仕様どおり
/// 複数値ヘッダのコンマ結合表現。`set-cookie` 等の例外は非対応）。
pub(crate) fn headers_append(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let key = headers_key(a);
        let v = arg(a, 1).to_js_string();
        let existing = o.borrow().props.get(&key).map(|v| v.to_js_string());
        let merged = match existing {
            Some(e) if !e.is_empty() => alloc::format!("{}, {}", e, v),
            _ => v,
        };
        o.borrow_mut().props.insert(key, Value::str(merged));
    }
    Ok(Value::Undefined)
}
pub(crate) fn headers_has(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let key = headers_key(a);
        let has = matches!(o.borrow().props.get(&key), Some(v) if !matches!(v, Value::Object(f) if f.borrow().is_callable()));
        return Ok(Value::Bool(has));
    }
    Ok(Value::Bool(false))
}
pub(crate) fn headers_delete(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        o.borrow_mut().props.shift_remove(&headers_key(a));
    }
    Ok(Value::Undefined)
}
pub(crate) fn headers_for_each(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let cb = arg(a, 0);
    for (k, v) in headers_entries_sorted(&this) {
        it.call_value(&cb, Value::Undefined, &[Value::str(v), Value::str(k), this.clone()])?;
    }
    Ok(Value::Undefined)
}
/// `headers.entries()`/`for (const [k,v] of headers)`（`Symbol.iterator` は
/// `entries()` と同義）が丸ごと未対応だった。
pub(crate) fn headers_entries(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = headers_entries_sorted(&this)
        .into_iter()
        .map(|(k, v)| Value::Object(Obj::array(alloc::vec![Value::str(k), Value::str(v)])))
        .collect();
    Ok(Value::Object(make_iterator(items)))
}
pub(crate) fn headers_keys(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = headers_entries_sorted(&this)
        .into_iter()
        .map(|(k, _)| Value::str(k))
        .collect();
    Ok(Value::Object(make_iterator(items)))
}
pub(crate) fn headers_values(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = headers_entries_sorted(&this)
        .into_iter()
        .map(|(_, v)| Value::str(v))
        .collect();
    Ok(Value::Object(make_iterator(items)))
}

/// headers オブジェクトから Content-Type を大小無視で探す。
/// Headers オブジェクト（または素のオブジェクト）を `(名前, 値)` の列にする（内部の `_` 始まり・関数は除く）。
pub(crate) fn headers_list(headers: &Value) -> Vec<(String, String)> {
    let mut out = Vec::new();
    if let Value::Object(o) = headers {
        for (k, val) in o.borrow().props.iter() {
            if k.starts_with('_') || matches!(val, Value::Object(f) if f.borrow().is_callable()) {
                continue;
            }
            out.push((k.clone(), val.to_js_string()));
        }
    }
    out
}

pub(crate) fn headers_content_type(headers: &Value) -> Option<String> {
    if let Value::Object(o) = headers {
        for (k, val) in o.borrow().props.iter() {
            if k.eq_ignore_ascii_case("content-type") {
                return Some(val.to_js_string());
            }
        }
    }
    None
}

/// fetch/XHR の body 値を文字列化する。FormData / URLSearchParams は内部 `_query`
/// （"k=v&k=v"）をそのまま送信本文に使う。それ以外は通常の文字列化。
pub(crate) fn body_to_string(v: &Value) -> String {
    if let Value::Object(o) = v {
        let b = o.borrow();
        if let Some(q) = b.props.get("_query") {
            return q.to_js_string();
        }
        // 【2026-10-03】Blob は中身のバイト列を本文にする（従来は "[object Object]" を送っていた。
        // sendBeacon(url, new Blob([json], {type:"application/json"})) の定番形）。
        if let Some(Value::Object(arr)) = b.props.get("_blob_bytes") {
            if let ObjKind::Array(items) = &arr.borrow().kind {
                let bytes: alloc::vec::Vec<u8> = items
                    .iter()
                    .map(|x| match x {
                        Value::Number(n) => *n as u8,
                        _ => 0,
                    })
                    .collect();
                return String::from_utf8_lossy(&bytes).into_owned();
            }
        }
    }
    v.to_js_string()
}

/// `new Request(input, options?)`（Fetch API。`fetch(new Request(url, opts))` という
/// 定番パターンで使われる）が丸ごと未対応で `Request is not defined` になっていた。
/// `input` は URL 文字列、または別の `Request`（`.url`/`.method` 等をコピーする
/// clone 的な使い方）のどちらも受け付ける。
pub(crate) fn request_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let input = arg(a, 0);
    let opts = arg(a, 1);
    let is_request_like = matches!(&input, Value::Object(o) if o.borrow().props.contains_key("url"));
    let url = if is_request_like {
        let u = obj_prop(&input, "url").unwrap_or(Value::Undefined);
        it.to_string_value(u)?
    } else {
        // ToString（利用者定義の toString。YouTube は URL を包んだオブジェクトを渡す）。
        it.to_string_value(input.clone())?
    };
    let method = obj_prop(&opts, "method")
        .or_else(|| if is_request_like { obj_prop(&input, "method") } else { None })
        .map(|v| v.to_js_string())
        .unwrap_or_else(|| String::from("GET"));
    // 本文は元の値のまま持つ（TypedArray 等のバイナリを `fetch` がバイト列で送れるように）。
    // 【2026-10-17】従来は生成時に文字列化しており、YouTube の gzip 本文が "31,139,8,…" になっていた。
    let body = obj_prop(&opts, "body")
        .or_else(|| if is_request_like { obj_prop(&input, "_body") } else { None })
        .map(|v| match v {
            Value::Object(_) | Value::Str(_) => v,
            Value::Undefined | Value::Null => Value::str(""),
            other => Value::str(other.to_js_string()),
        })
        .unwrap_or_else(|| Value::str(""));
    // `request.headers` が仕様上は常に本物の `Headers` インスタンス（未指定でも
    // 空の `Headers`）であるべきところ、渡された生の値（プレーンオブジェクト/
    // `undefined`）をそのまま格納するだけで、`request.headers.get(...)` が
    // 「関数ではない」になるバグだった。
    let headers_raw = obj_prop(&opts, "headers")
        .or_else(|| if is_request_like { obj_prop(&input, "headers") } else { None })
        .unwrap_or(Value::Undefined);
    let headers = make_headers(headers_raw);
    let signal = obj_prop(&opts, "signal")
        .or_else(|| if is_request_like { obj_prop(&input, "signal") } else { None })
        .unwrap_or(Value::Undefined);
    let req = Obj::plain();
    {
        let mut r = req.borrow_mut();
        r.props.insert("url".into(), Value::str(url.clone()));
        r.props.insert("method".into(), Value::str(method.clone()));
        // 内部スロット（`url`/`method` を JS が getter に差し替えても、fetch は元の値を使う）。
        // 【2026-10-20】YouTube の改ざん検査（ha3）は data: の Request の url を getter に替えて
        // fetch し、本物の fetch が data: を読むことを確かめる。
        r.props.insert("_req_url".into(), Value::str(url));
        r.props.insert("_req_method".into(), Value::str(method));
        r.props.insert("_body".into(), body);
        r.props.insert("headers".into(), headers);
        r.props.insert("signal".into(), signal);
    }
    Ok(Value::Object(req))
}

/// `navigator.sendBeacon(url, data)`（丸ごと未対応だった。ページ離脱時の
/// 計測データ送信に使われる定番パターン）。この処理系の HTTP は同期実行の
/// ため、仕様上の「ページ破棄後も配送を継続する」非同期性の恩恵は無いが、
/// 既存の `fetch()` と同じ POST 経路（同じ body/content-type 推論）を通して
/// その場で送信し、常に成功（`true`）を返す簡略実装。戻り値の Promise は
/// 仕様どおり呼び出し元へ返さないため破棄する。
pub(crate) fn navigator_send_beacon(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let url = arg(a, 0).to_js_string();
    let data = arg(a, 1);
    // 【2026-10-03】送信は背景スレッドで行い、ここではキューに積むだけにする。
    // 従来は `fetch()`（この処理系では同期通信）をその場で呼んでおり、Cloudflare の
    // アクセス解析（beacon.min.js）の送信が終わるまで**ページの描画が止まった**。
    // 通信路の不調で応答が来ないと、sugi-lab.net/papers.htm が「Loading」のまま固まった。
    // sendBeacon は仕様上も「送りっぱなし」（結果を返さない）なので背景送信で足りる。
    let resolved = resolve_url(&it.base_url, &url);
    if resolved.starts_with("data:") {
        return Ok(Value::Bool(true));
    }
    let body = if matches!(data, Value::Undefined) { String::new() } else { body_to_string(&data) };
    let content_type = match &data {
        Value::Object(o) => o
            .borrow()
            .props
            .get("type")
            .map(|v| v.to_js_string())
            .filter(|t| !t.is_empty())
            .unwrap_or_else(|| String::from("text/plain;charset=UTF-8")),
        _ => String::from("text/plain;charset=UTF-8"),
    };
    BEACON_QUEUE.lock().push_back((resolved, body, content_type));
    if !BEACON_WORKER.swap(true, core::sync::atomic::Ordering::AcqRel) {
        let pid = crate::kernel::scheduler::spawn(
            beacon_thread,
            crate::kernel::scheduler::Priority::Low,
            "beacon",
        );
        if pid == 0 {
            // 起こせなかった（ヒープ不足）。次の sendBeacon で再挑戦する。
            BEACON_WORKER.store(false, core::sync::atomic::Ordering::Release);
        }
    }
    Ok(Value::Bool(true))
}

/// sendBeacon の送信待ち（解決済み URL, 本文, Content-Type）。
static BEACON_QUEUE: spin::Mutex<alloc::collections::VecDeque<(String, String, String)>> =
    spin::Mutex::new(alloc::collections::VecDeque::new());
/// 送信スレッドが動いているか。
static BEACON_WORKER: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);

/// sendBeacon の背景送信スレッド。キューが空になったら終わる。
fn beacon_thread() {
    loop {
        let job = BEACON_QUEUE.lock().pop_front();
        match job {
            Some((url, body, content_type)) => {
                match do_http_request("", &url, "POST", &body, &content_type) {
                    Ok((status, _)) => crate::debug!("[BEACON] sent status={} url={}", status, url),
                    Err(e) => crate::warn!("[BEACON] 送信失敗 url={} err={}", url, e),
                }
                crate::kernel::scheduler::yield_now();
            }
            None => {
                BEACON_WORKER.store(false, core::sync::atomic::Ordering::Release);
                // 終える直前に積まれたぶんがあれば、自分で続ける。
                if BEACON_QUEUE.lock().is_empty()
                    || BEACON_WORKER.swap(true, core::sync::atomic::Ordering::AcqRel)
                {
                    return;
                }
            }
        }
    }
}

/// `GeolocationPositionError` 相当のオブジェクトを組み立てる（`code`/`message`/
/// `PERMISSION_DENIED`/`POSITION_UNAVAILABLE`/`TIMEOUT` 定数。仕様どおり
/// インスタンスにも static 同名定数が生えている）。
pub(crate) fn make_geolocation_error() -> Value {
    let o = Obj::plain();
    let mut b = o.borrow_mut();
    b.props.insert("code".into(), Value::Number(1.0));
    b.props.insert(
        "message".into(),
        Value::str("Geolocation is not supported in this environment"),
    );
    b.props.insert("PERMISSION_DENIED".into(), Value::Number(1.0));
    b.props.insert("POSITION_UNAVAILABLE".into(), Value::Number(2.0));
    b.props.insert("TIMEOUT".into(), Value::Number(3.0));
    drop(b);
    Value::Object(o)
}
/// `navigator.geolocation.getCurrentPosition(success, error, options)`（丸ごと
/// 未対応だった）。この処理系には位置情報を提供する手段が一切無いため、常に
/// `error` を `PERMISSION_DENIED` で同期的に呼ぶ簡略実装（`success` は永遠に
/// 呼ばれない）。
pub(crate) fn geolocation_get_current_position(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(err_cb) = callable_or_none(arg(a, 1)) {
        it.call_listener(
            &err_cb,
            Value::Undefined,
            &[make_geolocation_error()],
            "geolocation error callback",
        );
    }
    Ok(Value::Undefined)
}
/// `navigator.geolocation.watchPosition(success, error, options)`。継続監視の
/// 概念が無いためワンショットの `getCurrentPosition` と同じ即時エラー通知の
/// みだが、`clearWatch` と対にするための一意な id は仕様どおり返す。
pub(crate) fn geolocation_watch_position(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    geolocation_get_current_position(it, this, a)?;
    Ok(Value::Number(TIMER_ID.fetch_add(1, Ordering::Relaxed) as f64))
}
/// `navigator.geolocation.clearWatch(id)`。監視自体が実在しないため no-op。
pub(crate) fn geolocation_clear_watch(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}
/// `navigator.permissions.query({name})`（丸ごと未対応だった）。`PermissionStatus`
/// 相当の `{state, name, onchange}` を解決済み Promise で返す。実プロンプト UI が
/// 無いため、他 API の実装状況と整合する固定値のみを返す簡略実装。
pub(crate) fn permissions_query(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let name = obj_prop(&arg(a, 0), "name").map(|v| v.to_js_string()).unwrap_or_default();
    let state = match name.as_str() {
        "geolocation" | "camera" | "microphone" => "denied",
        "notifications" => "granted",
        _ => "prompt",
    };
    let status = Obj::plain();
    {
        let mut b = status.borrow_mut();
        b.props.insert("state".into(), Value::str(state));
        b.props.insert("name".into(), Value::str(name));
        b.props.insert("onchange".into(), Value::Null);
    }
    Ok(resolved_promise(it, Value::Object(status)))
}

/// `navigator.wakeLock.request(type)`（Screen Wake Lock API。丸ごと未対応
/// だった）。実際の電源管理機構は無いため、`WakeLockSentinel` 相当の
/// `{released, type, release()}` を状態のみ追跡する簡略実装で返す。
pub(crate) fn wake_lock_request(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let ty = arg(a, 0).to_js_string();
    let ty = if ty.is_empty() { String::from("screen") } else { ty };
    let sentinel = Obj::plain();
    {
        let mut b = sentinel.borrow_mut();
        b.props.insert("released".into(), Value::Bool(false));
        b.props.insert("type".into(), Value::str(ty));
        b.props
            .insert("release".into(), nv("WakeLockSentinel.release", wake_lock_sentinel_release));
    }
    Ok(resolved_promise(it, Value::Object(sentinel)))
}
/// `WakeLockSentinel.prototype.release()`（対をなす解放メソッド）。
pub(crate) fn wake_lock_sentinel_release(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        o.borrow_mut().props.insert("released".into(), Value::Bool(true));
    }
    Ok(resolved_promise(it, Value::Undefined))
}

/// `navigator.canShare(data)`（Web Share API。丸ごと未対応だった）。実際の
/// 共有先 UI が無くいかなる `data` も共有できないため、仕様上の「対応不明」
/// を意味する誠実な `false` を常に返す簡略実装。
pub(crate) fn navigator_can_share(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(false))
}
/// `navigator.share(data)`（Web Share API。丸ごと未対応だった）。実際の
/// 共有先 UI が無いため、ユーザーがネイティブ共有シートを閉じた場合と同じ
/// 仕様どおりの `AbortError` で常に拒否する（成功を偽装しない）。
pub(crate) fn navigator_share(it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let err = Obj::plain();
    {
        let mut b = err.borrow_mut();
        b.props.insert("name".into(), Value::str("AbortError"));
        b.props.insert(
            "message".into(),
            Value::str("Share was cancelled: no share target available in this environment"),
        );
    }
    Ok(rejected_promise(it, Value::Object(err)))
}

/// `new EyeDropper()`（丸ごと未対応だった）。`.open()` メソッドのみを持つ
/// オブジェクトを返す。
pub(crate) fn eye_dropper_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let o = Obj::plain();
    o.borrow_mut().props.insert("open".into(), nv("EyeDropper.open", eye_dropper_open));
    Ok(Value::Object(o))
}
/// `EyeDropper.prototype.open()`。実際のピッカー UI が無いため、ユーザーが
/// ピッカーをキャンセルした場合と同じ仕様どおりの `AbortError` で常に拒否
/// する（色を拾えていないのに成功を偽装しない）。
pub(crate) fn eye_dropper_open(it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    let err = Obj::plain();
    {
        let mut b = err.borrow_mut();
        b.props.insert("name".into(), Value::str("AbortError"));
        b.props.insert(
            "message".into(),
            Value::str("The color picker was cancelled: no picker UI available in this environment"),
        );
    }
    Ok(rejected_promise(it, Value::Object(err)))
}

/// `navigator.vibrate(pattern)`（Vibration API。丸ごと未対応だった）。仕様上
/// 戻り値は「リクエストを受理したか」のみを表しハードウェアの有無とは無関係
/// なため、常に `true` を返す簡略実装（実際に振動は発生しない）。
pub(crate) fn navigator_vibrate(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(true))
}

/// `navigator.getBattery()`（Battery Status API。丸ごと未対応だった）。この
/// OS のターゲット（Raspberry Pi）はバッテリー非搭載で常時 AC 電源動作の
/// ため、「常時満充電で給電中」を返す簡略実装（`levelchange` 等のイベントは
/// 対象外）。
/// `navigator.locks.request(name, options?, callback)`（Web Locks API。丸ごと
/// 未対応だった）。`options` は省略可能なため、実際に呼び出し可能な最後の
/// 引数をコールバックとして扱う。コールバックへ渡す `Lock` は仕様の必須
/// プロパティ（`name`/`mode`）のみを持つ簡略オブジェクト。
pub(crate) fn navigator_locks_request(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let cb = if matches!(arg(a, 2), Value::Object(o) if o.borrow().is_callable()) {
        arg(a, 2)
    } else {
        arg(a, 1)
    };
    let name = arg(a, 0).to_js_string();
    let lock = Obj::plain();
    {
        let mut b = lock.borrow_mut();
        b.props.insert("name".into(), Value::str(name));
        b.props.insert("mode".into(), Value::str("exclusive"));
    }
    let result = it.call_value(&cb, Value::Undefined, &[Value::Object(lock)])?;
    Ok(resolved_promise(it, result))
}
/// `navigator.locks.query()`。実際の排他状態を追跡していないため、保持中/
/// 待機中とも常に空のスナップショットを返す。
pub(crate) fn navigator_locks_query(it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("held".into(), Value::Object(Obj::array(alloc::vec![])));
        b.props.insert("pending".into(), Value::Object(Obj::array(alloc::vec![])));
    }
    Ok(resolved_promise(it, Value::Object(o)))
}
pub(crate) fn navigator_get_battery(it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let battery = Obj::plain();
    {
        let mut b = battery.borrow_mut();
        b.props.insert("charging".into(), Value::Bool(true));
        b.props.insert("chargingTime".into(), Value::Number(0.0));
        b.props.insert("dischargingTime".into(), Value::Number(f64::INFINITY));
        b.props.insert("level".into(), Value::Number(1.0));
        b.props
            .insert("addEventListener".into(), nv("addEventListener", dom_noop));
        b.props
            .insert("removeEventListener".into(), nv("removeEventListener", dom_noop));
    }
    Ok(resolved_promise(it, Value::Object(battery)))
}

/// fetch(url|Request, options?): options.method/body/headers に対応（GET/POST）。
/// AtmOS の HTTP は同期なので、その場で取得し解決済み Promise を返す。
pub(crate) fn fetch(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let first = arg(a, 0);
    // `fetch(new Request(url, opts))`（URL 文字列を渡す通常形と並ぶもう一方の
    // 定番の呼び出し形）が丸ごと未対応で、`Request` オブジェクトを渡すと
    // `to_js_string()` が `[object Object]` になり不正な URL 扱いになっていた。
    let is_request_like = matches!(&first, Value::Object(o) if o.borrow().props.contains_key("url") || o.borrow().props.contains_key("_req_url"));
    let url = if let Some(u) = obj_prop(&first, "_req_url") {
        u.to_js_string()
    } else if is_request_like {
        let u = obj_prop(&first, "url").unwrap_or(Value::Undefined);
        it.to_string_value(u)?
    } else {
        it.to_string_value(first.clone())?
    };
    let opts = arg(a, 1);
    let method = obj_prop(&opts, "method")
        .or_else(|| if is_request_like { obj_prop(&first, "_req_method").or_else(|| obj_prop(&first, "method")) } else { None })
        .map(|v| v.to_js_string())
        .unwrap_or_else(|| String::from("GET"));
    let body = obj_prop(&opts, "body")
        .or_else(|| if is_request_like { obj_prop(&first, "_body") } else { None })
        .map(|v| body_to_bytes(&v))
        .unwrap_or_default();
    let headers = obj_prop(&opts, "headers")
        .or_else(|| if is_request_like { obj_prop(&first, "headers") } else { None })
        .unwrap_or(Value::Undefined);
    let content_type =
        headers_content_type(&headers).unwrap_or_else(|| String::from("text/plain;charset=UTF-8"));
    // `fetch(url, {signal})` が丸ごと未対応で、`AbortSignal` を渡しても一切見ずに
    // 常にリクエストを実行してしまっていた。この処理系の HTTP は同期実行のため
    // 「実行中に中断する」ことはできないが、仕様どおり「呼び出し時点で既に
    // aborted な signal なら即座に AbortError で reject し、実際のリクエストは
    // 一切送らない」チェックは実装できる（`fetch` 前のバリデーション失敗を
    // `AbortSignal.abort()` で早期中断する定番パターンとも整合する）。
    let signal_opt = obj_prop(&opts, "signal")
        .or_else(|| if is_request_like { obj_prop(&first, "signal") } else { None });
    if let Some(signal) = signal_opt {
        let already_aborted = matches!(&signal, Value::Object(o) if matches!(o.borrow().props.get("aborted"), Some(Value::Bool(true))));
        if already_aborted {
            let reason = match &signal {
                Value::Object(o) => o.borrow().props.get("reason").cloned().unwrap_or(Value::Undefined),
                _ => Value::Undefined,
            };
            return Ok(rejected_promise(it, reason));
        }
    }
    let base = it.base_url.clone();
    let resolved_url = resolve_url(&base, &url);
    let req_headers = headers_list(&headers);
    match do_http_request_raw(&base, &url, &method, &body, &content_type, &req_headers) {
        Ok((status, body, bytes)) => {
            let resp = make_response_with_url(status, body, resolved_url);
            attach_raw_body(&resp, &bytes);
            // `response.body` はバイト列のストリーム（Uint8Array のチャンク）。
            let stream = super::streams::make_readable_stream_from_bytes(it, &bytes);
            if let Value::Object(r) = &resp {
                r.borrow_mut().props.insert("body".into(), stream);
            }
            Ok(resolved_promise(it, resp))
        }
        Err(msg) => Ok(rejected_promise(it, it.error(format!("fetch: {}", msg)))),
    }
}

/// XMLHttpRequest: AtmOS の HTTP は同期なので send() で即取得し readyState=4 まで進め、
/// onreadystatechange → onload(またはonerror) を同期発火する。
pub(crate) fn xhr_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("readyState".into(), Value::Number(0.0));
        b.props.insert("status".into(), Value::Number(0.0));
        b.props.insert("statusText".into(), Value::str(""));
        b.props.insert("responseText".into(), Value::str(""));
        b.props.insert("response".into(), Value::str(""));
        b.props.insert("open".into(), nv("open", xhr_open));
        b.props.insert("send".into(), nv("send", xhr_send));
        b.props.insert(
            "setRequestHeader".into(),
            nv("setRequestHeader", xhr_set_request_header),
        );
        b.props.insert("abort".into(), nv("abort", xhr_noop));
        b.props.insert(
            "getAllResponseHeaders".into(),
            nv("getAllResponseHeaders", xhr_get_all_response_headers),
        );
        // `getResponseHeader(name)` が丸ごと未対応で「関数ではない」の TypeError
        // になっていた。`getAllResponseHeaders` と同じ理由（この処理系の HTTP
        // クライアントは応答ヘッダを捕捉していない）で常に `null`（仕様上、該当
        // ヘッダが無い場合の戻り値）を返す。
        b.props.insert(
            "getResponseHeader".into(),
            nv("getResponseHeader", xhr_get_response_header),
        );
        b.props.insert(
            "addEventListener".into(),
            nv("addEventListener", xhr_add_event_listener),
        );
        // `removeEventListener` が丸ごと未対応で、`xhr.removeEventListener(...)`
        // が「関数ではない」という TypeError になっていた（`AbortSignal` の
        // 対応済みリスナ削除と同じパターンで対応する）。
        b.props.insert(
            "removeEventListener".into(),
            nv("removeEventListener", xhr_remove_event_listener),
        );
    }
    Ok(Value::Object(o))
}

pub(crate) fn xhr_noop(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}

/// setRequestHeader(name, value): Content-Type のみ保持（POST のボディ送信に使用）。
pub(crate) fn xhr_set_request_header(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let name = arg(a, 0).to_js_string();
        let value = arg(a, 1).to_js_string();
        if name.eq_ignore_ascii_case("content-type") {
            o.borrow_mut().props.insert("_content_type".into(), Value::str(value));
        } else {
            // 【2026-10-17】Content-Type 以外も送る（YouTube の X-Goog-Visitor-Id・Content-Encoding 等）。
            let hdrs = o.borrow().props.get("_req_headers").cloned();
            let hdrs = match hdrs {
                Some(Value::Object(h)) => h,
                _ => {
                    let h = Obj::plain();
                    o.borrow_mut().props.insert("_req_headers".into(), Value::Object(h.clone()));
                    h
                }
            };
            hdrs.borrow_mut().props.insert(name, Value::str(value));
        }
    }
    Ok(Value::Undefined)
}

pub(crate) fn xhr_empty_str(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(""))
}
pub(crate) fn xhr_get_response_header(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string().to_ascii_lowercase();
    if let Value::Object(o) = &this {
        if let Some(Value::Object(h)) = o.borrow().props.get("_resp_headers") {
            for (k, v) in h.borrow().props.iter() {
                if k.to_ascii_lowercase() == name {
                    return Ok(v.clone());
                }
            }
        }
    }
    Ok(Value::Null)
}

/// `getAllResponseHeaders()`（`name: value\r\n` の並び、名前は小文字）。
pub(crate) fn xhr_get_all_response_headers(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let mut out = String::new();
    if let Value::Object(o) = &this {
        if let Some(Value::Object(h)) = o.borrow().props.get("_resp_headers") {
            for (k, v) in h.borrow().props.iter() {
                out.push_str(&k.to_ascii_lowercase());
                out.push_str(": ");
                out.push_str(&v.to_js_string());
                out.push_str("\r\n");
            }
        }
    }
    Ok(Value::str(out))
}

/// addEventListener(type, fn) を on<type> プロパティへ写像（最後の登録が有効）。
pub(crate) fn xhr_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)
}
/// removeEventListener(type, fn)。`AbortSignal` と同じ「`on<type>` に単一リスナを
/// 格納する」簡略方式に合わせ、渡された関数が現在登録済みのものと同一参照の場合
/// のみ削除する。
pub(crate) fn xhr_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 xhr_open(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    // URL は ToString（利用者定義の toString。TrustedResourceUrl 等）。
    let url = it.to_string_value(arg(a, 1))?;
    if let Value::Object(o) = &this {
        let mut b = o.borrow_mut();
        b.props
            .insert("_method".into(), Value::str(arg(a, 0).to_js_string()));
        b.props
            .insert("_url".into(), Value::str(url));
        b.props.insert("readyState".into(), Value::Number(1.0));
    }
    Ok(Value::Undefined)
}

pub(crate) fn xhr_send(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let o = match &this {
        Value::Object(o) => o.clone(),
        _ => return Ok(Value::Undefined),
    };
    let (url, method, content_type) = {
        let b = o.borrow();
        (
            b.props
                .get("_url")
                .map(|v| v.to_js_string())
                .unwrap_or_default(),
            b.props
                .get("_method")
                .map(|v| v.to_js_string())
                .unwrap_or_else(|| String::from("GET")),
            b.props
                .get("_content_type")
                .map(|v| v.to_js_string())
                .unwrap_or_else(|| String::from("text/plain;charset=UTF-8")),
        )
    };
    // send(body): undefined/null は空ボディ。TypedArray 等はバイト列のまま送る（`body_to_bytes`）。
    let req_body = body_to_bytes(&arg(a, 0));
    let req_headers = headers_list(&o.borrow().props.get("_req_headers").cloned().unwrap_or(Value::Undefined));
    let base = it.base_url.clone();
    let (status, body, ok, raw, resp_headers) = match do_http_request_full(&base, &url, &method, &req_body, &content_type, &req_headers) {
        Ok((s, b, raw, h)) => (s, b, true, raw, h),
        Err(e) => {
            // 失敗理由を捨てない。従来は `Err(_)` で握り潰しており、
            // 取得が失敗しても `status=0` になるだけで原因が残らなかった。
            crate::warn!("[XHR] 取得失敗 url={:?} 理由={}", url, e);
            (0u16, String::new(), false, Vec::new(), alloc::collections::BTreeMap::new())
        }
    };
    {
        let h = Obj::plain();
        for (k, v) in resp_headers {
            h.borrow_mut().props.insert(k, Value::str(v));
        }
        o.borrow_mut().props.insert("_resp_headers".into(), Value::Object(h));
    }
    // responseType（XHR Level 2）。'arraybuffer'/'blob' は生バイト列から作る（YouTube 等の
    // メディアセグメント取得）。従来は常に文字列で、バイナリが UTF-8 置換で壊れていた。
    let response_type = o.borrow().props.get("responseType").map(|v| v.to_js_string()).unwrap_or_default();
    {
        let mut b = o.borrow_mut();
        b.props
            .insert("status".into(), Value::Number(status as f64));
        // `statusText` はコンストラクタで空文字列に初期化されたきり、`send()` 完了後も
        // 一切更新されないバグだった（`Response.prototype.statusText` と同種の欠落。
        // `xhr.status`/`xhr.statusText` を併記するエラーログの定番パターンで参照される）。
        b.props
            .insert("statusText".into(), Value::str(http_status_text(status)));
        b.props
            .insert("responseText".into(), Value::str(body.clone()));
        let response = match response_type.as_str() {
            "arraybuffer" => super::typed_array::make_arraybuffer_with_bytes(raw.iter().map(|&x| x as f64).collect()),
            "blob" => super::typed_array::make_blob(raw.iter().map(|&x| x as f64).collect(), String::new()),
            _ => Value::str(body),
        };
        b.props.insert("response".into(), response);
        b.props.insert("readyState".into(), Value::Number(4.0));
    }
    let onrsc = o.borrow().props.get("onreadystatechange").cloned();
    if let Some(f) = onrsc.and_then(callable_or_none) {
        it.call_listener(&f, this.clone(), &[], "XHR onreadystatechange");
    }
    let cb = o
        .borrow()
        .props
        .get(if ok { "onload" } else { "onerror" })
        .cloned();
    if let Some(f) = cb.and_then(callable_or_none) {
        let ctx = if ok { "XHR onload" } else { "XHR onerror" };
        it.call_listener(&f, this.clone(), &[], ctx);
    }
    Ok(Value::Undefined)
}

/// Promise.all: マイクロタスクを駆動して各入力を解決し、結果配列に集約する。
pub(crate) fn promise_all_static(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = it.iter_to_vec(&arg(a, 0));
    let result = new_pending();
    // 保留中の Promise を同期的に解決まで進める。
    it.run_microtasks();
    let mut out: Vec<Value> = Vec::new();
    let mut rejected: Option<Value> = None;
    for item in items {
        // 汎用 thenable（`.then` を持つが本物の Promise ではないオブジェクト）が
        // 「非 Promise」としてそのまま結果配列に混入するバグだった（`Promise.resolve`/
        // `await` 単体では既に同化に対応済みだったのに `Promise.all` だけ非対称
        // だった）。`allSettled`/`race`/`any` と共通の `resolve_maybe_thenable` を使う。
        match resolve_maybe_thenable(it, &item) {
            Some(s) => {
                let b = s.borrow();
                match b.status {
                    PromiseStatus::Fulfilled => out.push(b.value.clone()),
                    PromiseStatus::Rejected => {
                        rejected = Some(b.value.clone());
                        break;
                    }
                    PromiseStatus::Pending => out.push(Value::Undefined),
                }
            }
            None => out.push(item), // 非 Promise・非 thenable はそのまま。
        }
    }
    match rejected {
        Some(e) => it.promise_reject(&result, e),
        None => it.promise_resolve(&result, Value::Object(Obj::array(out))),
    }
    Ok(Value::Object(Obj::promise(result)))
}

/// `then`/`catch`/`finally` メソッド（interp の get_property から返す）。
pub fn promise_method(key: &str) -> Value {
    match key {
        "then" => nv("Promise.then", promise_then_m),
        "catch" => nv("Promise.catch", promise_catch_m),
        "finally" => nv("Promise.finally", promise_finally_m),
        _ => Value::Undefined,
    }
}

pub(crate) fn promise_then_m(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_promise_state(&this) {
        let on_f = callable_or_none(arg(a, 0));
        let on_r = callable_or_none(arg(a, 1));
        return Ok(it.promise_then(&s, on_f, on_r));
    }
    Ok(Value::Undefined)
}

pub(crate) fn promise_catch_m(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_promise_state(&this) {
        let on_r = callable_or_none(arg(a, 0));
        return Ok(it.promise_then(&s, None, on_r));
    }
    Ok(Value::Undefined)
}

/// `Promise.prototype.finally(cb)`。以前は `cb` を fulfill/reject 双方で副作用として
/// 実行するだけで戻り値/例外を完全に無視していた。仕様上は `cb` が例外を投げる、
/// または reject する Promise を返した場合、その結果が元の settle を上書きすべき
/// （`Promise.resolve(1).finally(() => { throw 'x' })` は `1` ではなく `'x'` で
/// reject すべき）で、これが `cb` に副作用以上の意味が無いという誤った前提の
/// 静かな破壊バグだった。ネイティブ関数はクロージャで `cb`/`this` を束縛できない
/// ため（`AbortSignal.any` 等と同じ制約）、グローバルの一時変数経由で渡した上で
/// `eval_source` に組み立てた JS（仕様の `finally` 展開そのもの）を実行する。
pub(crate) fn promise_finally_m(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(s) = this_promise_state(&this) else {
        return Ok(Value::Undefined);
    };
    let cb = arg(a, 0);
    if callable_or_none(cb.clone()).is_none() {
        // cb が呼び出し不能なら仕様上ただの `then()` と同じ（副作用なし）。
        return Ok(it.promise_then(&s, None, None));
    }
    it.global
        .borrow_mut()
        .vars
        .insert("__finally_promise".into(), this);
    it.global.borrow_mut().vars.insert("__finally_cb".into(), cb);
    let src = "(function(){ \
        var p = __finally_promise; \
        var cb = __finally_cb; \
        return p.then( \
            function(v){ return Promise.resolve(cb()).then(function(){ return v; }); }, \
            function(r){ return Promise.resolve(cb()).then(function(){ throw r; }); } \
        ); \
    })()";
    let result = it.eval_source(src);
    it.global.borrow_mut().vars.remove("__finally_promise");
    it.global.borrow_mut().vars.remove("__finally_cb");
    result
}