atmos/os_lib/js/builtins/

web_forms.rs

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

// ===== Storage API（localStorage / sessionStorage）=====
// localStorage: SylFS に "__localStorage__" として永続化。sessionStorage: in-memory のみ。
pub(crate) static LOCAL_STORAGE: spin::Mutex<alloc::collections::BTreeMap<String, String>> =
    spin::Mutex::new(alloc::collections::BTreeMap::new());
pub(crate) static SESSION_STORAGE: spin::Mutex<alloc::collections::BTreeMap<String, String>> =
    spin::Mutex::new(alloc::collections::BTreeMap::new());
pub(crate) static LS_LOADED: core::sync::atomic::AtomicBool =
    core::sync::atomic::AtomicBool::new(false);
// `document.cookie`（丸ごと未対応だった）。実ブラウザのような per-origin の
// 永続 cookie jar・`expires`/`max-age`/`path`/`domain`/`secure`/`samesite`
// 属性は非対応の簡略実装（in-memory のみ、OS 再起動で消える）。読み書きされる
// 属性部分は無視し、`name=value` の1件のみを反映する。
pub(crate) static COOKIES: spin::Mutex<alloc::collections::BTreeMap<String, String>> =
    spin::Mutex::new(alloc::collections::BTreeMap::new());

pub(crate) const LS_FILENAME: &str = "__localStorage__";

/// BTreeMap を長さプレフィクス付きバイナリ形式にシリアライズ。
pub(crate) fn ls_serialize(map: &alloc::collections::BTreeMap<String, String>) -> alloc::vec::Vec<u8> {
    let mut out = alloc::vec::Vec::new();
    for (k, v) in map.iter() {
        let kb = k.as_bytes();
        let vb = v.as_bytes();
        out.extend_from_slice(&(kb.len() as u32).to_le_bytes());
        out.extend_from_slice(kb);
        out.extend_from_slice(&(vb.len() as u32).to_le_bytes());
        out.extend_from_slice(vb);
    }
    out
}

/// バイナリ形式から BTreeMap を復元。
pub(crate) fn ls_deserialize(data: &[u8]) -> alloc::collections::BTreeMap<String, String> {
    let mut map = alloc::collections::BTreeMap::new();
    let mut pos = 0usize;
    while pos + 8 <= data.len() {
        let klen = u32::from_le_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]])
            as usize;
        pos += 4;
        if pos + klen > data.len() {
            break;
        }
        let k = alloc::string::String::from_utf8_lossy(&data[pos..pos + klen]).into_owned();
        pos += klen;
        if pos + 4 > data.len() {
            break;
        }
        let vlen = u32::from_le_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]])
            as usize;
        pos += 4;
        if pos + vlen > data.len() {
            break;
        }
        let v = alloc::string::String::from_utf8_lossy(&data[pos..pos + vlen]).into_owned();
        pos += vlen;
        map.insert(k, v);
    }
    map
}

/// 起動後初回アクセス時に SylFS から localStorage を読み込む（FS 未マウントなら skip）。
pub(crate) fn ls_ensure_loaded() {
    if LS_LOADED.load(core::sync::atomic::Ordering::Relaxed) {
        return;
    }
    LS_LOADED.store(true, core::sync::atomic::Ordering::Relaxed);
    if !crate::kernel::fs::is_mounted() {
        return;
    }
    if let Some(data) = crate::kernel::fs::read_file(LS_FILENAME) {
        *LOCAL_STORAGE.lock() = ls_deserialize(&data);
    }
}

/// localStorage の変更を SylFS に書き出す（FS 未マウントなら skip）。
pub(crate) fn ls_flush() {
    if !crate::kernel::fs::is_mounted() {
        return;
    }
    let data = ls_serialize(&LOCAL_STORAGE.lock());
    // 【2026-08-25 バグ修正】ここは FS_LOCK を取らずに **書いて** いた。
    //
    // この関数は JS の setter 経路（ブラウザ本体スレッド）から呼ばれるが、
    // 画像・フォントのワーカースレッドは同時に `FS_LOCK` を取って
    // ディスクキャッシュを書いている。番人なしで割り込むと
    // 空きセクタビットマップが二重確保され、**関係ないファイルが壊れる**。
    //
    // 削除と保存はひと続きの書き換えなので、両方を同じ番人の下で行う
    // （途中で手放すと、消えたまま保存されない瞬間が他スレッドから見える）。
    let _fs_guard = crate::kernel::fs::FS_LOCK.lock();
    let fs = crate::kernel::fs::get_fs();
    // 【2026-07-28】ここで書き込み失敗を捨てると localStorage が**黙って
    // 永続化されない**（次回起動で消えるのに、その場では成功して見える）。
    // この関数は `()` を返す JS 側の setter 経路から呼ばれるため例外にはできないが、
    // 失敗した事実は必ずログへ残す。
    if let Err(e) = fs.delete_file(LS_FILENAME) {
        // 未作成なら "file not found" は正常。それ以外は書き換え失敗の予兆。
        if e != "file not found" {
            crate::warn!("[JS] localStorage: failed to remove old store: {}", e);
        }
    }
    if !data.is_empty() {
        if let Err(e) = fs.save_file(LS_FILENAME, &data, "system") {
            crate::error!("[JS] localStorage: failed to persist ({} bytes): {}", data.len(), e);
        }
    }
}

/// `document.cookie` の getter: `"name=value; name2=value2"` 形式で結合する。
pub fn cookie_string() -> String {
    COOKIES
        .lock()
        .iter()
        .map(|(k, v)| alloc::format!("{}={}", k, v))
        .collect::<alloc::vec::Vec<_>>()
        .join("; ")
}

/// `document.cookie = "..."` の setter: 先頭の `name=value` セグメントのみを
/// 反映し、`; expires=...`/`; path=...` 等の後続属性は無視する（`name` が空、
/// または `=` が無い場合は何もしない）。
pub fn cookie_set(s: &str) {
    let first = s.split(';').next().unwrap_or("");
    if let Some(eq) = first.find('=') {
        let name = first.get(..eq).unwrap_or("").trim();
        let value = first.get(eq + 1..).unwrap_or("").trim();
        if !name.is_empty() {
            COOKIES
                .lock()
                .insert(String::from(name), String::from(value));
        }
    }
}

/// `cookieStore.get(name)`（Cookie Store API。丸ごと未対応だった）。
/// `document.cookie` と同じ `COOKIES` を参照する。見つからなければ仕様どおり
/// `null`。
pub(crate) fn cookie_store_get(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string();
    let value = COOKIES.lock().get(&name).cloned();
    let result = match value {
        Some(v) => {
            let o = Obj::plain();
            o.borrow_mut().props.insert("name".into(), Value::str(&name));
            o.borrow_mut().props.insert("value".into(), Value::str(v));
            Value::Object(o)
        }
        None => Value::Null,
    };
    Ok(resolved_promise(it, result))
}
/// `cookieStore.getAll(name?)`（対応する複数形。`name` 省略時は全 Cookie）。
pub(crate) fn cookie_store_get_all(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let filter = if a.is_empty() { None } else { Some(arg(a, 0).to_js_string()) };
    let items: Vec<Value> = COOKIES
        .lock()
        .iter()
        .filter(|(k, _)| filter.as_ref().is_none_or(|f| *f == **k))
        .map(|(k, v)| {
            let o = Obj::plain();
            o.borrow_mut().props.insert("name".into(), Value::str(k));
            o.borrow_mut().props.insert("value".into(), Value::str(v));
            Value::Object(o)
        })
        .collect();
    Ok(resolved_promise(it, Value::Object(Obj::array(items))))
}
/// `cookieStore.set(name, value)`（`cookieStore.set({name, value})` 形式も
/// 対応）。既存の `cookie_set` と同じ `COOKIES` へ書き込む。
pub(crate) fn cookie_store_set(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let first = arg(a, 0);
    let (name, value) = if let Value::Object(_) = &first {
        (
            obj_prop(&first, "name").map(|v| v.to_js_string()).unwrap_or_default(),
            obj_prop(&first, "value").map(|v| v.to_js_string()).unwrap_or_default(),
        )
    } else {
        (first.to_js_string(), arg(a, 1).to_js_string())
    };
    if !name.is_empty() {
        COOKIES.lock().insert(name, value);
    }
    Ok(resolved_promise(it, Value::Undefined))
}
/// `cookieStore.delete(name)`。
pub(crate) fn cookie_store_delete(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string();
    COOKIES.lock().remove(&name);
    Ok(resolved_promise(it, Value::Undefined))
}

pub(crate) fn storage_map(tag: &str) -> &'static spin::Mutex<alloc::collections::BTreeMap<String, String>> {
    if tag == "storage:session" {
        &SESSION_STORAGE
    } else {
        &LOCAL_STORAGE
    }
}
/// `kind` が `localStorage`/`sessionStorage` の `ObjKind::Host` なら、実データを保持する
/// `storage_map` から現在のキー一覧を返す。`Object.keys(localStorage)`/`for...in localStorage`
/// が常に空を返していたバグの修正用（実データは `.props` ではなく別マップにあるため）。
pub fn storage_host_keys(kind: &ObjKind) -> Option<Vec<String>> {
    if let ObjKind::Host(t) = kind {
        if t.starts_with("storage:") {
            if t.as_str() != "storage:session" {
                ls_ensure_loaded();
            }
            return Some(storage_map(t).lock().keys().cloned().collect());
        }
    }
    None
}
/// `kind` が `dataset:N`（`element.dataset`）の `ObjKind::Host` なら、対応する
/// DOM 要素の `data-*` 属性一覧を camelCase キーへ変換して返す。
/// `Object.keys(el.dataset)`/`for...in el.dataset` が実データ（`data-*` 属性、
/// `.props` ではなく DOM 要素側の属性ストアにある）を素通しして常に空を
/// 返していたバグの修正用（`storage_host_keys`（localStorage/sessionStorage）
/// で修正済みの同型バグ）。
pub fn dataset_host_keys(kind: &ObjKind, dom: &super::super::dom_bridge::DomBridge) -> Option<Vec<String>> {
    dataset_host_entries(kind, dom).map(|entries| entries.into_iter().map(|(k, _)| k).collect())
}
/// `dataset_host_keys` と同じ判定条件で、camelCase キー→属性値のペア一覧を
/// 返す（`Object.values`/`Object.entries` 用）。
pub fn dataset_host_entries(
    kind: &ObjKind,
    dom: &super::super::dom_bridge::DomBridge,
) -> Option<Vec<(String, String)>> {
    if let ObjKind::Host(t) = kind {
        if let Some(rest) = t.strip_prefix("dataset:") {
            let idx: usize = rest.parse().ok()?;
            return Some(
                dom.attr_names(idx)
                    .into_iter()
                    .filter_map(|n| {
                        n.strip_prefix("data-").map(|s| {
                            let camel = data_attr_to_camel(s);
                            let val = dom.get_attr(idx, &n).unwrap_or_default();
                            (camel, val)
                        })
                    })
                    .collect(),
            );
        }
    }
    None
}
/// `data-user-id` → `userId`（`camel_to_data_attr` の逆変換）。
pub(crate) fn data_attr_to_camel(name: &str) -> String {
    let mut out = String::new();
    let mut upper_next = false;
    for c in name.chars() {
        if c == '-' {
            upper_next = true;
        } else if upper_next {
            out.extend(c.to_uppercase());
            upper_next = false;
        } else {
            out.push(c);
        }
    }
    out
}
pub(crate) fn this_storage_tag(this: &Value) -> Option<String> {
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if t.starts_with("storage:") {
                return Some(t.clone());
            }
        }
    }
    None
}
pub(crate) fn storage_get_item(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(tag) = this_storage_tag(&this) {
        if tag != "storage:session" {
            ls_ensure_loaded();
        }
        let k = arg(a, 0).to_js_string();
        return Ok(match storage_map(&tag).lock().get(&k) {
            Some(v) => Value::str(v.clone()),
            None => Value::Null,
        });
    }
    Ok(Value::Null)
}
pub(crate) fn storage_set_item(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(tag) = this_storage_tag(&this) {
        if tag != "storage:session" {
            ls_ensure_loaded();
        }
        storage_map(&tag)
            .lock()
            .insert(arg(a, 0).to_js_string(), arg(a, 1).to_js_string());
        if tag != "storage:session" {
            ls_flush();
        }
    }
    Ok(Value::Undefined)
}
pub(crate) fn storage_remove_item(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(tag) = this_storage_tag(&this) {
        if tag != "storage:session" {
            ls_ensure_loaded();
        }
        storage_map(&tag).lock().remove(&arg(a, 0).to_js_string());
        if tag != "storage:session" {
            ls_flush();
        }
    }
    Ok(Value::Undefined)
}
pub(crate) fn storage_clear(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(tag) = this_storage_tag(&this) {
        storage_map(&tag).lock().clear();
        if tag != "storage:session" {
            ls_flush();
        }
    }
    Ok(Value::Undefined)
}
pub(crate) fn storage_key(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(tag) = this_storage_tag(&this) {
        if tag != "storage:session" {
            ls_ensure_loaded();
        }
        let i = arg(a, 0).to_number() as usize;
        return Ok(match storage_map(&tag).lock().keys().nth(i) {
            Some(k) => Value::str(k.clone()),
            None => Value::Null,
        });
    }
    Ok(Value::Null)
}

/// `storage:` host のプロパティ取得（メソッド / length / データキー）。
pub fn storage_get_prop(tag: &str, key: &str) -> Value {
    if tag != "storage:session" {
        ls_ensure_loaded();
    }
    match key {
        "getItem" => nv("getItem", storage_get_item),
        "setItem" => nv("setItem", storage_set_item),
        "removeItem" => nv("removeItem", storage_remove_item),
        "clear" => nv("clear", storage_clear),
        "key" => nv("key", storage_key),
        "length" => Value::Number(storage_map(tag).lock().len() as f64),
        _ => match storage_map(tag).lock().get(key) {
            Some(v) => Value::str(v.clone()),
            None => Value::Undefined,
        },
    }
}
/// `storage:` host へのプロパティ代入（length 以外は setItem 相当）。
/// `delete localStorage.foo`/`delete sessionStorage.foo`（プロパティ直接削除。`removeItem`
/// と同義だが、こちらの経路は Host プロキシが `.props` を持たないため以前は黙って
/// 何も起きなかった）。
pub fn storage_remove_prop(tag: &str, key: &str) {
    if tag != "storage:session" {
        ls_ensure_loaded();
    }
    storage_map(tag).lock().remove(key);
    if tag != "storage:session" {
        ls_flush();
    }
}
pub fn storage_set_prop(tag: &str, key: &str, val: &Value) {
    if key != "length" {
        if tag != "storage:session" {
            ls_ensure_loaded();
        }
        storage_map(tag)
            .lock()
            .insert(String::from(key), val.to_js_string());
        if tag != "storage:session" {
            ls_flush();
        }
    }
}

// ===== URLSearchParams =====
// 内部状態は正規化済みクエリ文字列 `_query`（"k=v&k=v"、常にエンコード済みの形で保持）。
// get/set 等の外部インターフェースでは form-urlencoded（+ = 空白, %XX）でデコード/エンコードする。
pub(crate) fn parse_query(q: &str) -> Vec<(String, String)> {
    let q = q.strip_prefix('?').unwrap_or(q);
    q.split('&')
        .filter(|s| !s.is_empty())
        .map(|pair| match pair.split_once('=') {
            Some((k, v)) => (percent_decode(k, true), percent_decode(v, true)),
            None => (percent_decode(pair, true), String::new()),
        })
        .collect()
}
/// form-urlencoded（RFC1738 系）でエンコード。空白は `+`、それ以外の非英数字は `%XX`。
pub(crate) fn form_url_encode(s: &str) -> String {
    let mut out = String::new();
    for b in s.as_bytes() {
        match *b {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                out.push(*b as char);
            }
            b' ' => out.push('+'),
            _ => out.push_str(&alloc::format!("%{:02X}", b)),
        }
    }
    out
}
pub(crate) fn build_query(pairs: &[(String, String)]) -> String {
    let parts: Vec<String> = pairs
        .iter()
        .map(|(k, v)| format!("{}={}", form_url_encode(k), form_url_encode(v)))
        .collect();
    parts.join("&")
}
/// `URLSearchParams.prototype.size`（ES2023）の実体。`interp.rs` のプロパティ
/// getter から呼ばれる（USP は専用 ObjKind を持たない plain object 実装のため、
/// Map/Set の `size` のように直接カウントを持たず、その都度クエリ文字列をパース
/// して数える）。
pub fn usp_entry_count(this: &Value) -> usize {
    parse_query(&usp_query(this)).len()
}
pub(crate) fn usp_query(this: &Value) -> String {
    if let Value::Object(o) = this {
        return o
            .borrow()
            .props
            .get("_query")
            .map(|v| v.to_js_string())
            .unwrap_or_default();
    }
    String::new()
}
pub(crate) fn usp_set_query(this: &Value, q: &str) {
    if let Value::Object(o) = this {
        let parent = {
            let mut b = o.borrow_mut();
            b.props.insert(String::from("_query"), Value::str(q));
            b.props.get("_parent_url").cloned()
        };
        if let Some(Value::Object(po)) = parent {
            let search_val = if q.is_empty() {
                String::new()
            } else {
                alloc::format!("?{}", q)
            };
            po.borrow_mut()
                .props
                .insert(String::from("search"), Value::str(search_val));
        }
    }
}
pub(crate) fn usp_get(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let k = arg(a, 0).to_js_string();
    let pairs = parse_query(&usp_query(&this));
    Ok(pairs
        .iter()
        .find(|(pk, _)| *pk == k)
        .map(|(_, v)| Value::str(v.clone()))
        .unwrap_or(Value::Null))
}
pub(crate) fn usp_get_all(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let k = arg(a, 0).to_js_string();
    let items: Vec<Value> = parse_query(&usp_query(&this))
        .into_iter()
        .filter(|(pk, _)| *pk == k)
        .map(|(_, v)| Value::str(v))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}
/// `has(name, value)`（ES2023 で追加された第2引数 `value`。省略時は名前だけで判定する
/// 従来どおりの挙動だが、指定時は名前と値の両方が一致するエントリの有無を返す。
/// 以前は第2引数を完全に無視しており、`has('a', 'wrong-value')` が誤って `true` に
/// なるバグだった）。
pub(crate) fn usp_has(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let k = arg(a, 0).to_js_string();
    let entries = parse_query(&usp_query(&this));
    let found = if matches!(arg(a, 1), Value::Undefined) {
        entries.iter().any(|(pk, _)| *pk == k)
    } else {
        let v = arg(a, 1).to_js_string();
        entries.iter().any(|(pk, pv)| *pk == k && *pv == v)
    };
    Ok(Value::Bool(found))
}
pub(crate) fn usp_append(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let mut pairs = parse_query(&usp_query(&this));
    pairs.push((arg(a, 0).to_js_string(), arg(a, 1).to_js_string()));
    usp_set_query(&this, &build_query(&pairs));
    Ok(Value::Undefined)
}
pub(crate) fn usp_set(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let k = arg(a, 0).to_js_string();
    let mut pairs: Vec<(String, String)> = parse_query(&usp_query(&this))
        .into_iter()
        .filter(|(pk, _)| *pk != k)
        .collect();
    pairs.push((k, arg(a, 1).to_js_string()));
    usp_set_query(&this, &build_query(&pairs));
    Ok(Value::Undefined)
}
/// `delete(name, value)`（ES2023 で追加された第2引数。`has` と同じく省略時は名前だけ
/// で全削除、指定時は名前と値の両方が一致するエントリのみ削除する。以前は第2引数を
/// 完全に無視しており、値を問わず同名のエントリを全て消してしまうバグだった）。
pub(crate) fn usp_delete(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let k = arg(a, 0).to_js_string();
    let value_filter = if matches!(arg(a, 1), Value::Undefined) {
        None
    } else {
        Some(arg(a, 1).to_js_string())
    };
    let pairs: Vec<(String, String)> = parse_query(&usp_query(&this))
        .into_iter()
        .filter(|(pk, pv)| match &value_filter {
            Some(v) => !(*pk == k && pv == v),
            None => *pk != k,
        })
        .collect();
    usp_set_query(&this, &build_query(&pairs));
    Ok(Value::Undefined)
}
pub(crate) fn usp_to_string(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(usp_query(&this)))
}
/// `URLSearchParams.prototype.sort()`（ES2020）が丸ごと未対応だった。全エントリを
/// キー名でソートする（仕様どおり安定ソート。同名キー同士の相対順序は保持する）。
pub(crate) fn usp_sort(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let mut pairs = parse_query(&usp_query(&this));
    pairs.sort_by(|a, b| a.0.cmp(&b.0));
    usp_set_query(&this, &build_query(&pairs));
    Ok(Value::Undefined)
}
/// `URLSearchParams` の既定イテレーション（`entries()` と同義）。`make_iterator()` で
/// 本物のイテレータ形状（`.next()`）にして返す。
pub(crate) fn usp_iterator(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = parse_query(&usp_query(&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)))
}
// `new URLSearchParams(init)` の `init` がオブジェクトの場合、以前は
// `Value::to_js_string()`（`it: &mut Interp` を持たないため JS 側の
// カスタム `toString`/イテレータを呼べない、純粋な既定変換）に丸投げしており、
// 素の `Obj::plain()` はどれも `"[object Object]"` に落ちるため、仕様上有効な
// 3つの `init` 形式が軒並み壊れていた：`sequence<sequence<USVString>>`
// （配列のペア列。`to_js_string` は要素をカンマ結合するだけで `=`/`&` に
// ならない）・`record<USVString, USVString>`（プレーンオブジェクト）・
// 既存の `URLSearchParams`/`FormData` インスタンス（実ブラウザでは USVString
// 変換が `toString()` を呼ぶため動く）。
pub(crate) fn url_search_params_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let init = arg(a, 0);
    let q = match &init {
        Value::Undefined | Value::Null => String::new(),
        Value::Object(o) => {
            let is_array = matches!(&o.borrow().kind, ObjKind::Array(_));
            if is_array {
                let pairs: alloc::vec::Vec<(String, String)> = this_items(&init)
                    .iter()
                    .filter_map(|item| {
                        let inner = this_items(item);
                        if inner.len() >= 2 {
                            Some((inner[0].to_js_string(), inner[1].to_js_string()))
                        } else {
                            None
                        }
                    })
                    .collect();
                build_query(&pairs)
            } else if let Some(existing) = o.borrow().props.get("_query") {
                // 既存の URLSearchParams/FormData インスタンス由来。
                existing.to_js_string()
            } else {
                let pairs: alloc::vec::Vec<(String, String)> = o
                    .borrow()
                    .props
                    .iter()
                    .map(|(k, v)| (k.clone(), v.to_js_string()))
                    .collect();
                build_query(&pairs)
            }
        }
        other => other.to_js_string(),
    };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props
            .insert("_query".into(), Value::str(build_query(&parse_query(&q))));
        // `.size`（ES2023）は USP 固有の仕様（`FormData` には無い）なので、同じ
        // `_query` 内部表現を共有する `FormData` と区別するためのマーカー。
        b.props.insert("_is_usp".into(), Value::Bool(true));
        // `.sort()`（ES2020）は USP 固有の仕様（`FormData` には無い）。
        b.props.insert("sort".into(), nv("sort", usp_sort));
        b.props.insert("get".into(), nv("get", usp_get));
        b.props.insert("getAll".into(), nv("getAll", usp_get_all));
        b.props.insert("has".into(), nv("has", usp_has));
        b.props.insert("append".into(), nv("append", usp_append));
        b.props.insert("set".into(), nv("set", usp_set));
        b.props.insert("delete".into(), nv("delete", usp_delete));
        // `entries`/`keys`/`values`/`forEach`（`FormData` は既にあったが、実は同じ
        // `_query` 内部表現を使うため丸ごと欠落していた `URLSearchParams` 側にも
        // そのまま流用できる）。
        b.props.insert("entries".into(), nv("entries", fd_entries));
        b.props.insert("keys".into(), nv("keys", fd_keys));
        b.props.insert("values".into(), nv("values", fd_values));
        b.props.insert("forEach".into(), nv("forEach", fd_for_each));
        // `Symbol.iterator` が未登録で `for (const [k,v] of params)`（`entries()` と
        // 同義の既定イテレーション）が丸ごと非対応だったバグ。`entries()` 自体は
        // 単純な配列を返す簡略実装だが、`for...of` の汎用カスタムイテレータ駆動
        // 経路は `.next()` を持つ本物のイテレータ形状を要求するため、`make_iterator()`
        // で包んだ別実装を用意する。
        b.props.insert(
            "Symbol(Symbol.iterator)".into(),
            nv("[Symbol.iterator]", usp_iterator),
        );
        b.props
            .insert("toString".into(), nv("toString", usp_to_string));
    }
    Ok(Value::Object(o))
}

// ===== FormData =====
// URLSearchParams と同じ `_query` 内部表現を流用しつつ、entries/keys/values/forEach と
// form 要素からの初期収集に対応する。値は文字列のみ（File は未対応）。
pub(crate) fn fd_entries(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = parse_query(&usp_query(&this))
        .into_iter()
        .map(|(k, v)| Value::Object(Obj::array(alloc::vec![Value::str(k), Value::str(v)])))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}
pub(crate) fn fd_keys(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = parse_query(&usp_query(&this))
        .into_iter()
        .map(|(k, _)| Value::str(k))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}
pub(crate) fn fd_values(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = parse_query(&usp_query(&this))
        .into_iter()
        .map(|(_, v)| Value::str(v))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}
pub(crate) fn fd_for_each(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let cb = arg(a, 0);
    if matches!(cb, Value::Object(_)) {
        for (k, v) in parse_query(&usp_query(&this)) {
            it.call_value(
                &cb,
                Value::Undefined,
                &[Value::str(v), Value::str(k), this.clone()],
            )?;
        }
    }
    Ok(Value::Undefined)
}

/// <form> 要素配下の送信対象コントロールから (name, value) を収集する。
/// - name 属性が無いコントロールは無視（HTML 仕様）。
/// - checkbox/radio は checked のときのみ、value（無ければ "on"）を採用。
/// - select は selected option（無ければ最初の option）の value。
/// - disabled は除外。
pub(crate) fn collect_form_data(it: &Interp, form_idx: usize) -> Vec<(String, String)> {
    let dom = it.dom.borrow();
    let mut out: Vec<(String, String)> = Vec::new();
    // ドキュメント全体をルート（node[0]）からドキュメント順で走査し、その中から
    // このフォームに実際に属する（`associated_form`が`form_idx`を指す）
    // コントロールだけを拾う。以前は`form_idx`を起点にした子孫走査のみだった
    // ため、`<form>`の外に置かれた`<input form="...">`（HTML5仕様の「form
    // owner」。`element.form`/`checkValidity()`側は既に対応済み）が送信データ
    // から漏れていた。`associated_form`は`form`属性優先・無ければ祖先探索という
    // 正しい優先順位を既に実装しているため、それをそのまま判定に使う。
    let mut stack: Vec<usize> = alloc::vec![0usize];
    let mut order: Vec<usize> = Vec::new();
    while let Some(i) = stack.pop() {
        order.push(i);
        if let Some(n) = dom.nodes.get(i) {
            // 子はドキュメント順を保つため逆順 push。
            for &c in n.children.iter().rev() {
                stack.push(c);
            }
        }
    }
    for &i in order.iter() {
        let n = match dom.nodes.get(i) {
            Some(n) => n,
            None => continue,
        };
        if n.is_text || i == form_idx {
            continue;
        }
        let tag = n.tag.as_str();
        if tag != "input" && tag != "select" && tag != "textarea" {
            continue;
        }
        if dom.associated_form(i) != Some(form_idx) {
            continue;
        }
        // `<fieldset disabled>`祖先による暗黙の無効化も含めて判定する
        // （詳細は`is_disabled`のコメント参照。以前は要素自身の`disabled`
        // 属性しか見ておらず、無効化されたフィールドの値が送信データに
        // 混入していた）。
        if dom.is_disabled(i) {
            continue;
        }
        let name = dom.get_attr(i, "name").unwrap_or_default();
        if name.is_empty() {
            continue;
        }
        match tag {
            "input" => {
                let ty = dom.get_attr(i, "type").unwrap_or_default().to_lowercase();
                match ty.as_str() {
                    "submit" | "button" | "reset" | "image" | "file" => { /* 送信対象外 */ }
                    "checkbox" | "radio" => {
                        if dom.has_attr(i, "checked") {
                            let v = dom
                                .get_attr(i, "value")
                                .filter(|s| !s.is_empty())
                                .unwrap_or_else(|| String::from("on"));
                            out.push((name, v));
                        }
                    }
                    _ => {
                        out.push((name, dom.get_attr(i, "value").unwrap_or_default()));
                    }
                }
            }
            "textarea" => {
                let v = dom
                    .get_attr(i, "value")
                    .unwrap_or_else(|| n.initial_text.clone());
                out.push((name, v));
            }
            "select" => {
                // `<select multiple>`（仕様上は選択された option 1つにつき1エントリを
                // 送信する）が丸ごと未対応で、常に単一値しか収集しないバグだった
                // （複数選択リストボックスという定番 UI パターンで送信データが欠落する）。
                // `<optgroup>`配下の`<option>`が丸ごと見えなくなっていたバグ
                // （`select_options`側で2026-07-17に修正済み。以前はここで
                // 直接の子だけを`n.children.iter()`で見ており、`<select
                // multiple>`の複数選択送信・フォールバック単一選択のどちらも
                // カテゴリ分けされた`<optgroup>`内のoptionを見落としていた）。
                // 既に`<optgroup>`対応済みの`select_options`を再利用する。
                if dom.has_attr(i, "multiple") {
                    for c in dom.select_options(i) {
                        if dom.has_attr(c, "selected") {
                            let v = dom.get_attr(c, "value").unwrap_or_else(|| {
                                dom.nodes.get(c).map(|cn| cn.initial_text.clone()).unwrap_or_default()
                            });
                            out.push((name.clone(), v));
                        }
                    }
                }
                // select 自身の value 属性（レンダラが選択値を反映）を優先。
                else if let Some(v) = dom.get_attr(i, "value").filter(|s| !s.is_empty()) {
                    out.push((name, v));
                } else {
                    // フォールバック: HTML属性`selected`が付いたoptionがあれば
                    // それを、無ければ仕様どおり構造上最初のoption（HTML標準の
                    // 「selected未指定なら最初のoptionが暗黙に選択される」規則）
                    // を使う。以前は`selected`属性を一切見ず常に構造上最初の
                    // optionを使っていたため、`<option selected>`をHTMLの
                    // マークアップだけで（JS側の`.value=`代入を経由せず）
                    // 指定した場合、`FormData`送信値が実際の選択と食い違う
                    // バグだった（`.value`ゲッターは正しく`selected`を見て
                    // いたのに、こちらのフォールバックだけ非対称だった。
                    // `<optgroup>`監査中に自己テストで発見。2026-07-17
                    // 発見・実装）。
                    let opts = dom.select_options(i);
                    let chosen = opts
                        .iter()
                        .find(|&&o| dom.has_attr(o, "selected"))
                        .or_else(|| opts.first());
                    if let Some(&oi) = chosen {
                        let v = dom.get_attr(oi, "value").unwrap_or_else(|| {
                            dom.nodes
                                .get(oi)
                                .map(|cn| cn.initial_text.clone())
                                .unwrap_or_default()
                        });
                        out.push((name, v));
                    }
                }
            }
            _ => {}
        }
    }
    out
}

pub(crate) fn form_data_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    // 引数が form 要素なら、その送信対象コントロールから初期化。
    let pairs = match this_dom_idx(&arg(a, 0)) {
        Some(form_idx) => collect_form_data(it, form_idx),
        None => Vec::new(),
    };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props
            .insert("_query".into(), Value::str(build_query(&pairs)));
        b.props.insert("get".into(), nv("get", usp_get));
        b.props.insert("getAll".into(), nv("getAll", usp_get_all));
        b.props.insert("has".into(), nv("has", usp_has));
        b.props.insert("append".into(), nv("append", usp_append));
        b.props.insert("set".into(), nv("set", usp_set));
        b.props.insert("delete".into(), nv("delete", usp_delete));
        b.props.insert("entries".into(), nv("entries", fd_entries));
        b.props.insert("keys".into(), nv("keys", fd_keys));
        b.props.insert("values".into(), nv("values", fd_values));
        b.props.insert("forEach".into(), nv("forEach", fd_for_each));
        // `URLSearchParams` と同じ理由で `Symbol.iterator` が未登録だった
        // （`for (const [k,v] of formData)` が丸ごと非対応）。
        b.props.insert(
            "Symbol(Symbol.iterator)".into(),
            nv("[Symbol.iterator]", usp_iterator),
        );
        b.props
            .insert("toString".into(), nv("toString", usp_to_string));
    }
    Ok(Value::Object(o))
}

/// new URL(href): location 風の成分 + searchParams を持つオブジェクト。
// `new URL(url, base)` の第2引数 `base` が丸ごと無視されており、
// `new URL('/path', 'https://example.com')` のような相対URL解決という URL API
// の最も基本的な使い方が一切機能しないバグだった（絶対URL文字列をそのまま渡す
// 使い方しか動いていなかった）。`fetch`/XHR の相対URL解決に既に使われている
// 既存の `resolve_url(base, url)` をそのまま再利用する。
/// `URL.canParse(url, base?)` の実体。この処理系の `new URL()`/`resolve_url`
/// は寛容な簡略実装で不正な入力でも例外を投げないため、代わりに「解決結果が
/// `scheme:` 形式を持つか」で判定する（WHATWG のスキーム構文
/// `[a-zA-Z][a-zA-Z0-9+.-]*:` に準拠した簡易チェック）。
pub(crate) fn url_can_parse(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let raw = arg(a, 0).to_js_string();
    let base = match arg(a, 1) {
        Value::Undefined => String::new(),
        v => v.to_js_string(),
    };
    let href = if base.is_empty() { raw } else { resolve_url(&base, &raw) };
    Ok(Value::Bool(has_url_scheme(&href)))
}
/// `URL.parse(url, base?)`（ES2024/WHATWG。丸ごと未対応だった）。
/// `try { return new URL(...) } catch { return null }` という定番イディオムを
/// 1メソッドで完結させる（`URL.canParse` は真偽値のみを返す存在確認、
/// こちらは実際に使う `URL` インスタンスまたは `null` を返す）。この処理系の
/// `new URL()` 自体は不正な URL でも例外を投げず素通しする簡略実装のため、
/// 有効性判定は `canParse` と同じ `has_url_scheme` を流用する。
pub(crate) fn url_parse(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let raw = arg(a, 0).to_js_string();
    let base = match arg(a, 1) {
        Value::Undefined => String::new(),
        v => v.to_js_string(),
    };
    let href = if base.is_empty() { raw } else { resolve_url(&base, &raw) };
    if !has_url_scheme(&href) {
        return Ok(Value::Null);
    }
    url_ctor(it, Value::Undefined, a)
}
pub(crate) fn has_url_scheme(s: &str) -> bool {
    if !s.contains(':') {
        return false;
    }
    // 生の byte インデックスでの文字列スライス（`clippy::string_slice` で
    // deny 対象）を避けるため、`:` の手前までを `chars()` で走査する。
    let mut chars = s.chars().take_while(|&c| c != ':');
    match chars.next() {
        Some(c) if c.is_ascii_alphabetic() => {}
        _ => return false,
    }
    chars.all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '-' || c == '.')
}
pub(crate) fn url_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let raw = arg(a, 0).to_js_string();
    let base = if matches!(arg(a, 1), Value::Undefined) {
        String::new()
    } else {
        arg(a, 1).to_js_string()
    };
    let href = if base.is_empty() {
        raw
    } else {
        resolve_url(&base, &raw)
    };
    let comps = location_components(&href);
    let search = comps
        .iter()
        .find(|(k, _)| *k == "search")
        .map(|(_, v)| v.clone())
        .unwrap_or_default();
    let sp = url_search_params_ctor(it, Value::Undefined, &[Value::str(search)])?;
    let o = Obj::plain();
    if let Value::Object(sp_obj) = &sp {
        sp_obj.borrow_mut().props.insert(String::from("_parent_url"), Value::Object(o.clone()));
    }
    {
        let mut b = o.borrow_mut();
        for (k, v) in &comps {
            b.props.insert(String::from(*k), Value::str(v.clone()));
        }
        b.props.insert("searchParams".into(), sp);
        // `location_to_string` を使い回していたため、`url.searchParams.set(...)` で
        // クエリ文字列を変更しても `url.toString()`/暗黙の文字列化（`fetch(url)` 等）
        // が構築時点の `href` スナップショットのまま変わらないバグだった。
        b.props
            .insert("toString".into(), nv("toString", url_to_string));
        // `URL.prototype.toJSON()`（仕様上 `toString()` と同じ href 文字列列を返す
        // だけの薄いエイリアス）が丸ごと未対応だった。`JSON.stringify` は `toJSON`
        // メソッドの有無を見るため、無いと `URL` オブジェクトの内部プロパティ
        // （`protocol`/`host` 等）がそのままシリアライズされてしまう
        // （`JSON.stringify(new URL('https://a.com/'))` が `"https://a.com/"` では
        // なくオブジェクト丸ごとの JSON になる）静かな破壊バグだった。
        b.props
            .insert("toJSON".into(), nv("toJSON", url_to_string));
        // `href` は上のループで construction 時点の静的スナップショットとして
        // `.props` に入れていたが、`toString()`/`toJSON()` は `searchParams` から
        // 毎回再構成するため、`url.searchParams.set(...)` 後に `url.href` と
        // `String(url)` が食い違う（`href` だけ古いまま）バグだった。`href` を
        // 通常のデータプロパティからアクセサへ差し替え、`url_to_string` と同じ
        // 再構成ロジックを都度呼ぶことで両者を一致させる。
        b.accessors.insert(
            String::from("href"),
            super::super::value::Accessor {
                get: Some(nv("href", url_to_string)),
                // `url.href = '...'`（URL全体を再パースして全コンポーネントを
                // 書き換える定番の再代入パターン）が丸ごと未対応だった。
                // セッターが無いため代入が黙って無視され、`.protocol`/`.host`/
                // `.pathname`等が古いまま食い違うバグ。既存の`url_ctor`と
                // 全く同じ「`location_components()`で分解して`.props`へ詰め、
                // `searchParams`を作り直す」ロジックを再利用する`url_set_href`
                // をそのまま登録する。
                set: Some(nv("href", url_set_href)),
            },
        );
        b.props.shift_remove("href");
        // `url.pathname = '...'`/`.search = '...'`/`.hash = '...'`（コンポーネント
        // 単位の再代入。`href`丸ごと差し替えほど頻度は高くないが定番）が丸ごと
        // 未対応だった。以前はこれらが単なるプレーンデータプロパティのままで、
        // 代入自体は（プロパティ書き込みとして）通ってしまうが、(1) 先頭の
        // `/`/`?`/`#`が正規化されない、(2) 特に`search`は`url.toString()`/
        // `href`ゲッターが`searchParams`だけを見て`search`プロパティ自体は
        // 一切読まないため、代入しても`toString()`/`href`に何も反映されない
        // （`searchParams`が同期されない）、という2種類の静かな不整合があった。
        // アクセサへ差し替え、正規化と（`search`のみ）`searchParams`再構築を行う。
        for (key, getter, setter) in [
            ("pathname", nv("pathname", url_get_pathname) , nv("pathname", url_set_pathname)),
            ("search", nv("search", url_get_search), nv("search", url_set_search)),
            ("hash", nv("hash", url_get_hash), nv("hash", url_set_hash)),
        ] {
            // `href`と異なりこちらは`.props[key]`をそのまま裏の実体として使う
            // （アクセサはデータプロパティより優先されるため、`.props`側の
            // 初期値を消さずに残しておいても`get`/`set`はちゃんと呼ばれる）。
            // ここで`.props.remove`してしまうと、代入されるまでゲッターが
            // 常に空文字列を返す新規バグを生むため、あえて残す。
            b.accessors.insert(
                String::from(key),
                super::super::value::Accessor { get: Some(getter), set: Some(setter) },
            );
        }
        // `protocol`/`host`/`hostname`/`port`の個別再代入も同じ理由で丸ごと
        // 未対応だった。`origin`（`toString()`/`href`は使わないが仕様上の
        // 読み取り専用プロパティとして参照される定番の値）は`protocol`/
        // `host`から導出されるため、この4つのうちどれを代入しても
        // `url_rebuild_host_and_origin`で`host`/`origin`を再計算し直す
        // 必要がある。
        for (key, getter, setter) in [
            ("protocol", nv("protocol", url_get_protocol), nv("protocol", url_set_protocol)),
            ("host", nv("host", url_get_host), nv("host", url_set_host)),
            ("hostname", nv("hostname", url_get_hostname), nv("hostname", url_set_hostname)),
            ("port", nv("port", url_get_port), nv("port", url_set_port)),
        ] {
            b.accessors.insert(
                String::from(key),
                super::super::value::Accessor { get: Some(getter), set: Some(setter) },
            );
        }
    }
    Ok(Value::Object(o))
}

/// `protocol`/`hostname`/`port`のいずれかが変更された後、それらから導出される
/// `host`（`hostname`+`:`+`port`）と`origin`（`protocol`+`//`+`host`）を
/// 再計算して`.props`へ書き戻す。`host`セッター自身は`hostname`/`port`へ分割
/// した後にこの関数を呼ぶ。
fn url_rebuild_host_and_origin(b: &mut Obj) {
    let protocol = b.props.get("protocol").map(|v| v.to_js_string()).unwrap_or_default();
    let hostname = b.props.get("hostname").map(|v| v.to_js_string()).unwrap_or_default();
    let port = b.props.get("port").map(|v| v.to_js_string()).unwrap_or_default();
    let host = if port.is_empty() { hostname.clone() } else { alloc::format!("{}:{}", hostname, port) };
    let origin = if protocol.is_empty() { String::new() } else { alloc::format!("{}//{}", protocol, host) };
    b.props.insert("host".into(), Value::str(host));
    b.props.insert("origin".into(), Value::str(origin));
}
pub(crate) fn url_get_protocol(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(url_prop_or_empty(&this, "protocol"))
}
pub(crate) fn url_set_protocol(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let v = if raw.ends_with(':') { raw } else { alloc::format!("{}:", raw) };
        let mut b = o.borrow_mut();
        b.props.insert("protocol".into(), Value::str(v));
        url_rebuild_host_and_origin(&mut b);
    }
    Ok(Value::Undefined)
}
pub(crate) fn url_get_hostname(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(url_prop_or_empty(&this, "hostname"))
}
pub(crate) fn url_set_hostname(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let mut b = o.borrow_mut();
        b.props.insert("hostname".into(), Value::str(raw));
        url_rebuild_host_and_origin(&mut b);
    }
    Ok(Value::Undefined)
}
pub(crate) fn url_get_port(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(url_prop_or_empty(&this, "port"))
}
pub(crate) fn url_set_port(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let mut b = o.borrow_mut();
        b.props.insert("port".into(), Value::str(raw));
        url_rebuild_host_and_origin(&mut b);
    }
    Ok(Value::Undefined)
}
pub(crate) fn url_get_host(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(url_prop_or_empty(&this, "host"))
}
/// `url.host = 'hostname:port'`。`hostname`/`port`へ分割して保存し直す
/// （`hostname`/`port`個別セッターと`host`の内部表現を一致させるため）。
pub(crate) fn url_set_host(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let (hostname, port) = match raw.split_once(':') {
            Some((h, p)) => (String::from(h), String::from(p)),
            None => (raw, String::new()),
        };
        let mut b = o.borrow_mut();
        b.props.insert("hostname".into(), Value::str(hostname));
        b.props.insert("port".into(), Value::str(port));
        url_rebuild_host_and_origin(&mut b);
    }
    Ok(Value::Undefined)
}

fn url_prop_or_empty(this: &Value, key: &str) -> Value {
    if let Value::Object(o) = this {
        if let Some(v) = o.borrow().props.get(key) {
            return v.clone();
        }
    }
    Value::str("")
}
pub(crate) fn url_get_pathname(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(url_prop_or_empty(&this, "pathname"))
}
pub(crate) fn url_set_pathname(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let v = if raw.is_empty() || raw.starts_with('/') {
            raw
        } else {
            alloc::format!("/{}", raw)
        };
        o.borrow_mut().props.insert("pathname".into(), Value::str(v));
    }
    Ok(Value::Undefined)
}
pub(crate) fn url_get_hash(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(url_prop_or_empty(&this, "hash"))
}
pub(crate) fn url_set_hash(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let frag = raw.strip_prefix('#').unwrap_or(&raw);
        let v = if frag.is_empty() { String::new() } else { alloc::format!("#{}", frag) };
        o.borrow_mut().props.insert("hash".into(), Value::str(v));
    }
    Ok(Value::Undefined)
}
/// `url.search`ゲッター。
/// 【安全性・2026-07-23】`toString()`/`href`と同じく`searchParams`から毎回
/// 再構成する版（`usp_to_string`経由で`searchParams`オブジェクトを参照する
/// 実装）を試した際、`u.searchParams.set(...); u.search`という呼び出し順序で
/// QEMU起動がハングする現象が一度観測されていたが、後日の徹底調査で「QEMU
/// 起動ハングはビルドごとのヒープレイアウトに依存する非決定的現象であり、
/// 特定のコード内容には紐づかない」と判明した（詳細はspec/walkthrough.md
/// 「QEMU起動ハングの二分探索」参照）。この修正自体は`url_to_string`と
/// 同じ既に安全実績のあるパターン（`o.borrow()`一度きり、別オブジェクトへの
/// 単純な委譲）であり内容起因のリスクは無いと判断し、再適用する。
pub(crate) fn url_get_search(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let sp = o.borrow().props.get("searchParams").cloned();
        if let Some(sp_val) = sp {
            let query = usp_to_string(it, sp_val, a)?.to_js_string();
            let v = if query.is_empty() { String::new() } else { alloc::format!("?{}", query) };
            return Ok(Value::str(v));
        }
    }
    Ok(url_prop_or_empty(&this, "search"))
}
/// `url.search = '...'`。`searchParams`が「唯一の真実源」（`toString()`/`href`は
/// `search`プロパティ自体でなく`searchParams`から毎回再構成する）ため、
/// `search`プロパティの更新だけでなく`searchParams`自体も作り直す必要がある。
pub(crate) fn url_set_search(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let raw = arg(a, 0).to_js_string();
        let query = raw.strip_prefix('?').unwrap_or(&raw).to_string();
        let sp = url_search_params_ctor(it, Value::Undefined, &[Value::str(query.clone())])?;
        let v = if query.is_empty() { String::new() } else { alloc::format!("?{}", query) };
        let mut b = o.borrow_mut();
        b.props.insert("search".into(), Value::str(v));
        b.props.insert("searchParams".into(), sp);
    }
    Ok(Value::Undefined)
}

/// `url.href = newHref`（`URL.prototype.href`セッター）。`url_ctor`と同じ
/// 分解ロジックを、新規オブジェクトを作る代わりに既存の`this`へ上書き
/// する形で再利用する（オブジェクト identity は保つ）。
pub(crate) fn url_set_href(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let new_href = arg(a, 0).to_js_string();
        let comps = location_components(&new_href);
        let search = comps
            .iter()
            .find(|(k, _)| *k == "search")
            .map(|(_, v)| v.clone())
            .unwrap_or_default();
        let sp = url_search_params_ctor(it, Value::Undefined, &[Value::str(search)])?;
        let mut b = o.borrow_mut();
        for (k, v) in &comps {
            b.props.insert(String::from(*k), Value::str(v.clone()));
        }
        b.props.insert("searchParams".into(), sp);
    }
    Ok(Value::Undefined)
}

/// `URL.prototype.toString()`。`href` の静的スナップショットを返すのではなく、
/// `searchParams` の現在の内容から毎回クエリ文字列を再構成する（`protocol`/`host`/
/// `pathname`/`hash` は construction 時点のまま。この処理系は `pathname`/`hash` への
/// 代入自体は未対応なので、それらのプロパティ再代入との不整合は生じない）。
pub(crate) fn url_to_string(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let (protocol, host, pathname, hash, sp) = {
            let b = o.borrow();
            (
                b.props.get("protocol").map(|v| v.to_js_string()).unwrap_or_default(),
                b.props.get("host").map(|v| v.to_js_string()).unwrap_or_default(),
                b.props.get("pathname").map(|v| v.to_js_string()).unwrap_or_default(),
                b.props.get("hash").map(|v| v.to_js_string()).unwrap_or_default(),
                b.props.get("searchParams").cloned(),
            )
        };
        let query = match sp {
            Some(sp_val) => usp_to_string(it, sp_val, a)?.to_js_string(),
            None => String::new(),
        };
        let mut s = alloc::format!("{}//{}{}", protocol, host, pathname);
        if !query.is_empty() {
            s.push('?');
            s.push_str(&query);
        }
        s.push_str(&hash);
        return Ok(Value::str(s));
    }
    Ok(Value::str(String::new()))
}

// ===== URLPattern API (HTML Standard) =====
/// `new URLPattern(pattern, baseURL?)` または `new URLPattern({ pathname, hostname, ... })`
pub(crate) fn url_pattern_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let arg0 = arg(a, 0);
    let mut pattern_pathname = String::from("*");
    let mut pattern_hostname = String::from("*");
    let mut pattern_protocol = String::from("*");

    match &arg0 {
        Value::Object(o) => {
            let b = o.borrow();
            if let Some(p) = b.props.get("pathname") {
                pattern_pathname = p.to_js_string();
            }
            if let Some(h) = b.props.get("hostname") {
                pattern_hostname = h.to_js_string();
            }
            if let Some(pr) = b.props.get("protocol") {
                pattern_protocol = pr.to_js_string();
            }
        }
        _ => {
            let pat_str = arg0.to_js_string();
            if !pat_str.is_empty() {
                if pat_str.contains("://") {
                    let href = pat_str;
                    if let Some((proto, rest)) = href.split_once("://") {
                        pattern_protocol = proto.to_string();
                        match rest.split_once('/') {
                            Some((host, path)) => {
                                pattern_hostname = host.to_string();
                                pattern_pathname = alloc::format!("/{}", path);
                            }
                            None => {
                                pattern_hostname = rest.to_string();
                                pattern_pathname = String::from("/");
                            }
                        }
                    }
                } else {
                    pattern_pathname = pat_str;
                }
            }
        }
    }

    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("pathname".into(), Value::str(pattern_pathname));
        b.props.insert("hostname".into(), Value::str(pattern_hostname));
        b.props.insert("protocol".into(), Value::str(pattern_protocol));
        b.props.insert("test".into(), nv("test", url_pattern_test));
        b.props.insert("exec".into(), nv("exec", url_pattern_exec));
    }
    Ok(Value::Object(o))
}

/// パスパターン（`/users/:id`のような`:name`名前付きセグメントを含む）を
/// ターゲットパスとスラッシュ区切りのセグメント単位で照合する。
/// 以前は`match_pattern_part`がパターン全体を1個の文字列として扱い、
/// `pattern.starts_with(':')`（パターン全体の先頭が`:`の場合のみ）しか
/// 見ていなかったため、`/users/:id`のように名前付きセグメントが途中に
/// ある一般的なパターンが常にマッチ失敗し、かつ`groups`（`URLPattern`の
/// 名前付きキャプチャ結果、`res.pathname.groups.id`等でアクセスされる）
/// も一切生成されないバグだった。一致した場合は`(名前, 値)`のキャプチャ
/// 一覧を返す。
fn match_pathname_pattern(pattern: &str, target: &str) -> Option<Vec<(String, String)>> {
    if pattern == "*" || pattern.is_empty() {
        return Some(Vec::new());
    }
    if pattern == target {
        return Some(Vec::new());
    }
    if pattern.contains('*') && !pattern.contains(':') {
        let parts: Vec<&str> = pattern.split('*').collect();
        if parts.len() == 2 && target.starts_with(parts[0]) && target.ends_with(parts[1]) {
            return Some(Vec::new());
        }
        return None;
    }
    let pat_segs: Vec<&str> = pattern.split('/').collect();
    let tgt_segs: Vec<&str> = target.split('/').collect();
    if pat_segs.len() != tgt_segs.len() {
        return None;
    }
    let mut groups = Vec::new();
    for (p, t) in pat_segs.iter().zip(tgt_segs.iter()) {
        if let Some(name) = p.strip_prefix(':') {
            groups.push((name.to_string(), t.to_string()));
        } else if *p == "*" {
            // ワイルドカードセグメント: 何にでもマッチ
        } else if p != t {
            return None;
        }
    }
    Some(groups)
}

fn match_pattern_part(pattern: &str, target: &str) -> bool {
    if pattern == "*" || pattern.is_empty() {
        return true;
    }
    if pattern == target {
        return true;
    }
    if pattern.starts_with(':') || pattern == "*" {
        return true;
    }
    if pattern.contains('*') {
        let parts: Vec<&str> = pattern.split('*').collect();
        if parts.len() == 2 {
            return target.starts_with(parts[0]) && target.ends_with(parts[1]);
        }
    }
    false
}

pub(crate) fn url_pattern_test(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let res = url_pattern_exec(it, this, a)?;
    Ok(Value::Bool(!matches!(res, Value::Null)))
}

pub(crate) fn url_pattern_exec(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let input = arg(a, 0);
    let (pat_pathname, pat_hostname, pat_protocol) = match &this {
        Value::Object(o) => {
            let b = o.borrow();
            (
                b.props.get("pathname").map(|v| v.to_js_string()).unwrap_or_else(|| "*".into()),
                b.props.get("hostname").map(|v| v.to_js_string()).unwrap_or_else(|| "*".into()),
                b.props.get("protocol").map(|v| v.to_js_string()).unwrap_or_else(|| "*".into()),
            )
        }
        _ => return Ok(Value::Null),
    };

    let mut target_pathname = String::new();
    let mut target_hostname = String::new();
    let mut target_protocol = String::new();

    match &input {
        Value::Object(o) => {
            let b = o.borrow();
            target_pathname = b.props.get("pathname").map(|v| v.to_js_string()).unwrap_or_default();
            target_hostname = b.props.get("hostname").map(|v| v.to_js_string()).unwrap_or_default();
            target_protocol = b.props.get("protocol").map(|v| v.to_js_string()).unwrap_or_default();
        }
        _ => {
            let url_str = input.to_js_string();
            if url_str.contains("://") {
                if let Some((proto, rest)) = url_str.split_once("://") {
                    target_protocol = proto.to_string();
                    match rest.split_once('/') {
                        Some((host, path)) => {
                            target_hostname = host.to_string();
                            target_pathname = alloc::format!("/{}", path);
                        }
                        None => {
                            target_hostname = rest.to_string();
                            target_pathname = String::from("/");
                        }
                    }
                }
            } else {
                target_pathname = url_str;
            }
        }
    }

    let path_match = match_pathname_pattern(&pat_pathname, &target_pathname);
    let match_host = match_pattern_part(&pat_hostname, &target_hostname);
    let match_proto = match_pattern_part(&pat_protocol, &target_protocol);

    if let (Some(groups), true, true) = (path_match, match_host, match_proto) {
        let result_obj = Obj::plain();
        {
            let mut b = result_obj.borrow_mut();
            let pathname_obj = Obj::plain();
            {
                let mut pb = pathname_obj.borrow_mut();
                pb.props.insert("input".into(), Value::str(target_pathname));
                let groups_obj = Obj::plain();
                {
                    let mut gb = groups_obj.borrow_mut();
                    for (name, value) in &groups {
                        gb.props.insert(name.clone(), Value::str(value.clone()));
                    }
                }
                pb.props.insert("groups".into(), Value::Object(groups_obj));
            }
            b.props.insert("pathname".into(), Value::Object(pathname_obj));
        }
        Ok(Value::Object(result_obj))
    } else {
        Ok(Value::Null)
    }
}