atmos/os_lib/js/builtins/

text_clone.rs

// 分割: builtins.rs より機械的に移動（2026-07-16 リファクタ フェーズ2）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;
// structuredClone が RegExp を複製する経路で使う（元は builtins.rs のファイル
// スコープ use で共有されていた。分割に伴い明示 import）。
use super::super::regex::{self, RegExpData};

// ===== TextEncoder / TextDecoder（UTF-8。Uint8Array を返す） =====
pub(crate) fn text_encode(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = arg(a, 0).to_js_string();
    Ok(make_uint8array(it, s.as_bytes().to_vec()))
}
/// `TextEncoder.prototype.encodeInto(source, destination)` が丸ごと未対応
/// だった（`encode()` は既に対応済みだったが、既存の `Uint8Array` バッファへ
/// 直接書き込むこちらの性能向けバリアントが欠けていた）。仕様どおり UTF-8
/// コードポイント境界で打ち切り（マルチバイト文字を途中で分割しない）、
/// `{read, written}`（`read` は消費した UTF-16 コード単位数、`written` は
/// 書き込んだバイト数）を返す。
pub(crate) fn text_encode_into(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let source = arg(a, 0).to_js_string();
    let dest = arg(a, 1);
    let Value::Object(dest_obj) = &dest else {
        return Ok(Value::Undefined);
    };
    let capacity = match &dest_obj.borrow().kind {
        ObjKind::Array(items) => items.len(),
        ObjKind::Bytes(st) => st.len,
        _ => 0,
    };
    let mut read_units = 0usize;
    let mut written_bytes: alloc::vec::Vec<u8> = alloc::vec::Vec::new();
    for c in source.chars() {
        let mut buf = [0u8; 4];
        let bytes = c.encode_utf8(&mut buf).as_bytes();
        if written_bytes.len() + bytes.len() > capacity {
            break;
        }
        written_bytes.extend_from_slice(bytes);
        read_units += c.len_utf16();
    }
    if let ObjKind::Bytes(st) = &dest_obj.borrow().kind {
        for (i, b) in written_bytes.iter().enumerate() {
            st.set(i, *b as f64);
        }
    }
    if let ObjKind::Array(items) = &mut dest_obj.borrow_mut().kind {
        for (i, b) in written_bytes.iter().enumerate() {
            if let Some(slot) = items.get_mut(i) {
                *slot = Value::Number(*b as f64);
            }
        }
    }
    let result = Obj::plain();
    {
        let mut b = result.borrow_mut();
        b.props.insert("read".into(), Value::Number(read_units as f64));
        b.props
            .insert("written".into(), Value::Number(written_bytes.len() as f64));
    }
    Ok(Value::Object(result))
}
/// `TextDecoder` のラベル正規化（WHATWG Encoding の簡易サブセット）。未知の
/// ラベルは寛容に `utf-8` へフォールバックする（この処理系の他のパース系と
/// 同水準の簡略化）。
pub(crate) fn normalize_text_encoding_label(label: &str) -> &'static str {
    match label.trim().to_lowercase().as_str() {
        "utf-16le" | "utf-16" => "utf-16le",
        "utf-16be" => "utf-16be",
        _ => "utf-8",
    }
}
/// UTF-16（LE/BE）のバイト列を Rust `String` へデコードする。不正な
/// サロゲートは仕様どおり置換文字（U+FFFD）に置き換える。
pub(crate) fn decode_utf16_bytes(bytes: &[u8], little_endian: bool) -> alloc::string::String {
    let units: alloc::vec::Vec<u16> = bytes
        .chunks(2)
        .map(|c| {
            let lo = *c.first().unwrap_or(&0) as u16;
            let hi = *c.get(1).unwrap_or(&0) as u16;
            if little_endian {
                lo | (hi << 8)
            } else {
                (lo << 8) | hi
            }
        })
        .collect();
    core::char::decode_utf16(units)
        .map(|r| r.unwrap_or(core::char::REPLACEMENT_CHARACTER))
        .collect()
}
/// UTF-8 バイト列の末尾が「まだ継続バイトが足りない不完全なマルチバイト
/// シーケンスの途中」かどうかを判定し、その未完了分のバイト数（0なら
/// 末尾は完結している）を返す。`TextDecoder.decode(chunk, {stream:true})`
/// が末尾のバイトを次回呼び出しへ持ち越すために使う。
pub(crate) fn utf8_incomplete_trailing_len(bytes: &[u8]) -> usize {
    let len = bytes.len();
    for back in 1..=3.min(len) {
        let b = bytes[len - back];
        if b & 0b1100_0000 == 0b1000_0000 {
            continue; // 継続バイト。さらに前を見る
        }
        let needed = if b & 0b1000_0000 == 0 {
            1
        } else if b & 0b1110_0000 == 0b1100_0000 {
            2
        } else if b & 0b1111_0000 == 0b1110_0000 {
            3
        } else if b & 0b1111_1000 == 0b1111_0000 {
            4
        } else {
            1 // 不正な先頭バイト。完結扱い（置換文字化に任せる）
        };
        return if needed > back { back } else { 0 };
    }
    0
}
/// `TextDecoder.prototype.decode()`。以前はコンストラクタに渡した encoding
/// ラベル（`new TextDecoder('utf-16le')` 等）を完全に無視し、常に UTF-8 として
/// デコードしていたバグだった（`utf-16` 系データを渡しても静かに文字化けする）。
/// **重要**: `decode(chunk, {stream: true})`（ストリーミングデコード。丸ごと
/// 未対応だった。チャンク境界でマルチバイト文字が分断された場合に文字化け
/// させず次回呼び出しへ持ち越す定番パターン）にも対応。`this._pending`
/// （隠しプロパティ）に前回分の未完了バイトを保持する。UTF-16 系は2バイト
/// 単位のため奇数バイト余りを同様に持ち越す。
pub(crate) fn text_decode(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let mut bytes: Vec<u8> = if let Value::Object(o) = &this {
        match o.borrow().props.get("_pending") {
            Some(Value::Object(p)) => match &p.borrow().kind {
                ObjKind::Array(items) => items.iter().map(|v| v.to_number() as u8).collect(),
                _ => Vec::new(),
            },
            _ => Vec::new(),
        }
    } else {
        Vec::new()
    };
    // `TextDecoder.decode(arrayBuffer)`（ビューではなく生の`ArrayBuffer`を
    // 直接渡す、仕様上有効な呼び出し形式）が常に空文字列を返すバグだった。
    // `iterable_values`は`ObjKind::Array`（TypedArray等）のみ扱い、生の
    // `ArrayBuffer`（`ObjKind::Plain`＋`_bytes`/`byteLength` props）は
    // 反復可能でないため素通りして空になっていた。`blob_part_bytes`
    // （`crypto.subtle.digest`等でも使う共通ヘルパー）に差し替えることで
    // `_bytes`を持つ`ArrayBuffer`からも実際のバイト列を読めるようにする
    // （TypedArray/配列/文字列の既存の挙動は維持）。2026-07-18 発見・実装。
    let mut arg0_bytes_f64 = alloc::vec::Vec::new();
    blob_part_bytes(&arg(a, 0), &mut arg0_bytes_f64);
    bytes.extend(arg0_bytes_f64.iter().map(|v| *v as i64 as u8));
    let stream = obj_prop(&arg(a, 1), "stream").map(|v| v.truthy()).unwrap_or(false);
    let enc = if let Value::Object(o) = &this {
        o.borrow()
            .props
            .get("encoding")
            .map(|v| v.to_js_string())
            .unwrap_or_else(|| String::from("utf-8"))
    } else {
        String::from("utf-8")
    };
    let pending_len = if stream {
        match enc.as_str() {
            "utf-16le" | "utf-16be" => bytes.len() % 2,
            _ => utf8_incomplete_trailing_len(&bytes),
        }
    } else {
        0
    };
    let ready_len = bytes.len() - pending_len;
    let (ready, pending) = bytes.split_at(ready_len);
    if let Value::Object(o) = &this {
        let pending_vals: Vec<Value> = pending.iter().map(|&b| Value::Number(b as f64)).collect();
        o.borrow_mut()
            .props
            .insert("_pending".into(), Value::Object(Obj::array(pending_vals)));
    }
    let decoded = match enc.as_str() {
        "utf-16le" => decode_utf16_bytes(ready, true),
        "utf-16be" => decode_utf16_bytes(ready, false),
        _ => alloc::string::String::from_utf8_lossy(ready).into_owned(),
    };
    Ok(Value::str(decoded))
}
pub(crate) fn text_encoder_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("encoding".into(), Value::str("utf-8"));
        b.props.insert("encode".into(), nv("encode", text_encode));
        b.props
            .insert("encodeInto".into(), nv("encodeInto", text_encode_into));
    }
    Ok(Value::Object(o))
}
/// `new TextDecoder(label)` が丸ごと引数を無視し常に `utf-8` 決め打ちだった
/// バグ（詳細は `text_decode`/`normalize_text_encoding_label` のコメント参照）。
pub(crate) fn text_decoder_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let label = arg(a, 0).to_js_string();
    let enc = if label.is_empty() {
        "utf-8"
    } else {
        normalize_text_encoding_label(&label)
    };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("encoding".into(), Value::str(enc));
        b.props.insert("decode".into(), nv("decode", text_decode));
    }
    Ok(Value::Object(o))
}

// ===== crypto =====
/// `URL.createObjectURL(blob_or_media_source)`（`Blob`/`File`/`MediaSource` を一意な `blob:` URL 文字列へ
/// 変換する定番パターン。`<video src=URL.createObjectURL(ms)>` や `<img src=URL.createObjectURL(blob)>`
/// で広く使われる）。MediaSource の場合はグローバルの `__media_source_urls` に登録し、
/// `<video>`/`<audio>` に割り当てられた際に sourceopen を自動発火できるようにする。
pub(crate) fn url_create_object_url(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let target = arg(a, 0);
    let is_media_source = if let Value::Object(o) = &target {
        let borrow = o.borrow();
        borrow.props.contains_key("sourceBuffers")
            || borrow.props.get("_is_media_source").map(|v| v.truthy()).unwrap_or(false)
    } else {
        false
    };

    let id = crypto_random_uuid(it, t, &[])?.to_js_string();
    let url = if is_media_source {
        alloc::format!("blob:mediasource-{}", id)
    } else {
        alloc::format!("blob:{}", id)
    };

    if is_media_source {
        let existing = match it.global.borrow().vars.get("__media_source_urls") {
            Some(Value::Object(r)) => Some(r.clone()),
            _ => None,
        };
        let registry = match existing {
            Some(r) => r,
            None => {
                let r = Obj::plain();
                it.global.borrow_mut().vars.insert("__media_source_urls".into(), Value::Object(r.clone()));
                r
            }
        };
        super::mse::register_media_source_url(&url, &target);
        registry.borrow_mut().props.insert(url.clone(), target);
    } else {
        let is_blob = if let Value::Object(o) = &target {
            o.borrow().props.contains_key("_blob_bytes")
        } else {
            false
        };
        if is_blob {
            let existing = match it.global.borrow().vars.get("__blob_urls") {
                Some(Value::Object(r)) => Some(r.clone()),
                _ => None,
            };
            let registry = match existing {
                Some(r) => r,
                None => {
                    let r = Obj::plain();
                    it.global.borrow_mut().vars.insert("__blob_urls".into(), Value::Object(r.clone()));
                    r
                }
            };
            registry.borrow_mut().props.insert(url.clone(), target);
        }
    }

    Ok(Value::str(url))
}
/// `URL.revokeObjectURL(url)`。`__media_source_urls` および `__blob_urls` から解除する。
pub(crate) fn url_revoke_object_url(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let url = arg(a, 0).to_js_string();
    if let Some(Value::Object(registry)) = it.global.borrow().vars.get("__media_source_urls") {
        registry.borrow_mut().props.shift_remove(&url);
    }
    if let Some(Value::Object(registry)) = it.global.borrow().vars.get("__blob_urls") {
        registry.borrow_mut().props.shift_remove(&url);
    }
    Ok(Value::Undefined)
}
pub(crate) fn crypto_random_uuid(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let mut bytes = [0u8; 16];
    for b in bytes.iter_mut() {
        *b = (next_rand_u64() & 0xff) as u8;
    }
    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 10
    let mut s = String::new();
    for (i, b) in bytes.iter().enumerate() {
        if i == 4 || i == 6 || i == 8 || i == 10 {
            s.push('-');
        }
        s.push_str(&format!("{:02x}", b));
    }
    Ok(Value::str(s))
}
/// `crypto.getRandomValues(typedArray)`。以前は種別を無視して全要素を無条件に
/// `& 0xff`（0-255）で埋めており、`Int16Array`/`Int32Array`/`Uint32Array` 等
/// 8bit より広い型に対しては本来の値域のごく一部（下位8bitのみ、常に非負）しか
/// 埋められない、実質的にランダム性が大幅に弱まるバグだった。`_ta_kind` タグから
/// 種別を復元し、コンストラクタ/`set`/索引代入と同じ `TaKind::convert()` で
/// 型ごとの正しい値域に変換する。
pub(crate) fn crypto_get_random_values(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let v = arg(a, 0);
    if let Value::Object(o) = &v {
        let kind = o
            .borrow()
            .props
            .get("_ta_kind")
            .map(|v| v.to_js_string())
            .map(|tag| TaKind::from_name(tag.as_str()));
        if let ObjKind::Bytes(st) = &o.borrow().kind {
            for i in 0..st.len {
                st.set(i, (next_rand_u64() & 0xff) as f64);
            }
            return Ok(v.clone());
        }
        let mut b = o.borrow_mut();
        if let ObjKind::Array(items) = &mut b.kind {
            for it2 in items.iter_mut() {
                let raw = Value::Number(next_rand_u64() as f64);
                *it2 = Value::Number(match kind {
                    Some(k) => k.convert(&raw),
                    None => (next_rand_u64() & 0xff) as f64,
                });
            }
        }
    }
    Ok(v)
}

// ===== structuredClone（深いコピー。関数等の特殊種別は plain object に退化）=====
/// `structuredClone` は仕様上、循環参照（`var a={}; a.self=a;`）や同一オブジェクトへの
/// 複数参照（構造の共有）を正しく扱う必要がある。以前はそのための「複製済みオブジェクトの
/// 記録」を一切持たず単純な再帰だけだったため、循環参照ではスタックオーバーフロー
/// （この no_std カーネル環境ではクラッシュ/ハングになり得る）に陥っていた。
/// `seen` に (元オブジェクト, 複製先オブジェクト) を積みながら辿ることで、複製先の
/// 入れ物を先に作ってから中身を埋める（＝自己参照が現れた時点で既に登録済みにする）。
pub(crate) fn deep_clone_value(
    it: &mut Interp,
    v: &Value,
    seen: &mut Vec<(super::super::value::ObjRef, super::super::value::ObjRef)>,
) -> Result<Value, Value> {
    deep_clone_value_depth(it, v, seen, 0)
}

fn deep_clone_value_depth(
    it: &mut Interp,
    v: &Value,
    seen: &mut Vec<(super::super::value::ObjRef, super::super::value::ObjRef)>,
    depth: usize,
) -> Result<Value, Value> {
    // 閾値30は、この関数がRustのネイティブ再帰で実装されているため
    // JSの`max_steps`予算では防げない「Rustコールスタック自体のオーバーフロー」
    // に対するガードとして機能する。ブート時点の`boot.S`初期コアスタックが
    // わずか64KB（`(CoreID+1)*64KB`）しか無く、深い再帰がチェック到達前に
    // スタックを枯渇させることを防止する。
    // ※ 以前 `seen.len() > 30` でチェックしていたが、`seen` は累積の
    // クローン済みオブジェクト数であるため、フラットな大配列（要素数>30）でも
    // 誤ってエラーになるバグがあった。そのため再帰深さ `depth` で判定する。
    if depth > 30 {
        return Err(make_dom_exception("DataCloneError", "Exceeded maximum call stack size / nesting depth limit"));
    }
    let error_proto = match it.global.borrow().vars.get("Error") {
        Some(Value::Object(ctor)) => match ctor.borrow().props.get("prototype") {
            Some(Value::Object(p)) => Some(p.clone()),
            _ => None,
        },
        _ => None,
    };
    match v {
        Value::Object(o) => {
            if let Some((_, cloned)) = seen.iter().find(|(orig, _)| Rc::ptr_eq(orig, o)) {
                return Ok(Value::Object(cloned.clone()));
            }
            // 関数（`ObjKind::NativeFn`/`Closure`）は仕様上そもそも構造化複製
            // 不可（`DataCloneError`）。以前は例外機構が無いという理由で他の
            // 型（`Proxy`等）と同様「target へフォワード」する簡略実装が
            // 検討されたが、関数には複製すべき target が無いため、汎用の
            // plain object 複製に落ちて「呼出不能な壊れたオブジェクト」に
            // 静かに化けるだけの実害しかなかった。`structured_clone`側は既に
            // `Result`を返す口があるため、ここで素直に`DataCloneError`を
            // 投げるよう修正（2026-07-17 発見・実装）。
            if o.borrow().is_callable() {
                return Err(make_dom_exception("DataCloneError", "could not be cloned"));
            }
            // `Promise`も仕様上構造化複製不可（`DataCloneError`）。実データが
            // `.props`ではなく`ObjKind::PromiseObj`側にあるため、他の分岐に
            // 落ちずここで先に処理しないと「`.props`だけをコピーする plain
            // object化」に落ちて、`.then`/`.catch`（`ObjKind::PromiseObj`を
            // 見て動的振り分けする実装のため`.props`には無い）が消えた
            // 呼出不能な壊れたオブジェクトに静かに化ける（`Proxy`等と同種の
            // 実害だが、`Proxy`と違い正しい簡略転送先が無いため素直に
            // `DataCloneError`とする。2026-07-17 発見・実装）。
            if matches!(&o.borrow().kind, ObjKind::PromiseObj(_)) {
                return Err(make_dom_exception("DataCloneError", "could not be cloned"));
            }
            // `Proxy` は実データが `.props` ではなく `ObjKind::Proxy { target, .. }` 側に
            // あるため、他の分岐に落ちずここで先に処理しないと「`.props` だけでコピーする
            // plain object 化」に落ちて、常に空の `{}` に化ける壊れたクローンになる
            // （`Date`/`Map`/`Set`/`TypedArray`/`Blob` 等で修正済みの「実体が消える」系と
            // 同種のバグ）。仕様上 `Proxy` はそもそも構造化複製不可（`DataClone` エラー）
            // だが、この処理系に例外機構の対応する仕組みが無いため、他の Proxy 透過性
            // 修正（`Array.isArray`/`Object.keys` 等）と同じ「target へフォワード」方針で
            // target を複製する簡略実装とする。
            if matches!(&o.borrow().kind, ObjKind::Proxy { .. }) {
                let target = unwrap_proxy_target(o);
                let cloned = deep_clone_value_depth(it, &Value::Object(target), seen, depth + 1)?;
                if let Value::Object(c) = &cloned {
                    seen.push((o.clone(), c.clone()));
                }
                return Ok(cloned);
            }
            // `Date`/`RegExp` は実データが `props` ではなく `ObjKind::DateObj`/`RegExpObj`
            // 側にあるため、他の分岐に落ちずここで先に処理しないと「`.props` だけを
            // コピーする plain object 化」に落ちて実データの消えた壊れたオブジェクトになる
            // （`Map`/`Set` で過去に修正した同種のバグ）。`structuredClone(new Date())` が
            // `{}` になる、`structuredClone(/re/g)` がパターンの消えた空オブジェクトになる、
            // という実害があった。
            if let ObjKind::DateObj(ms) = &o.borrow().kind {
                return Ok(Value::Object(Obj::date_obj(*ms)));
            }
            let regex_info = match &o.borrow().kind {
                ObjKind::RegExpObj(r) => {
                    let d = r.borrow();
                    Some((d.re.source.clone(), d.re.flags.clone(), d.last_index))
                }
                _ => None,
            };
            if let Some((source, flags, last_index)) = regex_info {
                let re = regex::Regex::new(&source, &flags);
                return Ok(Value::Object(Obj::regexp(RegExpData { re, last_index })));
            }
            // 1 バイト型 TypedArray（記憶域）はバイト列を写した新しい記憶域で複製する。
            let bytes_ta = match &o.borrow().kind {
                ObjKind::Bytes(st) => Some(st.clone()),
                _ => None,
            };
            if let Some(st) = bytes_ta {
                let tag = o.borrow().props.get("_ta_kind").map(|v| v.to_js_string()).unwrap_or_default();
                let new_val = super::typed_array::make_bytes_ta(
                    it,
                    crate::os_lib::js::value::ByteStore::new(st.to_vec(), st.kind),
                    TaKind::from_name(tag.as_str()),
                );
                if let Value::Object(new) = &new_val {
                    seen.push((o.clone(), new.clone()));
                }
                return Ok(new_val);
            }
            let is_array = matches!(&o.borrow().kind, ObjKind::Array(_));
            if is_array {
                // TypedArray も内部表現は `ObjKind::Array` を流用しており（`_ta_kind`
                // タグで種別を区別）、この分岐が `.props` を一切コピーせず素の
                // `Obj::array` を作るだけだったため、`structuredClone(new Int8Array(...))`
                // は `_ta_kind`/`BYTES_PER_ELEMENT`/`set`/`slice`/`fill` 等が全て失われた
                // 「ただの配列」に化けてしまうバグだった（`Date`/`RegExp`/`Map`/`Set` で
                // 過去に修正した「plain object 化で実体が消える」系と同種）。
                let ta_kind_tag = o.borrow().props.get("_ta_kind").map(|v| v.to_js_string());
                if let Some(tag) = ta_kind_tag {
                    let items = match &o.borrow().kind {
                        ObjKind::Array(items) => items.iter().map(|v| v.to_number()).collect(),
                        _ => unreachable!(),
                    };
                    let new_val = make_typed_array(it, items, TaKind::from_name(tag.as_str()));
                    if let Value::Object(new) = &new_val {
                        seen.push((o.clone(), new.clone()));
                    }
                    return Ok(new_val);
                }
                let new = Obj::array(Vec::new());
                seen.push((o.clone(), new.clone()));
                let items = match &o.borrow().kind {
                    ObjKind::Array(items) => items.clone(),
                    _ => unreachable!(),
                };
                let mut cloned_items: Vec<Value> = Vec::with_capacity(items.len());
                for x in &items {
                    cloned_items.push(deep_clone_value_depth(it, x, seen, depth + 1)?);
                }
                if let ObjKind::Array(v) = &mut new.borrow_mut().kind {
                    *v = cloned_items;
                }
                return Ok(Value::Object(new));
            }
            // Map/Set は「`.props` だけをコピーする plain object 化」に落ちると、実データが
            // 入っている ObjKind::MapObj/SetObj 自体は複製されず中身が消えた壊れた
            // オブジェクトになる実害のあるバグだった（過去に修正済み）。
            let is_map = matches!(&o.borrow().kind, ObjKind::MapObj(_));
            if is_map {
                let new = Obj::map_obj(Vec::new());
                seen.push((o.clone(), new.clone()));
                let entries = match &o.borrow().kind {
                    ObjKind::MapObj(e) => e.clone(),
                    _ => unreachable!(),
                };
                let mut cloned: Vec<(Value, Value)> = Vec::with_capacity(entries.len());
                for (k, val) in &entries {
                    let ck = deep_clone_value_depth(it, k, seen, depth + 1)?;
                    let cv = deep_clone_value_depth(it, val, seen, depth + 1)?;
                    cloned.push((ck, cv));
                }
                if let ObjKind::MapObj(e) = &mut new.borrow_mut().kind {
                    *e = cloned;
                }
                return Ok(Value::Object(new));
            }
            let is_set = matches!(&o.borrow().kind, ObjKind::SetObj(_));
            if is_set {
                let new = Obj::set_obj(Vec::new());
                seen.push((o.clone(), new.clone()));
                let items = match &o.borrow().kind {
                    ObjKind::SetObj(s) => s.clone(),
                    _ => unreachable!(),
                };
                let mut cloned: Vec<Value> = Vec::with_capacity(items.len());
                for x in &items {
                    cloned.push(deep_clone_value_depth(it, x, seen, depth + 1)?);
                }
                if let ObjKind::SetObj(s) = &mut new.borrow_mut().kind {
                    *s = cloned;
                }
                return Ok(Value::Object(new));
            }
            // `Blob`/`DataView` も `Obj::plain()` + 隠しプロパティで実データを持つ実装
            // のため、汎用の plain object 複製（全 `.props` を再帰複製）に落ちると、
            // `slice`/`text`/`arrayBuffer`/`getUint8` 等のネイティブ関数プロパティが
            // 「関数ではない別の空オブジェクト」として複製されてしまい、複製結果が
            // 呼出不能な壊れたオブジェクトになるバグだった（`Date`/`RegExp`/`Map`/`Set`/
            // `TypedArray` で修正済みの「実体が消える」系と同種）。
            if let Some(Value::Object(bytes_obj)) = o.borrow().props.get("_blob_bytes").cloned() {
                let bytes: alloc::vec::Vec<f64> = match &bytes_obj.borrow().kind {
                    ObjKind::Array(items) => items.iter().map(|v| v.to_number()).collect(),
                    _ => alloc::vec::Vec::new(),
                };
                let mime = o.borrow().props.get("type").map(|v| v.to_js_string()).unwrap_or_default();
                // `File`（`Blob`を継承し`name`/`lastModified`を追加する
                // `file_ctor`由来のオブジェクト）を複製すると、`Blob`分岐に
                // 落ちて`name`/`lastModified`が失われ、素の`Blob`へ格下げ
                // されるバグだった（`structuredClone(new File(...))`
                // `.name`が`undefined`になる「実体が消える」系の派生バグ。
                // 2026-07-17 発見・実装）。`name`プロパティの有無を`File`か
                // `Blob`かの目印として使い、`File`なら追加で引き継ぐ。
                // `webkitRelativePath`（2026-07-17 追加）も同じ理由で
                // 一緒に引き継ぐ。
                let file_meta = o.borrow().props.get("name").cloned().map(|name| {
                    let last_modified =
                        o.borrow().props.get("lastModified").cloned().unwrap_or(Value::Number(0.0));
                    let webkit_relative_path =
                        o.borrow().props.get("webkitRelativePath").cloned().unwrap_or_else(|| Value::str(""));
                    (name, last_modified, webkit_relative_path)
                });
                let new_val = make_blob(bytes, mime);
                if let (Value::Object(new), Some((name, last_modified, webkit_relative_path))) = (&new_val, file_meta) {
                    new.borrow_mut().props.insert("name".into(), name);
                    new.borrow_mut().props.insert("lastModified".into(), last_modified);
                    new.borrow_mut().props.insert("webkitRelativePath".into(), webkit_relative_path);
                }
                if let Value::Object(new) = &new_val {
                    seen.push((o.clone(), new.clone()));
                }
                return Ok(new_val);
            }
            if o.borrow().props.contains_key("_dv_bytes") {
                let byte_values: alloc::vec::Vec<Value> = super::typed_array::dv_slice_bytes(o)
                    .unwrap_or_default()
                    .into_iter()
                    .map(Value::Number)
                    .collect();
                let new_buffer = make_arraybuffer_with_bytes(byte_values.iter().map(|v| v.to_number()).collect());
                let new_val = make_dataview(new_buffer, 0, byte_values);
                if let Value::Object(new) = &new_val {
                    seen.push((o.clone(), new.clone()));
                }
                return Ok(new_val);
            }
            // `ArrayBuffer` も同じ理由（`slice` がネイティブ関数プロパティ）で複製が
            // 壊れる対象だった。`byteLength`+`slice` の組合せを `ArrayBuffer` の目印に
            // 使う（この2つを両方持つのは `make_arraybuffer()` 由来のオブジェクトのみ）。
            let is_arraybuffer = {
                let b = o.borrow();
                b.props.contains_key("byteLength")
                    && matches!(b.props.get("slice"), Some(Value::Object(f)) if f.borrow().is_callable())
            };
            if is_arraybuffer {
                // resizable な ArrayBuffer（ES2024。`.resizable`/`.maxByteLength`/
                // `.resize()`）は複製時に非resizableな新規バッファへ落ちて
                // いたバグだった（`make_arraybuffer_with_bytes`は常に
                // 固定長版を作るため、`structuredClone(resizableBuf).resizable`
                // が`false`になり`.resize()`も呼べなくなる「実体が消える」系の
                // 派生バグ。2026-07-17 発見）。`make_arraybuffer_ex`で元の
                // `resizable`/`maxByteLength`を引き継ぐよう修正。
                let is_resizable = matches!(o.borrow().props.get("resizable"), Some(Value::Bool(true)));
                let max_byte_length = o.borrow().props.get("maxByteLength").map(|v| v.to_number() as usize);
                let bytes_prop = o.borrow().props.get("_bytes").cloned();
                let byte_length = o
                    .borrow()
                    .props
                    .get("byteLength")
                    .map(|v| v.to_number() as usize)
                    .unwrap_or(0);
                let new_val = make_arraybuffer_ex(byte_length, if is_resizable { max_byte_length } else { None });
                if let (Value::Object(new), Some(Value::Object(bytes_obj))) = (&new_val, &bytes_prop) {
                    let bytes = super::typed_array::obj_byte_values(bytes_obj).unwrap_or_default();
                    new.borrow_mut().props.insert(
                        "_bytes".into(),
                        Value::Object(Obj::bytes(crate::os_lib::js::value::ByteStore::new(bytes, 0))),
                    );
                }
                if let Value::Object(new) = &new_val {
                    seen.push((o.clone(), new.clone()));
                }
                return Ok(new_val);
            }
            // `Error`（とそのサブタイプ）も同じ理由（汎用 plain object 複製に落ちると
            // proto が引き継がれない）で複製が壊れるバグだった。`Error` 自体には
            // 専用の `ObjKind` が無く `message`/`name`/`stack` を持つ通常の `props`
            // オブジェクトのため、他の型と違って実データが消えるわけではないが、
            // `structuredClone(new TypeError('x')) instanceof Error` が `false` に
            // なる（プロトタイプ連鎖が Error.prototype に繋がらない）という実害が
            // あった（2026-07-14、`Error.prototype.stack` 実装時の点検で発見）。
            // この処理系は単一レルムのため、元オブジェクトの proto（`TypeError.
            // prototype` 等）をそのまま複製先へ引き継いでよい。
            let is_error = error_proto.as_ref().is_some_and(|ep| {
                let mut cur = o.borrow().proto.clone();
                let mut guard = 0;
                while let Some(c) = cur {
                    if Rc::ptr_eq(&c, ep) {
                        return true;
                    }
                    cur = c.borrow().proto.clone();
                    guard += 1;
                    if guard > 1000 {
                        break;
                    }
                }
                false
            });
            let new = Obj::plain();
            if is_error {
                new.borrow_mut().proto = o.borrow().proto.clone();
            }
            seen.push((o.clone(), new.clone()));
            let props: Vec<(String, Value)> =
                o.borrow().props.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
            for (k, val) in props {
                let cv = deep_clone_value_depth(it, &val, seen, depth + 1)?;
                new.borrow_mut().props.insert(k, cv);
            }
            Ok(Value::Object(new))
        }
        other => Ok(other.clone()),
    }
}
/// `structuredClone(value, {transfer: [...]})` の第2引数 `transfer` が丸ごと
/// 無視されていた。実際のメモリ移動は行わない簡略実装だが、転送対象の
/// `ArrayBuffer` の `.detached` を `true` にし内部バイト列を破棄することで
/// `ArrayBuffer.prototype.transfer()` 自身の「二重 transfer はエラー」という
/// 既存チェック（`arraybuffer_transfer_impl`）とは整合する状態にする
/// （`slice()`/`byteLength` 自体が `detached` を見ない、という既存の簡略化は
/// そのまま踏襲する）。
pub(crate) fn structured_clone(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut seen = Vec::new();
    let result = deep_clone_value(it, &arg(a, 0), &mut seen)?;
    if let Value::Object(opts) = arg(a, 1) {
        let transfer_list = opts.borrow().props.get("transfer").cloned();
        if let Some(list) = transfer_list {
            for item in this_items(&list) {
                if let Value::Object(o) = &item {
                    let is_arraybuffer = {
                        let b = o.borrow();
                        b.props.contains_key("byteLength")
                            && matches!(b.props.get("slice"), Some(Value::Object(f)) if f.borrow().is_callable())
                    };
                    if is_arraybuffer {
                        let mut b = o.borrow_mut();
                        b.props.insert("detached".into(), Value::Bool(true));
                        b.props.shift_remove("_bytes");
                    }
                }
            }
        }
    }
    Ok(result)
}