atmos/os_lib/js/

builtins.rs

//! JS 標準ライブラリ（実用コア）。
//!
//! グローバル関数・console・Math・JSON と、文字列/配列/オブジェクトのメソッドを
//! ネイティブ関数として提供する。メソッドは `this`（レシーバ）を受け取る。

use alloc::format;
use alloc::rc::Rc;
use alloc::string::String;
use alloc::string::ToString;
use alloc::vec;
use alloc::vec::Vec;
use core::cell::RefCell;
use core::sync::atomic::{AtomicU64, Ordering};

use super::interp::{Interp, Scope};
use super::value::*;

/// `window.` 経由でも読めるようにするグローバル名。
///
/// ブラウザではグローバルと `window` のプロパティは同じ物を指す。
/// この処理系は別々に持っているので、写して差を埋める。
const WINDOW_MIRRORED_GLOBALS: &[&str] = &[
    "navigator", "screen", "location", "document", "history",
    "localStorage", "sessionStorage", "performance", "console",
    "JSON", "Math", "Date", "Promise", "Array", "Object", "String",
    "Number", "Boolean", "RegExp", "Error", "Map", "Set", "Symbol",
    "XMLHttpRequest", "URL", "URLSearchParams", "Path2D", "ImageData", "Range", "NodeFilter",
    "customElements", "ReadableStream", "WritableStream", "TransformStream", "MediaSource", "Worker",
    "TextEncoderStream", "TextDecoderStream",
];

/// `Array.prototype` に並べるメソッド名。
///
/// 実体は `props_methods::object_get` が返す同じ関数を指す。
const ARRAY_PROTO_METHODS: &[&str] = &[
    "push", "pop", "shift", "unshift", "slice", "splice", "concat",
    "join", "reverse", "sort", "indexOf", "lastIndexOf", "includes",
    "find", "findIndex", "findLast", "findLastIndex", "filter", "map",
    "forEach", "reduce", "reduceRight", "some", "every", "flat",
    "flatMap", "fill", "copyWithin", "at", "keys", "values", "entries",
    "toString",
];

/// グローバルスコープへ組込みを登録。
/// `String.prototype` に並べるメソッド名。
///
/// 実体は `props_methods::string_get` が返す同じ関数を指す。
/// ここに無いものはプロトタイプ経由では読めないが、
/// 実体（`"x".foo()`）からは従来どおり解決できる。
const STRING_PROTO_METHODS: &[&str] = &[
    "charAt", "charCodeAt", "codePointAt", "localeCompare", "indexOf",
    "lastIndexOf", "includes", "startsWith", "endsWith", "slice",
    "substring", "substr", "toUpperCase", "toLowerCase", "trim",
    "trimStart", "trimEnd", "split", "replace", "replaceAll", "match",
    "matchAll", "search", "repeat", "concat", "padStart", "padEnd",
    "at", "toString", "valueOf", "normalize",
];

pub fn install(global: &Rc<RefCell<Scope>>) {
    let mut g = global.borrow_mut();

    // console
    let console = Obj::plain();
    {
        let mut c = console.borrow_mut();
        c.props.insert("log".into(), nv("console.log", console_log));
        c.props
            .insert("error".into(), nv("console.error", console_log));
        c.props
            .insert("warn".into(), nv("console.warn", console_log));
        c.props
            .insert("info".into(), nv("console.info", console_log));
        c.props
            .insert("debug".into(), nv("console.debug", console_log));
        c.props
            .insert("trace".into(), nv("console.trace", console_log));
        c.props.insert("dir".into(), nv("console.dir", console_log));
        c.props
            .insert("table".into(), nv("console.table", console_log));
        c.props
            .insert("group".into(), nv("console.group", console_log));
        c.props
            .insert("groupEnd".into(), nv("console.groupEnd", dom_noop));
        c.props.insert(
            "groupCollapsed".into(),
            nv("console.groupCollapsed", console_log),
        );
        c.props
            .insert("count".into(), nv("console.count", dom_noop));
        c.props
            .insert("assert".into(), nv("console.assert", console_log));
        c.props.insert("time".into(), nv("console.time", dom_noop));
        c.props
            .insert("timeEnd".into(), nv("console.timeEnd", dom_noop));
    }
    g.vars.insert("console".into(), Value::Object(console));

    // Math
    let math = Obj::plain();
    {
        let mut m = math.borrow_mut();
        m.props
            .insert("PI".into(), Value::Number(core::f64::consts::PI));
        m.props
            .insert("E".into(), Value::Number(core::f64::consts::E));
        m.props.insert("floor".into(), nv("Math.floor", math_floor));
        m.props.insert("ceil".into(), nv("Math.ceil", math_ceil));
        m.props.insert("round".into(), nv("Math.round", math_round));
        m.props.insert("trunc".into(), nv("Math.trunc", math_trunc));
        m.props.insert("abs".into(), nv("Math.abs", math_abs));
        m.props.insert("sign".into(), nv("Math.sign", math_sign));
        m.props.insert("sqrt".into(), nv("Math.sqrt", math_sqrt));
        m.props.insert("pow".into(), nv("Math.pow", math_pow));
        m.props.insert("min".into(), nv("Math.min", math_min));
        m.props.insert("max".into(), nv("Math.max", math_max));
        m.props
            .insert("random".into(), nv("Math.random", math_random));
        m.props.insert("sin".into(), nv("Math.sin", math_sin));
        m.props.insert("cos".into(), nv("Math.cos", math_cos));
        m.props.insert("tan".into(), nv("Math.tan", math_tan));
        m.props.insert("asin".into(), nv("Math.asin", math_asin));
        m.props.insert("acos".into(), nv("Math.acos", math_acos));
        m.props.insert("atan".into(), nv("Math.atan", math_atan));
        m.props.insert("atan2".into(), nv("Math.atan2", math_atan2));
        m.props.insert("log".into(), nv("Math.log", math_log));
        m.props.insert("log2".into(), nv("Math.log2", math_log2));
        m.props.insert("log10".into(), nv("Math.log10", math_log10));
        m.props.insert("cbrt".into(), nv("Math.cbrt", math_cbrt));
        m.props.insert("hypot".into(), nv("Math.hypot", math_hypot));
        m.props.insert("exp".into(), nv("Math.exp", math_exp));
        m.props.insert("fround".into(), nv("Math.fround", math_fround));
        m.props.insert("f16round".into(), nv("Math.f16round", math_f16round));
        m.props.insert("clamp".into(), nv("Math.clamp", math_clamp));
        m.props.insert("sumPrecise".into(), nv("Math.sumPrecise", math_sum_precise));
        m.props.insert("clz32".into(), nv("Math.clz32", math_clz32));
        m.props.insert("imul".into(), nv("Math.imul", math_imul));
        m.props.insert("sinh".into(), nv("Math.sinh", math_sinh));
        m.props.insert("cosh".into(), nv("Math.cosh", math_cosh));
        m.props.insert("tanh".into(), nv("Math.tanh", math_tanh));
        m.props.insert("asinh".into(), nv("Math.asinh", math_asinh));
        m.props.insert("acosh".into(), nv("Math.acosh", math_acosh));
        m.props.insert("atanh".into(), nv("Math.atanh", math_atanh));
        m.props.insert("expm1".into(), nv("Math.expm1", math_expm1));
        m.props.insert("log1p".into(), nv("Math.log1p", math_log1p));
        // `Math.LN2`/`LN10`/`LOG2E`/`LOG10E`/`SQRT2`/`SQRT1_2`（ES1 以来の定数群）が
        // `PI`/`E` 以外一つも登録されておらず丸ごと未対応だった。
        m.props.insert("LN2".into(), Value::Number(core::f64::consts::LN_2));
        m.props.insert("LN10".into(), Value::Number(core::f64::consts::LN_10));
        m.props.insert("LOG2E".into(), Value::Number(core::f64::consts::LOG2_E));
        m.props.insert("LOG10E".into(), Value::Number(core::f64::consts::LOG10_E));
        m.props.insert("SQRT2".into(), Value::Number(core::f64::consts::SQRT_2));
        m.props.insert("SQRT1_2".into(), Value::Number(1.0 / core::f64::consts::SQRT_2));
        m.props
            .insert("PI".into(), Value::Number(core::f64::consts::PI));
        m.props
            .insert("E".into(), Value::Number(core::f64::consts::E));
    }
    g.vars.insert("Math".into(), Value::Object(math));

    // `Intl`（`Intl.NumberFormat`/`Intl.DateTimeFormat`/`Intl.Collator` 等）が
    // グローバルオブジェクトに丸ごと存在しなかった。ロケール辞書・タイムゾーン
    // データベースを伴う本格実装は本キャンペーンの規模を超えるため、既に実装
    // 済みの `Number.prototype.toLocaleString`（既定の3桁カンマ区切り）を
    // `.format()` から呼べるようにする最小限の `Intl.NumberFormat` のみを追加し、
    // `new Intl.NumberFormat().format(n)` という最頻出イディオムだけを救う
    // （`DateTimeFormat`/`Collator`/ロケール・オプション引数は非対応のまま）。
    g.vars.insert("Intl".into(), create_intl_object());

    // `CSS.escape(str)`（CSSOM。`document.querySelector('#' + CSS.escape(userId))`
    // という定番イディオムで使われる）が `CSS` 名前空間自体丸ごと未対応だった。
    // `CSS.supports()`（`@supports` の条件式評価を実装した際に新設した
    // `css::supports_condition_matches` をそのまま再利用できるようになったため
    // 追加。かつては「CSS エンジンとの結合が必要で改修規模が異なる」として
    // 対象外にしていたが、その結合自体が既に完了済みとなった）。
    {
        let css_ns = Obj::plain();
        css_ns
            .borrow_mut()
            .props
            .insert("escape".into(), nv("CSS.escape", css_escape_static));
        css_ns
            .borrow_mut()
            .props
            .insert("supports".into(), nv("CSS.supports", css_supports_static));
        // `CSS.number()`/`.percent()`/`.px()`/`.em()`/`.rem()`/`.deg()`
        // （CSS Typed OM のうち値+単位オブジェクトを構築するだけの
        // ファクトリ関数群。丸ごと未対応だった。詳細は`regexp.rs`の
        // `make_css_unit_value`参照。2026-07-18 発見・実装）。
        {
            let mut b = css_ns.borrow_mut();
            b.props.insert("number".into(), nv("CSS.number", css_number_static));
            b.props.insert("percent".into(), nv("CSS.percent", css_percent_static));
            b.props.insert("px".into(), nv("CSS.px", css_px_static));
            b.props.insert("em".into(), nv("CSS.em", css_em_static));
            b.props.insert("rem".into(), nv("CSS.rem", css_rem_static));
            b.props.insert("deg".into(), nv("CSS.deg", css_deg_static));
        }
        g.vars.insert("CSS".into(), Value::Object(css_ns));
    }

    // JSON
    let json = Obj::plain();
    {
        let mut j = json.borrow_mut();
        j.props.insert("parse".into(), nv("JSON.parse", json_parse));
        j.props
            .insert("stringify".into(), nv("JSON.stringify", json_stringify));
        // `JSON.rawJSON`/`JSON.isRawJSON`（ES2025）が丸ごと未対応だった。
        // 2026-07-18 発見・実装。
        j.props
            .insert("rawJSON".into(), nv("JSON.rawJSON", json_raw_json));
        j.props
            .insert("isRawJSON".into(), nv("JSON.isRawJSON", json_is_raw_json));
    }
    g.vars.insert("JSON".into(), Value::Object(json));

    // Object（コンストラクタ兼名前空間）
    let object_ctor = Obj::native("Object", object_ctor);
    object_ctor
        .borrow_mut()
        .props
        .insert("keys".into(), nv("Object.keys", object_keys));
    object_ctor
        .borrow_mut()
        .props
        .insert("values".into(), nv("Object.values", object_values));
    object_ctor
        .borrow_mut()
        .props
        .insert("entries".into(), nv("Object.entries", object_entries));
    object_ctor
        .borrow_mut()
        .props
        .insert("assign".into(), nv("Object.assign", object_assign));
    object_ctor.borrow_mut().props.insert(
        "fromEntries".into(),
        nv("Object.fromEntries", object_from_entries),
    );
    object_ctor.borrow_mut().props.insert(
        "getOwnPropertyNames".into(),
        nv("Object.getOwnPropertyNames", object_keys),
    );
    object_ctor
        .borrow_mut()
        .props
        .insert("freeze".into(), nv("Object.freeze", object_freeze));
    object_ctor.borrow_mut().props.insert(
        "isFrozen".into(),
        nv("Object.isFrozen", object_is_frozen),
    );
    object_ctor
        .borrow_mut()
        .props
        .insert("seal".into(), nv("Object.seal", object_seal));
    object_ctor
        .borrow_mut()
        .props
        .insert("isSealed".into(), nv("Object.isSealed", object_is_sealed));
    object_ctor.borrow_mut().props.insert(
        "preventExtensions".into(),
        nv("Object.preventExtensions", object_prevent_extensions),
    );
    object_ctor.borrow_mut().props.insert(
        "isExtensible".into(),
        nv("Object.isExtensible", object_is_extensible),
    );
    // `Object.is(a, b)`（ES2015、SameValue）が丸ごと欠落していた。`===` と違い
    // `NaN` 同士は等しいと判定し、`Object.is(0, -0)` は `false`（`===`/SameValueZero とは
    // ここだけ異なる、符号付きゼロを区別する点が特徴）。
    object_ctor
        .borrow_mut()
        .props
        .insert("is".into(), nv("Object.is", object_is));
    object_ctor
        .borrow_mut()
        .props
        .insert("create".into(), nv("Object.create", object_create));
    object_ctor.borrow_mut().props.insert(
        "defineProperty".into(),
        nv("Object.defineProperty", object_define_property),
    );
    object_ctor.borrow_mut().props.insert(
        "defineProperties".into(),
        nv("Object.defineProperties", object_define_properties),
    );
    object_ctor.borrow_mut().props.insert(
        "getOwnPropertyDescriptor".into(),
        nv(
            "Object.getOwnPropertyDescriptor",
            object_get_own_property_descriptor,
        ),
    );
    object_ctor.borrow_mut().props.insert(
        "getOwnPropertyDescriptors".into(),
        nv(
            "Object.getOwnPropertyDescriptors",
            object_get_own_property_descriptors,
        ),
    );
    object_ctor
        .borrow_mut()
        .props
        .insert("hasOwn".into(), nv("Object.hasOwn", object_has_own_static));
    object_ctor
        .borrow_mut()
        .props
        .insert("groupBy".into(), nv("Object.groupBy", object_group_by));
    object_ctor.borrow_mut().props.insert(
        "getPrototypeOf".into(),
        nv("Object.getPrototypeOf", object_get_prototype_of),
    );
    object_ctor.borrow_mut().props.insert(
        "setPrototypeOf".into(),
        nv("Object.setPrototypeOf", object_set_prototype_of),
    );
    // `Object.prototype`（丸ごと未対応だった。`Object.prototype.toString.call(x)` という
    // `lodash` 等で広く使われる型判定イディオムは、`Object` に `.prototype` が全く無いと
    // 呼び出しようが無いため、`obj_to_string()` 自体を直しても実質使えない状態だった）。
    // この処理系の「組込み Array/Object は実際の `.prototype` を持たない簡略実装」という
    // 既存方針の中で、`Object.prototype` だけは最低限アクセス可能にする。
    let object_proto = Obj::plain();
    object_proto
        .borrow_mut()
        .props
        .insert("toString".into(), nv("toString", obj_to_string));
    object_ctor
        .borrow_mut()
        .props
        .insert("prototype".into(), Value::Object(object_proto.clone()));
    g.vars.insert("Object".into(), Value::Object(object_ctor));

    // Array
    let array_ctor = Obj::native("Array", array_ctor);
    let array_proto = Obj::plain();
    let unscopables_obj = Obj::plain();
    {
        let mut u = unscopables_obj.borrow_mut();
        for key in [
            "copyWithin", "entries", "fill", "find", "findIndex",
            "findLast", "findLastIndex", "flat", "flatMap", "includes",
            "keys", "values", "at",
        ] {
            u.props.insert(key.into(), Value::Bool(true));
        }
    }
    array_proto
        .borrow_mut()
        .props
        .insert("Symbol(Symbol.unscopables)".into(), Value::Object(unscopables_obj));
    // 【2026-09-05】`Array.prototype` はオブジェクトとしては在ったが
    // **メソッドが 1 つも入っていなかった**（`Symbol.unscopables` のみ）。
    //
    // 配列メソッドは実体からの動的解決（`props_methods::object_get`）だけで
    // 賄っており、`Array.prototype.slice` のように**プロトタイプから直接
    // 読む**形が `undefined` になっていた。
    // jQuery 1.8.2 の先頭が
    // `j=Array.prototype.push,k=Array.prototype.slice,l=Array.prototype.indexOf`
    // と読むため、続く `k.call(...)` で
    // 「Cannot read properties of undefined (reading 'call')」になっていた。
    //
    // `String.prototype` と同じく、同じ解決口を使って並べる。
    // 実体側と同じ関数を指すので挙動は一致し、二重実装にならない。
    {
        let probe = Obj::array(alloc::vec::Vec::new());
        let mut ap = array_proto.borrow_mut();
        for key in ARRAY_PROTO_METHODS {
            let v = super::builtins::props_methods::object_get(&probe, key);
            if !matches!(v, Value::Undefined) {
                ap.props.insert(alloc::string::String::from(*key), v);
            }
        }
    }
    array_ctor
        .borrow_mut()
        .props
        .insert("prototype".into(), Value::Object(array_proto));
    array_ctor
        .borrow_mut()
        .props
        .insert("isArray".into(), nv("Array.isArray", array_is_array));
    array_ctor
        .borrow_mut()
        .props
        .insert("from".into(), nv("Array.from", array_from));
    array_ctor
        .borrow_mut()
        .props
        .insert("of".into(), nv("Array.of", array_of));
    array_ctor
        .borrow_mut()
        .props
        .insert("fromAsync".into(), nv("Array.fromAsync", array_from_async));
    g.vars.insert("Array".into(), Value::Object(array_ctor));

    // 単純な型変換コンストラクタ
    let string_ctor_v = nv("String", string_ctor);
    if let Value::Object(sc) = &string_ctor_v {
        let mut b = sc.borrow_mut();
        b.props.insert(
            "fromCharCode".into(),
            nv("String.fromCharCode", string_from_char_code),
        );
        b.props.insert(
            "fromCodePoint".into(),
            nv("String.fromCodePoint", string_from_code_point),
        );
        b.props.insert("raw".into(), nv("String.raw", string_raw));
        // 【2026-09-05】`String.prototype` が丸ごと存在しなかった。
        //
        // 文字列のメソッドは実体（プリミティブ）からの動的解決
        // （`props_methods::string_get`）だけで賄っており、
        // `String.prototype.trim` のように**プロトタイプから直接読む**
        // 形が `undefined` になっていた。
        // jQuery 1.8.2 の先頭が
        // `o=String.prototype.trim` を読むため、**本体が実行時に落ち**、
        // 続く `$` も未定義になっていた（実測）。
        //
        // 同じ解決口を使ってメソッドを並べる。実体側と同じ関数を指すので
        // 挙動は一致し、二重実装にならない。
        let string_proto = Obj::plain();
        {
            let mut sp = string_proto.borrow_mut();
            for key in STRING_PROTO_METHODS {
                let v = super::builtins::props_methods::string_get("", key);
                if !matches!(v, Value::Undefined) {
                    sp.props.insert(alloc::string::String::from(*key), v);
                }
            }
        }
        b.props
            .insert("prototype".into(), Value::Object(string_proto));
    }
    g.vars.insert("String".into(), string_ctor_v);
    // `Number.parseFloat`/`Number.parseInt`（ES2015）は仕様上グローバル `parseFloat`/
    // `parseInt` と「同一の関数オブジェクト」（`Number.parseFloat === parseFloat` が
    // `true`）でなければならないが、以前はそれぞれ別々に `nv(...)` していたため
    // 別オブジェクトになり `===` が `false` になっていた（`.name` も本来どちらも
    // `"parseFloat"`/`"parseInt"` であるべきところ `"Number.parseFloat"` 等になっていた）。
    // 1回だけ構築して両方の束縛先で同じ `Value`（同じ `Rc`）を共有する。
    let parse_float_v = nv("parseFloat", global_parse_float);
    let parse_int_v = nv("parseInt", global_parse_int);
    let number_ctor_v = nv("Number", number_ctor);
    if let Value::Object(nc) = &number_ctor_v {
        let mut b = nc.borrow_mut();
        b.props.insert(
            "isInteger".into(),
            nv("Number.isInteger", number_is_integer),
        );
        b.props.insert(
            "isSafeInteger".into(),
            nv("Number.isSafeInteger", number_is_safe_integer),
        );
        b.props.insert(
            "isFinite".into(),
            nv("Number.isFinite", number_is_finite_static),
        );
        b.props
            .insert("isNaN".into(), nv("Number.isNaN", number_is_nan_static));
        b.props.insert("parseFloat".into(), parse_float_v.clone());
        b.props.insert("parseInt".into(), parse_int_v.clone());
        b.props
            .insert("MAX_SAFE_INTEGER".into(), Value::Number(9007199254740991.0));
        b.props.insert(
            "MIN_SAFE_INTEGER".into(),
            Value::Number(-9007199254740991.0),
        );
        b.props
            .insert("EPSILON".into(), Value::Number(f64::EPSILON));
        b.props.insert("MAX_VALUE".into(), Value::Number(f64::MAX));
        // `Number.MIN_VALUE`（0 に最も近い正の表現可能な値 = 最小の非正規化数
        // `5e-324`。ES1 以来の定数）と `Number.NaN`（グローバル `NaN` とは別に
        // `Number` 名前空間側にも仕様上存在する）が丸ごと未登録だった。
        // `f64::MIN_POSITIVE`（Rust 標準の「最小の正規化数」約 `2.2e-308`）とは
        // 別物なので注意（仕様の `Number.MIN_VALUE` は非正規化数まで含めた最小値）。
        // `MIN_SAFE_INTEGER`（安全な整数の下限、大きな負の値）とも紛らわしいが
        // 別物。
        b.props
            .insert("MIN_VALUE".into(), Value::Number(f64::from_bits(1)));
        b.props.insert("NaN".into(), Value::Number(f64::NAN));
        b.props
            .insert("POSITIVE_INFINITY".into(), Value::Number(f64::INFINITY));
        b.props
            .insert("NEGATIVE_INFINITY".into(), Value::Number(f64::NEG_INFINITY));
    }
    g.vars.insert("Number".into(), number_ctor_v);
    g.vars.insert("Boolean".into(), nv("Boolean", boolean_ctor));

    // BigInt コンストラクタ + 静的メソッド asIntN / asUintN。
    let bigint_ctor_v = nv("BigInt", bigint_ctor);
    if let Value::Object(bc) = &bigint_ctor_v {
        let mut b = bc.borrow_mut();
        b.props
            .insert("asIntN".into(), nv("BigInt.asIntN", bigint_as_int_n));
        b.props
            .insert("asUintN".into(), nv("BigInt.asUintN", bigint_as_uint_n));
    }
    g.vars.insert("BigInt".into(), bigint_ctor_v);

    // グローバル関数
    g.vars.insert("parseInt".into(), parse_int_v);
    g.vars.insert("parseFloat".into(), parse_float_v);
    g.vars.insert("isNaN".into(), nv("isNaN", global_is_nan));
    g.vars
        .insert("isFinite".into(), nv("isFinite", global_is_finite));
    // `eval`（ES1 以来。文字列以外の引数はそのまま返す仕様）と `Function` コンストラクタ
    // （ES1。動的にソースからコードを生成する定番イディオムの2大対象）が丸ごと欠落して
    // いたのを実装。この処理系は「常にグローバルスコープで実行する」簡略実装（indirect
    // eval と同じセマンティクス。direct eval が呼び出し元のレキシカルスコープを見る挙動は
    // 対象外）。
    g.vars.insert("eval".into(), nv("eval", global_eval));
    // 【2026-09-26】`Function.prototype` が存在しなかった（`String.prototype` 等と同じ欠落）。
    // 関数のメソッド（call/apply/bind/toString）は実体からの動的解決だけで賄っており、
    // `Function.prototype.toString.call(f)` のように**プロトタイプから直接読む**形が
    // undefined になっていた。OpenStreetMap 埋め込み（Leaflet 同梱の JS）が起動時にこれを読み、
    // 「Cannot read properties of undefined (reading 'toString')」で止まっていた。
    // 同じ解決口から取ったメソッドを並べる（実体側と同じ関数を指すので二重実装にならない）。
    let function_ctor_v = nv("Function", function_ctor);
    if let Value::Object(fc) = &function_ctor_v {
        let function_proto = Obj::plain();
        {
            let mut fp = function_proto.borrow_mut();
            for key in ["call", "apply", "bind"] {
                let v = super::builtins::props_methods::function_method(key);
                if !matches!(v, Value::Undefined) {
                    fp.props.insert(alloc::string::String::from(key), v);
                }
            }
            fp.props.insert(
                "toString".into(),
                nv("toString", super::builtins::props_methods::fn_to_string),
            );
        }
        fc.borrow_mut()
            .props
            .insert("prototype".into(), Value::Object(function_proto));
    }
    g.vars.insert("Function".into(), function_ctor_v);

    // location（window/document/global で共有する単一オブジェクト。
    // 値は base_url 設定時に update_location が埋める。install 時は空）。
    let location = Obj::plain();
    {
        let mut l = location.borrow_mut();
        for k in [
            "href", "protocol", "username", "password", "host", "hostname", "port", "origin",
            "pathname", "search", "hash",
        ] {
            l.props.insert(String::from(k), Value::str(""));
        }
        l.props
            .insert("assign".into(), nv("location.assign", location_assign));
        l.props
            .insert("replace".into(), nv("location.replace", location_replace));
        l.props
            .insert("reload".into(), nv("location.reload", location_reload));
        l.props.insert(
            "toString".into(),
            nv("location.toString", location_to_string),
        );
        // ホスト連携用マーカー。set_property がこのオブジェクトを location と判定し、
        // href/hash/pathname/search 代入をナビゲーション要求に変換する。
        l.props.insert("_is_location".into(), Value::Bool(true));
    }

    // history（SPA ルーティング。pushState/replaceState で location を書換え（再読込なし））。
    let history = Obj::plain();
    {
        let mut h = history.borrow_mut();
        h.props.insert("length".into(), Value::Number(1.0));
        h.props.insert("state".into(), Value::Null);
        h.props
            .insert("scrollRestoration".into(), Value::str("auto"));
        h.props.insert(
            "pushState".into(),
            nv("history.pushState", history_push_state),
        );
        h.props.insert(
            "replaceState".into(),
            nv("history.replaceState", history_replace_state),
        );
        h.props
            .insert("back".into(), nv("history.back", history_back));
        h.props
            .insert("forward".into(), nv("history.forward", history_forward));
        h.props.insert("go".into(), nv("history.go", history_go));
    }

    // document（DOM ホストオブジェクト）
    let document = Obj::host("document");
    {
        let mut d = document.borrow_mut();
        // Node としての種別（DOCUMENT_NODE）。【2026-10-20】無かったため YouTube の player の
        // 所有文書の取得（`f.nodeType==9?f:f.ownerDocument||f.document`）が document で undefined を返していた。
        d.props.insert("nodeType".into(), Value::Number(9.0));
        d.props.insert("nodeName".into(), Value::str("#document"));
        d.props.insert("ownerDocument".into(), Value::Null);
        d.props.insert(
            "getElementById".into(),
            nv("getElementById", document_get_element_by_id),
        );
        d.props.insert(
            "querySelector".into(),
            nv("querySelector", document_query_selector),
        );
        d.props.insert(
            "querySelectorAll".into(),
            nv("querySelectorAll", document_query_selector_all),
        );
        // `document.elementFromPoint(x,y)`/`.elementsFromPoint(x,y)`（座標ヒット
        // テストの定番 API）が丸ごと未対応だった。この処理系に z-index を考慮した
        // 合成順スタックは無いため、レイアウト確定後の `rects`（`getBoundingClientRect`
        // と同じ発生源）から座標を含む矩形を集め、最も面積が小さい（＝最も深く
        // ネストした）要素を「最前面」の近似として返す簡略実装。
        d.props.insert(
            "elementFromPoint".into(),
            nv("elementFromPoint", document_element_from_point),
        );
        d.props.insert(
            "elementsFromPoint".into(),
            nv("elementsFromPoint", document_elements_from_point),
        );
        d.props.insert(
            "createElement".into(),
            nv("document.createElement", document_create_element),
        );
        d.props.insert(
            "createElementNS".into(),
            nv("document.createElementNS", document_create_element_ns),
        );
        d.props.insert(
            "createTextNode".into(),
            nv("document.createTextNode", document_create_text_node),
        );
        d.props.insert(
            "createComment".into(),
            nv("document.createComment", document_create_comment),
        );
        // `document.createEvent(name)`（DOM Level 2 の古い構築方法。`initEvent` で初期化する）。
        d.props.insert(
            "createEvent".into(),
            nv("document.createEvent", document_create_event),
        );
        // `document.createDocumentFragment()` が丸ごと未対応だった。
        d.props.insert(
            "createDocumentFragment".into(),
            nv("document.createDocumentFragment", document_create_document_fragment),
        );
        d.props
            .insert("location".into(), Value::Object(location.clone()));
        d.props.insert(
            "getElementsByClassName".into(),
            nv(
                "getElementsByClassName",
                document_get_elements_by_class_name,
            ),
        );
        d.props.insert(
            "getElementsByTagName".into(),
            nv("getElementsByTagName", document_get_elements_by_tag_name),
        );
        d.props.insert(
            "getElementsByTagNameNS".into(),
            nv("getElementsByTagNameNS", document_get_elements_by_tag_name_ns),
        );
        d.props.insert(
            "getElementsByName".into(),
            nv("getElementsByName", document_get_elements_by_name),
        );
        d.props.insert("title".into(), Value::str(""));
        d.props.insert("activeElement".into(), Value::Null);
        // `document`にも`EventTarget`風の汎用リスナ格納`_listeners`を持たせる
        // （`click`/`keydown`等、`window`と共有しない汎用イベント種別の
        // `addEventListener`受け皿。2026-07-16 発見・実装。詳細は
        // `document_add_event_listener`のコメント参照）。
        d.props.insert("_listeners".into(), Value::Object(Obj::plain()));
        d.props.insert("readyState".into(), Value::str("complete"));
        // `document.designMode`（`"on"`/`"off"`。HTML5、丸ごと未対応だった）。
        // `element.contentEditable` と同じ理由でこの処理系にはキャレット/テキスト
        // 編集機構自体が無いため、実際のページ全体編集可能化は行わず状態の読み書き
        // のみを提供する簡略実装（既定 `"off"`）。
        d.props.insert("designMode".into(), Value::str("off"));
        // Fullscreen API（標準 + YouTube 等の Web プレーヤーが参照する webkit/moz/ms プレフィックス互換）。
        d.props.insert("fullscreenElement".into(), Value::Null);
        d.props.insert("webkitFullscreenElement".into(), Value::Null);
        d.props.insert("mozFullScreenElement".into(), Value::Null);
        d.props.insert("msFullscreenElement".into(), Value::Null);
        d.props.insert("fullscreenEnabled".into(), Value::Bool(true));
        d.props.insert("webkitFullscreenEnabled".into(), Value::Bool(true));
        d.props.insert("mozFullScreenEnabled".into(), Value::Bool(true));
        d.props.insert("msFullscreenEnabled".into(), Value::Bool(true));
        d.props.insert("onfullscreenchange".into(), Value::Null);
        d.props.insert("onwebkitfullscreenchange".into(), Value::Null);
        d.props.insert("onfullscreenerror".into(), Value::Null);
        d.props.insert(
            "exitFullscreen".into(),
            nv("document.exitFullscreen", document_exit_fullscreen),
        );
        d.props.insert(
            "webkitExitFullscreen".into(),
            nv("document.webkitExitFullscreen", document_exit_fullscreen),
        );
        d.props.insert(
            "webkitCancelFullScreen".into(),
            nv("document.webkitCancelFullScreen", document_exit_fullscreen),
        );
        d.props.insert(
            "mozCancelFullScreen".into(),
            nv("document.mozCancelFullScreen", document_exit_fullscreen),
        );
        d.props.insert(
            "msExitFullscreen".into(),
            nv("document.msExitFullscreen", document_exit_fullscreen),
        );
        // Pointer Lock API（丸ごと未対応だった）。Fullscreen API と同じ
        // 「状態のみ追跡する」簡略方針（`pointerlockchange` イベントは対象外）。
        d.props.insert("pointerLockElement".into(), Value::Null);
        d.props.insert(
            "exitPointerLock".into(),
            nv("document.exitPointerLock", document_exit_pointer_lock),
        );
        // Picture-in-Picture API（丸ごと未対応だった）。Fullscreen/Pointer Lock
        // API と同じ「状態のみ追跡する」簡略方針
        // （`enterpictureinpicture`/`leavepictureinpicture` イベントは対象外）。
        d.props.insert("pictureInPictureElement".into(), Value::Null);
        d.props.insert("pictureInPictureEnabled".into(), Value::Bool(true));
        d.props.insert(
            "exitPictureInPicture".into(),
            nv("document.exitPictureInPicture", document_exit_picture_in_picture),
        );
        // Storage Access API（`document.hasStorageAccess()`/
        // `.requestStorageAccess()`。丸ごと未対応だった。サードパーティ
        // iframe からの Cookie アクセス許可を確認/要求する定番パターン）。
        // この処理系にはサードパーティ Cookie 分離/ブロック機構自体が無く
        // ストレージは常にアクセス可能なため、`true`/成功を返すのは楽観視の
        // 偽装ではなく実態に即した誠実な近似。
        d.props.insert(
            "hasStorageAccess".into(),
            nv("document.hasStorageAccess", document_has_storage_access),
        );
        d.props.insert(
            "requestStorageAccess".into(),
            nv("document.requestStorageAccess", document_request_storage_access),
        );
        // `document.addEventListener('DOMContentLoaded'|'load', fn)` が単なる no-op で
        // リスナが一切発火しない黙殺バグだった（`window.addEventListener` 側は既に
        // 同じイベントを即時発火する実装があったが、`document` 側は同じ関数を配線
        // し忘れていた非対称な状態。`document.addEventListener('DOMContentLoaded', ...)`
        // は `window` 版よりもむしろ広く使われる定番パターン）。`document_add_event_
        // listener`（`window_api.rs`）が固定種別は `window` と共有し、それ以外
        // （`click`/`keydown`等の汎用種別）は `document` 自身の `_listeners` へ
        // 振り分ける（2026-07-16、`document.addEventListener('click', ...)` の
        // イベント委譲パターン対応で拡張）。
        d.props.insert(
            "addEventListener".into(),
            nv("document.addEventListener", document_add_event_listener),
        );
        // `document.removeEventListener`（丸ごと未対応だった。`addEventListener`
        // は `window` 版を再利用する形で配線済みだったが、対になる
        // `removeEventListener` 自体が登録されておらず「関数ではない」
        // `TypeError` になっていた）。
        d.props.insert(
            "removeEventListener".into(),
            nv("document.removeEventListener", document_remove_event_listener),
        );
        // `document.dispatchEvent`（丸ごと未対応だった。`addEventListener`/
        // `removeEventListener` と同じ兄弟ギャップ）。
        d.props.insert(
            "dispatchEvent".into(),
            nv("document.dispatchEvent", document_dispatch_event),
        );
        d.props
            .insert("write".into(), nv("document.write", dom_noop));
        d.props.insert(
            "createRange".into(),
            nv("document.createRange", document_create_range),
        );
        // `document.createTreeWalker(root, whatToShow?, filter?)`（丸ごと
        // 未対応だった。DOM 部分木を走査する定番パターン）。
        d.props.insert(
            "createTreeWalker".into(),
            nv("document.createTreeWalker", document_create_tree_walker),
        );
        // `document.createNodeIterator(root, whatToShow?, filter?)`（丸ごと
        // 未対応だった）。`TreeWalker` とは異なり内部状態が「参照ノード＋
        // 前後どちら側を指しているか」のポインタモデルで、`nextNode()`/
        // `previousNode()` を交互に呼ぶと同じノードへ一旦戻る仕様上の挙動がある。
        d.props.insert(
            "createNodeIterator".into(),
            nv("document.createNodeIterator", document_create_node_iterator),
        );
        // `document.importNode(externalNode, deep)`/`document.adoptNode(node)`
        // （丸ごと未対応だった。`<template>` の中身を取り込む定番パターン
        // `document.importNode(template.content, true)` 等で使われる）。
        d.props.insert(
            "importNode".into(),
            nv("document.importNode", doc_import_node),
        );
        d.props.insert(
            "adoptNode".into(),
            nv("document.adoptNode", doc_adopt_node),
        );
        // `document.createAttribute(name)`（丸ごと未対応だった。`getAttributeNode`
        // と対になる `Attr` ノード新規作成パターン）。
        d.props.insert(
            "createAttribute".into(),
            nv("document.createAttribute", document_create_attribute),
        );
        d.props.insert(
            "getSelection".into(),
            nv("document.getSelection", document_get_selection),
        );
        d.props.insert(
            "execCommand".into(),
            nv("document.execCommand", document_exec_command),
        );
        // `document.getAnimations()`（丸ごと未対応だった。`element.
        // getAnimations()` と同じく実行中アニメーションを一切保持していない
        // ため常に空配列を返す簡略実装）。
        d.props.insert(
            "getAnimations".into(),
            nv("document.getAnimations", |_, _, _| Ok(Value::Object(Obj::array(alloc::vec![])))),
        );
        d.props.insert(
            "hasFocus".into(),
            nv("document.hasFocus", |_, _, _| Ok(Value::Bool(true))),
        );
        // `document.visibilityState`/`.hidden`（Page Visibility API。丸ごと
        // 未対応だった。`visibilitychange`イベント自体は前サイクルで登録経路
        // のみ実装済みだったが、対になる状態プロパティが欠けていた）。この
        // OS にはタブ/ウィンドウのバックグラウンド化という概念自体が無く
        // GUI は常時フォアグラウンドのため、`document.hasFocus()`と同じく
        // 常に「可視」を返す誠実な簡略実装。
        d.props.insert("visibilityState".into(), Value::str("visible"));
        d.props.insert("hidden".into(), Value::Bool(false));
        // `document.characterSet`/`.compatMode`/`.contentType`/`.doctype`
        // （丸ごと未対応だった。2026-07-16 発見）。この処理系は常に UTF-8
        // でパースし `<!DOCTYPE html>` 前提の標準準拠モードのみをサポート
        // するため、`characterSet`/`compatMode`/`contentType`は固定値の
        // 誠実な簡略実装。`doctype`（`DocumentType` ノード）はパース時に
        // 一切モデル化していない（HTML パーサが `<!DOCTYPE ...>` を読み
        // 飛ばすのみでノード化しない）ため、「DocumentType ノードが存在
        // しない文書」を表す仕様どおりの `null` を返す。
        d.props.insert("characterSet".into(), Value::str("UTF-8"));
        d.props.insert("compatMode".into(), Value::str("CSS1Compat"));
        d.props.insert("contentType".into(), Value::str("text/html"));
        d.props.insert("doctype".into(), Value::Null);
        // `document.currentScript`（丸ごと未対応だった。2026-07-16 発見）。
        // 仕様上「同期実行中の非モジュールクラシックスクリプトの実行中のみ
        // 対応する `<script>` 要素、それ以外（イベントハンドラ・タイマー・
        // 実行完了後）は常に `null`」だが、この処理系には「現在実行中の
        // script 要素」を追跡する仕組みが無い（`<script>` はパース時に一括
        // 逐次評価されるのみで、実行スタックとノードの紐付けを持たない）
        // ため、`getAnimations()`と同方針の「状態追跡なし」の誠実な簡略
        // 実装として常に `null` を返す。
        d.props.insert("currentScript".into(), Value::Null);
        // `document.implementation`（`DOMImplementation`。丸ごと未対応
        // だった。2026-07-16 発見）。`hasFeature()` は仕様上「常に `true`
        // を返すレガシーな no-op」（実際の機能判定は行わない）と明記されて
        // いるため引数を無視して固定 `true` を返す誠実な実装。
        // `createDocumentType()` は他ノードから独立した単体オブジェクトを
        // 組み立てるだけで済むため対応。一方 `createDocument()`/
        // `createHTMLDocument()` はこの処理系が単一のグローバル `document`
        // シングルトンしか持たず独立した2つ目の文書ツリーを表現できない
        // ため、`customElements`/`<canvas>` と同格の大規模改修が必要と
        // 判断し本サイクルでは対象外とする（詳細は TODO.md 参照）。
        let implementation = Obj::plain();
        {
            let mut im = implementation.borrow_mut();
            im.props.insert(
                "hasFeature".into(),
                nv("DOMImplementation.hasFeature", |_, _, _| Ok(Value::Bool(true))),
            );
            im.props.insert(
                "createDocumentType".into(),
                nv("DOMImplementation.createDocumentType", dom_implementation_create_document_type),
            );
            im.props.insert(
                "createHTMLDocument".into(),
                nv("DOMImplementation.createHTMLDocument", dom_implementation_create_html_document),
            );
            im.props.insert(
                "createDocument".into(),
                nv("DOMImplementation.createDocument", dom_implementation_create_document),
            );
        }
        d.props
            .insert("implementation".into(), Value::Object(implementation));
    }
    /// `document.implementation.createDocumentType(qualifiedName, publicId,
    /// systemId)`（丸ごと未対応だった。2026-07-16 発見）。この処理系には
    /// `DocumentType` 専用の内部表現が無いため、`element.attributes`/
    /// `getAttributeNode` と同じ「読み取り専用簡略実装」方針で、`{name,
    /// publicId, systemId}` の平プレーンオブジェクトを返す（どのノードにも
    /// 接続されず `document.doctype` へも反映されない独立した値）。
    fn dom_implementation_create_document_type(
        _it: &mut Interp,
        _t: Value,
        a: &[Value],
    ) -> Result<Value, Value> {
        let obj = Obj::plain();
        {
            let mut b = obj.borrow_mut();
            b.props.insert("nodeType".into(), Value::Number(10.0));
            b.props.insert("name".into(), Value::str(arg(a, 0).to_js_string()));
            b.props.insert("publicId".into(), Value::str(arg(a, 1).to_js_string()));
            b.props.insert("systemId".into(), Value::str(arg(a, 2).to_js_string()));
        }
        Ok(Value::Object(obj))
    }
    fn dom_implementation_create_html_document(
        _it: &mut Interp,
        _t: Value,
        a: &[Value],
    ) -> Result<Value, Value> {
        let title = if !a.is_empty() && !matches!(a[0], Value::Undefined) {
            a[0].to_js_string()
        } else {
            String::new()
        };
        let doc = Obj::plain();
        {
            let mut b = doc.borrow_mut();
            b.props.insert("nodeType".into(), Value::Number(9.0));
            b.props.insert("nodeName".into(), Value::str("#document"));
            b.props.insert("title".into(), Value::str(&title));
            b.props.insert("body".into(), Value::Null);
            b.props.insert("head".into(), Value::Null);
            b.props.insert("documentElement".into(), Value::Null);
            b.props.insert("createElement".into(), nv("createElement", document_create_element));
        }
        Ok(Value::Object(doc))
    }
    fn dom_implementation_create_document(
        _it: &mut Interp,
        _t: Value,
        a: &[Value],
    ) -> Result<Value, Value> {
        let ns = arg(a, 0);
        let qname = arg(a, 1);
        let doc = Obj::plain();
        {
            let mut b = doc.borrow_mut();
            b.props.insert("nodeType".into(), Value::Number(9.0));
            b.props.insert("nodeName".into(), Value::str("#document"));
            b.props.insert("namespaceURI".into(), ns);
            b.props.insert("qualifiedName".into(), qname);
            b.props.insert("createElement".into(), nv("createElement", document_create_element));
        }
        Ok(Value::Object(doc))
    }
    g.vars
        .insert("document".into(), Value::Object(document.clone()));

    // window（最小限。document への参照と no-op を提供）
    let window = Obj::plain();
    let screen_obj = Obj::plain();
    {
        let mut w = window.borrow_mut();
        w.props.insert("document".into(), Value::Object(document));
        w.props
            .insert("location".into(), Value::Object(location.clone()));
        w.props
            .insert("history".into(), Value::Object(history.clone()));
        w.props.insert(
            "addEventListener".into(),
            nv("window.addEventListener", window_add_event_listener),
        );
        w.props.insert(
            "removeEventListener".into(),
            nv("window.removeEventListener", window_remove_event_listener),
        );
        w.props.insert(
            "dispatchEvent".into(),
            nv("window.dispatchEvent", window_dispatch_event),
        );
        // `window.print()`（丸ごと未対応だった）。実際の印刷パイプライン自体が
        // 無いため、`focus`/`blur`/`scrollIntoView` と同じ無害な no-op とする。
        w.props.insert("print".into(), nv("window.print", dom_noop));
        w.props.insert("scrollY".into(), Value::Number(0.0));
        w.props.insert("pageYOffset".into(), Value::Number(0.0));
        w.props.insert("scrollX".into(), Value::Number(0.0));
        w.props.insert("pageXOffset".into(), Value::Number(0.0));
        w.props
            .insert("scrollTo".into(), nv("scrollTo", window_scroll_to));
        w.props
            .insert("scroll".into(), nv("scroll", window_scroll_to));
        // `window.scrollBy(x, y)`（丸ごと未対応だった。`window.`修飾無しの
        // bare `scrollBy`〔グローバル関数〕は登録されていたが、`window.
        // scrollBy(...)`とプロパティ経由でアクセスする形は登録が漏れており
        // `TypeError: not a function`になっていた。`scrollTo`/`scroll`は
        // 両方の形が登録済みだったのに`scrollBy`だけこの非対称漏れが
        // あった。2026-07-16 発見・実装）。
        w.props
            .insert("scrollBy".into(), nv("window.scrollBy", window_scroll_by));
        w.props
            .insert("matchMedia".into(), nv("matchMedia", window_match_media));
        // `window.postMessage(data, targetOrigin)`（丸ごと未対応だった）。
        // 別ウィンドウ/フレーム間通信の仕様上の非同期性・`targetOrigin` に
        // よる送信先絞り込みは実装せず、同一 `window` 上の 'message' リスナへ
        // 同期的に配送する簡略実装（この処理系にはフレーム分離が無いため
        // 実用上大きな差は生じない）。
        w.props
            .insert("postMessage".into(), nv("postMessage", window_post_message));
        w.props.insert("alert".into(), nv("alert", console_log));
        // `window.confirm`/`window.prompt`（丸ごと未対応だった。`alert`は
        // 既に`console_log`で代替されていたのに、対になるこの2つだけ
        // グローバルにも`window`にも一切登録が無く「関数ではない」
        // `TypeError`になっていた。2026-07-16 発見・実装）。
        w.props
            .insert("confirm".into(), nv("window.confirm", window_confirm));
        w.props
            .insert("prompt".into(), nv("window.prompt", window_prompt));
        // `window.open`/`.close`/`.focus`/`.blur`（丸ごと未対応だった。同じ
        // 監査で発見。呼び出すと`TypeError`になっていた。2026-07-16
        // 発見・実装）。
        w.props
            .insert("open".into(), nv("window.open", window_open));
        w.props
            .insert("close".into(), nv("window.close", window_close));
        // `window.stop()`（丸ごと未対応だった。詳細は`window_stop`参照。
        // 2026-07-17 発見・実装）。
        w.props
            .insert("stop".into(), nv("window.stop", window_stop));
        w.props
            .insert("focus".into(), nv("window.focus", window_focus));
        w.props
            .insert("blur".into(), nv("window.blur", window_focus));
        // `window.getSelection()`（丸ごと未対応だった。仕様上こちらが本来の
        // 正規の場所で、`document.getSelection()`はレガシーな別名。この
        // 処理系は逆に`document.getSelection`だけを実装しており、より
        // 一般的に使われる`window.getSelection().toString()`等のイディオムが
        // `TypeError`になっていた。2026-07-16 発見・実装。同じ`document_get_
        // selection`実装を再利用）。
        w.props.insert(
            "getSelection".into(),
            nv("window.getSelection", document_get_selection),
        );
        // `window.self`/`.top`/`.parent`/`.frames`/`.name`（丸ごと未対応
        // だった。bare `self`/`top`/`parent`/`frames`〔`g.vars`〕と同じ
        // 理由。この処理系には独立JSレルムを持つiframeが無く常に単一
        // フレームのため、仕様どおり自分自身を指す。`.name`はプロパティ
        // として読み書き可能な単なる文字列で既定は空文字列）。
        w.props.insert("self".into(), Value::Object(window.clone()));
        w.props.insert("top".into(), Value::Object(window.clone()));
        w.props.insert("parent".into(), Value::Object(window.clone()));
        w.props.insert("frames".into(), Value::Object(window.clone()));
        w.props.insert("name".into(), Value::str(""));
        w.props.insert(
            "getComputedStyle".into(),
            nv("getComputedStyle", get_computed_style),
        );
        w.props.insert(
            "localStorage".into(),
            Value::Object(Obj::host("storage:local")),
        );
        w.props.insert(
            "sessionStorage".into(),
            Value::Object(Obj::host("storage:session")),
        );
        // viewport dimensions（VIEWPORT_HINT がセットされていれば使う）
        let vw = super::super::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let vh = super::super::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        let vw_f = if vw > 0 { vw as f64 } else { 1024.0 };
        let vh_f = if vh > 0 { vh as f64 } else { 600.0 };
        w.props.insert("innerWidth".into(), Value::Number(vw_f));
        w.props.insert("innerHeight".into(), Value::Number(vh_f));
        w.props.insert("outerWidth".into(), Value::Number(vw_f));
        w.props.insert("outerHeight".into(), Value::Number(vh_f));
        w.props
            .insert("devicePixelRatio".into(), Value::Number(1.0));
        // （`window.scrollBy` は上の方で `window_scroll_by` へ正しく登録済み。
        // ここに以前あった `nv("scrollBy", window_scroll_to)` という重複
        // 登録は、後勝ちの `props.insert` で正しい登録を静かに上書きし
        // `window.scrollBy(dx,dy)` が実質 `scrollTo` と誤動作するバグ
        // だった。2026-07-16 発見・削除）。
        // `window.screen`（丸ごと未対応だった。`screen.width`/`.height`/
        // `.availWidth`/`.availHeight`/`.colorDepth`/`.pixelDepth`/
        // `.orientation.type` というレスポンシブ分岐の定番パターンで参照される
        // 標準オブジェクト。タスクバー等が無いためウインドウ全体を占有する
        // ビューポート寸法と `avail*` を同一値にする簡略実装)。
        {
            let mut s = screen_obj.borrow_mut();
            s.props.insert("width".into(), Value::Number(vw_f));
            s.props.insert("height".into(), Value::Number(vh_f));
            s.props.insert("availWidth".into(), Value::Number(vw_f));
            s.props.insert("availHeight".into(), Value::Number(vh_f));
            s.props.insert("colorDepth".into(), Value::Number(24.0));
            s.props.insert("pixelDepth".into(), Value::Number(24.0));
            let orientation = Obj::plain();
            let otype = if vw_f >= vh_f { "landscape-primary" } else { "portrait-primary" };
            orientation.borrow_mut().props.insert("type".into(), Value::str(otype));
            orientation.borrow_mut().props.insert("angle".into(), Value::Number(0.0));
            // `screen.orientation.lock()`/`.unlock()`（丸ごと未対応だった）。
            // 実際にディスプレイの向きを固定する機構は無いため、`fullscreenElement`
            // 等と同じ「状態のみ追跡する」簡略実装とする（`lock()` は要求された
            // 向きへ `type` を書き換えるだけ、`unlock()` は現在のビューポート寸法
            // から求めた自然な向きへ戻す）。
            orientation
                .borrow_mut()
                .props
                .insert("lock".into(), nv("screen.orientation.lock", screen_orientation_lock));
            orientation.borrow_mut().props.insert(
                "unlock".into(),
                nv("screen.orientation.unlock", screen_orientation_unlock),
            );
            s.props.insert("orientation".into(), Value::Object(orientation));
        }
        w.props.insert("screen".into(), Value::Object(screen_obj.clone()));
    }
    // `window.cookieStore`（Cookie Store API。丸ごと未対応だった。従来の
    // `document.cookie` 文字列パースに代わる非同期・構造化された定番の
    // 読み書き方式）。既存の `COOKIES`（`document.cookie` の実データ）を
    // そのまま共有するため、両方の API 経由での読み書きが相互に反映される。
    let cookie_store = Obj::plain();
    {
        let mut cs = cookie_store.borrow_mut();
        cs.props.insert("get".into(), nv("cookieStore.get", cookie_store_get));
        cs.props.insert("getAll".into(), nv("cookieStore.getAll", cookie_store_get_all));
        cs.props.insert("set".into(), nv("cookieStore.set", cookie_store_set));
        cs.props.insert("delete".into(), nv("cookieStore.delete", cookie_store_delete));
    }
    window
        .borrow_mut()
        .props
        .insert("cookieStore".into(), Value::Object(cookie_store.clone()));

    // `window.customElements`（Web Components / Custom Elements API）
    let custom_elements = Obj::plain();
    {
        let mut ce = custom_elements.borrow_mut();
        ce.props.insert("define".into(), nv("customElements.define", custom_elements_define));
        ce.props.insert("get".into(), nv("customElements.get", custom_elements_get));
        ce.props.insert("whenDefined".into(), nv("customElements.whenDefined", custom_elements_when_defined));
        ce.props.insert("upgrade".into(), nv("customElements.upgrade", custom_elements_upgrade));
        ce.props.insert("_registry".into(), Value::Object(Obj::plain()));
    }
    window
        .borrow_mut()
        .props
        .insert("customElements".into(), Value::Object(custom_elements.clone()));

    // WHATWG Streams API
    window
        .borrow_mut()
        .props
        .insert("ReadableStream".into(), nv("ReadableStream", readable_stream_ctor));
    window
        .borrow_mut()
        .props
        .insert("WritableStream".into(), nv("WritableStream", writable_stream_ctor));
    window
        .borrow_mut()
        .props
        .insert("TransformStream".into(), nv("TransformStream", transform_stream_ctor));

    // W3C Media Source Extensions (MSE)
    let media_source_ctor_obj = Obj::native("MediaSource", media_source_ctor);
    media_source_ctor_obj.borrow_mut().props.insert(
        "isTypeSupported".into(),
        nv("MediaSource.isTypeSupported", media_source_is_type_supported),
    );
    let media_source_ctor_val = Value::Object(media_source_ctor_obj);
    window
        .borrow_mut()
        .props
        .insert("MediaSource".into(), media_source_ctor_val.clone());
    let worker_ctor_val = nv("Worker", worker_ctor);
    window
        .borrow_mut()
        .props
        .insert("Worker".into(), worker_ctor_val.clone());
    let text_encoder_stream_ctor_val = nv("TextEncoderStream", text_encoder_stream_ctor);
    let text_decoder_stream_ctor_val = nv("TextDecoderStream", text_decoder_stream_ctor);
    window
        .borrow_mut()
        .props
        .insert("TextEncoderStream".into(), text_encoder_stream_ctor_val.clone());
    window
        .borrow_mut()
        .props
        .insert("TextDecoderStream".into(), text_decoder_stream_ctor_val.clone());

    g.vars.insert("window".into(), Value::Object(window));
    g.vars.insert("screen".into(), Value::Object(screen_obj));
    g.vars.insert("cookieStore".into(), Value::Object(cookie_store));
    g.vars.insert("customElements".into(), Value::Object(custom_elements));
    g.vars.insert("ReadableStream".into(), nv("ReadableStream", readable_stream_ctor));
    g.vars.insert("WritableStream".into(), nv("WritableStream", writable_stream_ctor));
    g.vars.insert("TransformStream".into(), nv("TransformStream", transform_stream_ctor));
    g.vars.insert("MediaSource".into(), media_source_ctor_val);
    g.vars.insert("Worker".into(), worker_ctor_val);
    g.vars.insert("TextEncoderStream".into(), text_encoder_stream_ctor_val);
    g.vars.insert("TextDecoderStream".into(), text_decoder_stream_ctor_val);
    g.vars.insert(
        "innerWidth".into(),
        Value::Number({
            let v =
                super::super::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
            if v > 0 {
                v as f64
            } else {
                1024.0
            }
        }),
    );
    g.vars.insert(
        "innerHeight".into(),
        Value::Number({
            let v =
                super::super::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
            if v > 0 {
                v as f64
            } else {
                600.0
            }
        }),
    );
    g.vars.insert(
        "getComputedStyle".into(),
        nv("getComputedStyle", get_computed_style),
    );
    g.vars.insert(
        "localStorage".into(),
        Value::Object(Obj::host("storage:local")),
    );
    g.vars.insert(
        "sessionStorage".into(),
        Value::Object(Obj::host("storage:session")),
    );

    // URL / URLSearchParams / URLPattern
    g.vars.insert(
        "URLSearchParams".into(),
        nv("URLSearchParams", url_search_params_ctor),
    );
    g.vars.insert(
        "URLPattern".into(),
        nv("URLPattern", url_pattern_ctor),
    );
    g.vars
        .insert("FormData".into(), nv("FormData", form_data_ctor));
    // `URL.canParse(url, base?)`（ES2023/WHATWG。`new URL()` を try/catch で
    // 包む定番の存在確認イディオムを1メソッドで完結させる）が丸ごと未対応
    // だった。
    // `URL.createObjectURL(blob)`/`.revokeObjectURL(url)`（`Blob`/`File` を
    // 一意な `blob:` URL へ変換する定番パターン）が丸ごと未対応だった。
    {
        let url_ctor_val = nv("URL", url_ctor);
        if let Value::Object(o) = &url_ctor_val {
            let mut b = o.borrow_mut();
            b.props.insert("canParse".into(), nv("URL.canParse", url_can_parse));
            // `URL.parse(url, base?)`（ES2024/WHATWG。丸ごと未対応だった。詳細は
            // url_parse 参照）。
            b.props.insert("parse".into(), nv("URL.parse", url_parse));
            b.props.insert(
                "createObjectURL".into(),
                nv("URL.createObjectURL", url_create_object_url),
            );
            b.props.insert(
                "revokeObjectURL".into(),
                nv("URL.revokeObjectURL", url_revoke_object_url),
            );
        }
        g.vars.insert("URL".into(), url_ctor_val);
    }

    // XMLSerializer（丸ごと未対応だった。`new XMLSerializer().serializeToString(node)`
    // という定番パターン。既存の `outerHTML` ゲッターと同じ
    // `DomBridge::get_outer_html` を再利用する。詳細は xml_serializer_ctor 参照）。
    g.vars
        .insert("XMLSerializer".into(), nv("XMLSerializer", xml_serializer_ctor));

    // URI エンコード
    g.vars.insert(
        "encodeURIComponent".into(),
        nv("encodeURIComponent", js_encode_uri_component),
    );
    g.vars.insert(
        "decodeURIComponent".into(),
        nv("decodeURIComponent", js_decode_uri_component),
    );
    g.vars
        .insert("encodeURI".into(), nv("encodeURI", js_encode_uri));
    g.vars
        .insert("decodeURI".into(), nv("decodeURI", js_decode_uri));
    // `escape`/`unescape`（Annex B.2.1）が丸ごと未対応だった。`encodeURI` 系より
    // 古い遺産だが、実務コードになお残る（詳細は各関数の実装コメント参照）。
    g.vars.insert("escape".into(), nv("escape", js_escape));
    g.vars.insert("unescape".into(), nv("unescape", js_unescape));
    // `new ClipboardItem({mimeType: blob})`（丸ごと未対応だった。
    // `navigator.clipboard.write()` に渡す定番パターン）。
    g.vars.insert("ClipboardItem".into(), nv("ClipboardItem", clipboard_item_ctor));
    // `new EyeDropper()`（EyeDropper API。丸ごと未対応だった。`.open()` で
    // 画面上の色を拾うカラーピッカー UI を開く定番パターン）。この処理系には
    // 実際のピッカー UI が無くいかなる色も本当には拾えないため、
    // `navigator.share` と同じ「できないことを楽観視しない」方針で、
    // ユーザーがピッカーをキャンセルした場合と同じ仕様どおりの `AbortError`
    // で常に拒否する。
    g.vars.insert("EyeDropper".into(), nv("EyeDropper", eye_dropper_ctor));

    // base64
    g.vars.insert("btoa".into(), nv("btoa", btoa));
    g.vars.insert("atob".into(), nv("atob", atob));

    // navigator（最小限）
    let navigator = Obj::plain();
    {
        let mut n = navigator.borrow_mut();
        n.props.insert(
            "userAgent".into(),
            Value::str("AtmOS/1.0 (Raspberry Pi; aarch64) AtmOSBrowser/1.0"),
        );
        n.props.insert("platform".into(), Value::str("AtmOS"));
        n.props.insert("language".into(), Value::str("ja-JP"));
        n.props.insert("onLine".into(), Value::Bool(true));
        n.props.insert("vendor".into(), Value::str("Sugimura Lab"));
        // `navigator.cookieEnabled`/`.hardwareConcurrency`/`.maxTouchPoints`/
        // `.languages`/`.webdriver`（丸ごと未対応だった。いずれも
        // `if (!navigator.cookieEnabled) {...}` 等のフィーチャー検出で
        // 参照される定番プロパティ）。`hardwareConcurrency` は QEMU 起動時の
        // `-smp 4`（RPi3B+ の実コア数）に合わせた固定値、`maxTouchPoints` は
        // タッチスクリーンが無いため 0、`webdriver` は自動操作されていない
        // ため `false` の固定値。
        n.props.insert("cookieEnabled".into(), Value::Bool(true));
        n.props
            .insert("hardwareConcurrency".into(), Value::Number(4.0));
        n.props.insert("maxTouchPoints".into(), Value::Number(0.0));
        n.props.insert(
            "languages".into(),
            Value::Object(Obj::array(alloc::vec![Value::str("ja-JP")])),
        );
        n.props.insert("webdriver".into(), Value::Bool(false));
        // `navigator.userAgentData`（Client Hints API。丸ごと未対応
        // だった。`navigator.userAgent`文字列パースに代わる構造化版の
        // 定番フィーチャー検出パターン。2026-07-17 発見・実装）。既存の
        // `userAgent`文字列（"AtmOSBrowser/1.0"）/`platform`（"AtmOS"）と
        // 整合する固定値を返す誠実な簡略実装。
        let ua_data = Obj::plain();
        {
            let mut u = ua_data.borrow_mut();
            let brand_entry = Obj::plain();
            brand_entry.borrow_mut().props.insert("brand".into(), Value::str("AtmOSBrowser"));
            brand_entry.borrow_mut().props.insert("version".into(), Value::str("1"));
            u.props.insert(
                "brands".into(),
                Value::Object(Obj::array(alloc::vec![Value::Object(brand_entry)])),
            );
            u.props.insert("mobile".into(), Value::Bool(false));
            u.props.insert("platform".into(), Value::str("AtmOS"));
            u.props.insert(
                "getHighEntropyValues".into(),
                nv("getHighEntropyValues", navigator_get_high_entropy_values),
            );
        }
        n.props.insert("userAgentData".into(), Value::Object(ua_data));
    }
    // `navigator.clipboard`（丸ごと未対応だった。`navigator.clipboard.writeText(...)`/
    // `readText()` というコピー&ペースト UI の定番パターン）。この OS には実際の
    // OS 全体で共有されるクリップボードが無いため、単純なプロセス内の文字列保持
    // （`_clipboard` prop）で近似する。
    let clipboard = Obj::plain();
    {
        let mut c = clipboard.borrow_mut();
        c.props.insert("_clipboard".into(), Value::str(""));
        c.props.insert("writeText".into(), nv("writeText", clipboard_write_text));
        c.props.insert("readText".into(), nv("readText", clipboard_read_text));
        // `navigator.clipboard.write(items)`/`.read()`（`ClipboardItem` 配列版。
        // 丸ごと未対応だった。`text/plain` エントリのみ対応する簡略実装で、
        // `writeText`/`readText` と同じ `_clipboard` prop を共有する）。
        c.props.insert("write".into(), nv("write", navigator_clipboard_write));
        c.props.insert("read".into(), nv("read", navigator_clipboard_read));
    }
    navigator
        .borrow_mut()
        .props
        .insert("clipboard".into(), Value::Object(clipboard));
    // `navigator.storage`（StorageManager API。`.estimate()`/`.persist()`/
    // `.persisted()`が丸ごと未対応だった。2026-07-17 発見）。この処理系
    // には実際のディスク使用量計測・永続化権限の概念が無い（SylFSへの
    // 書き込みは常に永続化される）ため、`usage: 0`（未計測の誠実な簡略値）・
    // `quota`は固定の代表値、`persist`/`persisted`は常に`true`を返す
    // 簡略実装。
    let storage_mgr = Obj::plain();
    {
        let mut s = storage_mgr.borrow_mut();
        s.props.insert("estimate".into(), nv("estimate", navigator_storage_estimate));
        s.props.insert("persist".into(), nv("persist", navigator_storage_persist));
        s.props.insert("persisted".into(), nv("persisted", navigator_storage_persist));
    }
    navigator
        .borrow_mut()
        .props
        .insert("storage".into(), Value::Object(storage_mgr));
    // `navigator.sendBeacon(url, data)`（丸ごと未対応だった。ページ離脱時の
    // 計測データ送信に使われる定番パターン。詳細は navigator_send_beacon 参照）。
    navigator
        .borrow_mut()
        .props
        .insert("sendBeacon".into(), nv("sendBeacon", navigator_send_beacon));
    // `navigator.geolocation`（丸ごと未対応だった。`getCurrentPosition(success,
    // error, options)`/`watchPosition(...)`/`clearWatch(id)` という位置情報
    // 取得の定番パターン）。この OS には実際の位置情報ハードウェア/OS権限機構が
    // 一切無いため、常に `errorCallback` を `PERMISSION_DENIED`（実ブラウザで
    // 権限拒否時に返る値と同じコード）で同期的に呼ぶ簡略実装とする（`clipboard`
    // のような部分的な近似すら成立しない、この処理系に無い機能そのものであるため）。
    let geolocation = Obj::plain();
    {
        let mut geo = geolocation.borrow_mut();
        geo.props.insert(
            "getCurrentPosition".into(),
            nv("getCurrentPosition", geolocation_get_current_position),
        );
        geo.props
            .insert("watchPosition".into(), nv("watchPosition", geolocation_watch_position));
        geo.props
            .insert("clearWatch".into(), nv("clearWatch", geolocation_clear_watch));
    }
    navigator
        .borrow_mut()
        .props
        .insert("geolocation".into(), Value::Object(geolocation));
    // `navigator.permissions.query({name})`（丸ごと未対応だった。`if
    // ((await navigator.permissions.query({name:'geolocation'})).state ===
    // 'granted') {...}` という定番の機能可否事前判定パターン）。この処理系には
    // 実際の権限プロンプト UI が無いため、各 API の実装状況と整合する固定値を
    // 返す簡略実装とする（`geolocation` は常に `PERMISSION_DENIED` を返す実装
    // と整合させ `denied`、`Notification.permission` が常に `granted` と
    // 整合する `notifications` は `granted`、その他は `prompt`）。
    let permissions = Obj::plain();
    permissions
        .borrow_mut()
        .props
        .insert("query".into(), nv("permissions.query", permissions_query));
    navigator
        .borrow_mut()
        .props
        .insert("permissions".into(), Value::Object(permissions));
    // `navigator.wakeLock.request(type)`（Screen Wake Lock API。丸ごと未対応
    // だった。`await navigator.wakeLock.request('screen')` でスリープ抑制を
    // 要求する定番パターン）。この処理系には実際の電源管理機構が無いため、
    // `WakeLockSentinel` 相当の `{released, type, release()}` を状態のみ
    // 追跡する簡略実装で返す（`release` イベントは対象外）。
    let wake_lock = Obj::plain();
    wake_lock
        .borrow_mut()
        .props
        .insert("request".into(), nv("wakeLock.request", wake_lock_request));
    navigator
        .borrow_mut()
        .props
        .insert("wakeLock".into(), Value::Object(wake_lock));
    // `navigator.share(data)`/`navigator.canShare(data)`（Web Share API。
    // 丸ごと未対応だった。`await navigator.share({title, url})` でネイティブ
    // 共有シートを開く定番パターン）。この処理系には実際の共有先 UI が無い
    // ため、`navigator.geolocation` が実位置情報を取得できない以上
    // `PERMISSION_DENIED` を返すのと同じ「できないことを楽観視しない」方針で、
    // `canShare` は常に `false`、`share` は仕様どおり `AbortError` で拒否する
    // （何も共有できていないのに成功を偽装しない）。
    navigator
        .borrow_mut()
        .props
        .insert("canShare".into(), nv("navigator.canShare", navigator_can_share));
    navigator
        .borrow_mut()
        .props
        .insert("share".into(), nv("navigator.share", navigator_share));
    // `navigator.vibrate(pattern)`（Vibration API。丸ごと未対応だった）。
    // 仕様上この戻り値は「振動リクエストを受理したか」のみを表し、実際に
    // 振動モーターが存在するかとは無関係（ハードウェアの無い環境でも `true`
    // を返すのが仕様どおりの正しい挙動）なので、`geolocation` とは異なり
    // 常に `true` を返す簡略実装で問題ない。
    navigator
        .borrow_mut()
        .props
        .insert("vibrate".into(), nv("navigator.vibrate", navigator_vibrate));
    // `navigator.getBattery()`（Battery Status API。丸ごと未対応だった）。
    // このOSのターゲット（Raspberry Pi）はバッテリー非搭載で常時 AC 電源
    // 動作のため、「常時満充電で給電中」という値は楽観視の偽装ではなく
    // 実態に即した誠実な近似（`charging:true`/`level:1`/`chargingTime:0`/
    // `dischargingTime:Infinity`）。`levelchange` 等のイベントは対象外。
    navigator
        .borrow_mut()
        .props
        .insert("getBattery".into(), nv("navigator.getBattery", navigator_get_battery));
    // `navigator.connection`（Network Information API。丸ごと未対応
    // だった。`if (navigator.connection.saveData) {...}` という低速回線向け
    // 最適化分岐の定番パターン）。この処理系には実際の帯域/往復遅延の計測
    // 機構が無いため、`saveData:false`（節約モードを要求されていないと
    // 仮定する既定値）と一般的なブロードバンド相当の代表値を返す簡略実装
    // （`change` イベントは対象外）。
    let connection = Obj::plain();
    {
        let mut c = connection.borrow_mut();
        c.props.insert("type".into(), Value::str("ethernet"));
        c.props.insert("effectiveType".into(), Value::str("4g"));
        c.props.insert("downlink".into(), Value::Number(10.0));
        c.props.insert("rtt".into(), Value::Number(50.0));
        c.props.insert("saveData".into(), Value::Bool(false));
        c.props
            .insert("addEventListener".into(), nv("addEventListener", dom_noop));
        c.props
            .insert("removeEventListener".into(), nv("removeEventListener", dom_noop));
    }
    navigator
        .borrow_mut()
        .props
        .insert("connection".into(), Value::Object(connection));
    // `navigator.locks`（Web Locks API。丸ごと未対応だった）。この処理系には
    // 複数タブ/複数ワーカー間の実際の競合排他機構が無い（単一ドキュメント・
    // 単一スレッドの JS 実行モデル）ため、`request(name, callback)` は
    // コールバックを即座に同期呼び出しし、その戻り値で解決する Promise を
    // 返す簡略実装（`options` 引数中の `signal`/`mode`/`ifAvailable`/
    // `steal` は対象外）。`query()` は保持中/待機中とも常に空。
    let locks = Obj::plain();
    {
        let mut l = locks.borrow_mut();
        l.props.insert("request".into(), nv("navigator.locks.request", navigator_locks_request));
        l.props.insert("query".into(), nv("navigator.locks.query", navigator_locks_query));
    }
    navigator.borrow_mut().props.insert("locks".into(), Value::Object(locks));
    g.vars.insert("navigator".into(), Value::Object(navigator));

    // performance.now（疑似単調増加）
    let performance = Obj::plain();
    performance
        .borrow_mut()
        .props
        .insert("now".into(), nv("performance.now", performance_now));
    // `performance.timeOrigin`（丸ごと未対応だった。`performance.now()`が
    // 相対時刻の基準とする実時刻を表す。ページ読込=プロセス起動という
    // この処理系の簡略化と整合させ、グローバル初期化時点の実時刻を
    // 固定値として使う）。
    performance
        .borrow_mut()
        .props
        .insert("timeOrigin".into(), Value::Number(epoch_ms_now()));
    // 【2026-10-03】`performance.timing`（Navigation Timing Level 1）と `performance.navigation`。
    // 非推奨だが全ブラウザが持ち、Cloudflare の beacon.min.js が `performance.timing.navigationStart`
    // を読んで落ちていた（sugi-lab.net 全ページで JS エラー 1 件）。この処理系は各段階の時刻を
    // 測っていないので、すべて読込開始時刻（timeOrigin）とする。起きていない unload/redirect は
    // 仕様どおり 0。
    {
        let origin = libm::floor(epoch_ms_now());
        let timing = Obj::plain();
        {
            let mut t = timing.borrow_mut();
            for key in [
                "navigationStart", "fetchStart", "domainLookupStart", "domainLookupEnd",
                "connectStart", "connectEnd", "secureConnectionStart", "requestStart",
                "responseStart", "responseEnd", "domLoading", "domInteractive",
                "domContentLoadedEventStart", "domContentLoadedEventEnd", "domComplete",
                "loadEventStart", "loadEventEnd",
            ] {
                t.props.insert(key.into(), Value::Number(origin));
            }
            for key in ["unloadEventStart", "unloadEventEnd", "redirectStart", "redirectEnd"] {
                t.props.insert(key.into(), Value::Number(0.0));
            }
        }
        let navigation = Obj::plain();
        {
            let mut n = navigation.borrow_mut();
            n.props.insert("type".into(), Value::Number(0.0)); // TYPE_NAVIGATE
            n.props.insert("redirectCount".into(), Value::Number(0.0));
        }
        let mut p = performance.borrow_mut();
        p.props.insert("timing".into(), Value::Object(timing));
        p.props.insert("navigation".into(), Value::Object(navigation));
    }
    // Performance Timeline / User Timing API（`mark`/`measure`/
    // `getEntriesByType`/`getEntriesByName`/`clearMarks`/`clearMeasures`）が
    // `now()` 以外丸ごと未対応だった（プロファイリングの定番イディオム
    // `performance.mark('start'); ...; performance.measure('x','start')` が
    // 軒並み TypeError）。
    {
        let mut p = performance.borrow_mut();
        p.props.insert("_entries".into(), Value::Object(Obj::array(alloc::vec::Vec::new())));
        p.props.insert("mark".into(), nv("mark", perf_mark));
        p.props.insert("measure".into(), nv("measure", perf_measure));
        // `performance.getEntries()`（フィルタ無しの全件取得。丸ごと未対応
        // だった。`getEntriesByType`/`getEntriesByName` は既に対応済み
        // だったが、素の `getEntries()` 自体が欠けていた）。
        p.props.insert("getEntries".into(), nv("getEntries", perf_get_entries));
        p.props.insert(
            "getEntriesByType".into(),
            nv("getEntriesByType", perf_get_entries_by_type),
        );
        p.props.insert(
            "getEntriesByName".into(),
            nv("getEntriesByName", perf_get_entries_by_name),
        );
        p.props.insert("clearMarks".into(), nv("clearMarks", perf_clear_marks));
        p.props
            .insert("clearMeasures".into(), nv("clearMeasures", perf_clear_measures));
        // `PerformanceObserver` が監視対象を登録する先（丸ごと未対応だった。
        // 詳細は performance_observer_ctor 参照）。
        p.props
            .insert("_observers".into(), Value::Object(Obj::array(alloc::vec::Vec::new())));
    }
    g.vars
        .insert("performance".into(), Value::Object(performance));
    let performance_observer_ctor_val = nv("PerformanceObserver", performance_observer_ctor);
    // `PerformanceObserver.supportedEntryTypes`（静的プロパティ。丸ごと未対応
    // だった）。この処理系のパフォーマンスタイムラインが実際に生成する
    // エントリ種別は `mark`/`measure` のみのため、誠実にその2種のみを返す
    // （`navigation`/`resource`等、実装していない種別は含めない）。
    if let Value::Object(po) = &performance_observer_ctor_val {
        po.borrow_mut().props.insert(
            "supportedEntryTypes".into(),
            Value::Object(Obj::array(alloc::vec![Value::str("mark"), Value::str("measure")])),
        );
    }
    g.vars
        .insert("PerformanceObserver".into(), performance_observer_ctor_val);

    // ArrayBuffer / TypedArray 全種別（簡易実装。内部表現は通常の
    // ObjKind::Array(Vec<Value::Number>) を流用し、buffer は別インスタンスの独立コピー
    // — 真の共有メモリビューではない。BigInt64Array/BigUint64Array は対象外）。
    let ab_ctor = nv("ArrayBuffer", arraybuffer_ctor);
    if let Value::Object(o) = &ab_ctor {
        o.borrow_mut()
            .props
            .insert("isView".into(), nv("isView", arraybuffer_is_view));
    }
    g.vars.insert("ArrayBuffer".into(), ab_ctor);
    let mut register_typed_array = |name: &str, ctor: NativeFn, from_fn: NativeFn| {
        let f = nv(name, ctor);
        if let Value::Object(o) = &f {
            o.borrow_mut()
                .props
                .insert("from".into(), nv("from", from_fn));
            let proto = Obj::plain();
            proto.borrow_mut().proto = Some(object_proto.clone());
            o.borrow_mut()
                .props
                .insert("prototype".into(), Value::Object(proto.clone()));
            proto
                .borrow_mut()
                .props
                .insert("constructor".into(), f.clone());
        }
        g.vars.insert(String::from(name), f);
    };
    register_typed_array("Uint8Array", uint8array_ctor, uint8array_from);
    register_typed_array("Int8Array", int8array_ctor, int8array_from);
    register_typed_array(
        "Uint8ClampedArray",
        uint8clampedarray_ctor,
        uint8clampedarray_from,
    );
    register_typed_array("Int16Array", int16array_ctor, int16array_from);
    register_typed_array("Uint16Array", uint16array_ctor, uint16array_from);
    register_typed_array("Int32Array", int32array_ctor, int32array_from);
    register_typed_array("Uint32Array", uint32array_ctor, uint32array_from);
    register_typed_array("Float16Array", float16array_ctor, float16array_from);
    register_typed_array("Float32Array", float32array_ctor, float32array_from);
    register_typed_array("Float64Array", float64array_ctor, float64array_from);
    // `Uint8Array.fromBase64`/`fromHex`（ES2024/2025 静的メソッド）。
    if let Some(Value::Object(u8a)) = g.vars.get("Uint8Array").cloned() {
        u8a.borrow_mut()
            .props
            .insert("fromBase64".into(), nv("fromBase64", ta_from_base64));
        u8a.borrow_mut()
            .props
            .insert("fromHex".into(), nv("fromHex", ta_from_hex));
    }
    // DataView（ES2015）。丸ごと未対応で `new DataView(buf)` が
    // `DataView is not defined` になっていた。ArrayBuffer が実バイト列を持たない
    // 独立コピー簡易実装なのと同様、内部にバイト列（`ObjKind::Array` 流用）を
    // 独自に確保する（真の共有メモリビューではない）。
    g.vars.insert("DataView".into(), nv("DataView", dataview_ctor));
    // Blob（File API の基礎コンテナ。丸ごと未対応だった。File/FileReader/実 I/O は
    // この OS には実ファイル選択 UI が存在しないため対象外のまま、メモリ上のバイト列
    // コンテナとしての Blob 単体のみ対応する）。
    g.vars.insert("Blob".into(), nv("Blob", blob_ctor));
    // `File`（`Blob` を継承し `name`/`lastModified` を追加するファイル API の
    // 基礎コンストラクタ）が丸ごと未対応だった。`Blob` は既に対応済みだったため、
    // `new File(['x'], 'a.txt', {type, lastModified})` という定番パターンが
    // `File is not defined` になっていた。
    g.vars.insert("File".into(), nv("File", file_ctor));
    // `new Option(text?, value?, defaultSelected?, selected?)`（HTML5。
    // `document.createElement('option')` + `.text`/`.value`/`.selected` の
    // 個別代入を1呼び出しに縮める定番ショートハンド）が丸ごと未対応だった
    // （`Option is not defined`）。`defaultSelected` は `selected` 属性の
    // 初期値として、`selected` は同じ意味の別名として扱う簡略方針（本物の
    // `defaultSelected`/`selected` プロパティ分離は `input.defaultValue` と
    // 同種の既知の未対応）。
    g.vars.insert("Option".into(), nv("Option", option_ctor));
    // `FileReader`（`Blob`/`File` の内容を非同期に読み出す定番の従来型 API。
    // `blob.text()`/`.arrayBuffer()` という Promise 版は既に対応済みだったが、
    // `reader.readAsText(blob)` + `reader.onload = ...` という古典的な
    // イベントベースの書き方自体が丸ごと未対応だった）が丸ごと未対応だった。
    // 実際の非同期 I/O が無いこの処理系では読み出しは同期的に完了するため、
    // 完了後すぐに `onload`/`onloadend` を呼ぶ簡略実装とする。
    g.vars
        .insert("FileReader".into(), nv("FileReader", file_reader_ctor));

    // Notification（丸ごと未対応だった）。この OS には通知 UI 自体が無いため、
    // `element.requestFullscreen()`/`document.execCommand` と同じ「実際の見た目の
    // 変化は伴わないが JS 側の契約（プロパティ/Promise の形）は満たす」簡略実装
    // とする。許可拒否ダイアログが存在しないため常に `"granted"`。詳細は
    // notification_ctor 参照。
    {
        let notification_ctor_val = nv("Notification", notification_ctor);
        if let Value::Object(o) = &notification_ctor_val {
            let mut b = o.borrow_mut();
            b.props.insert("permission".into(), Value::str("granted"));
            b.props.insert(
                "requestPermission".into(),
                nv("requestPermission", notification_request_permission),
            );
        }
        g.vars.insert("Notification".into(), notification_ctor_val);
    }

    // TextEncoder / TextDecoder
    g.vars
        .insert("TextEncoder".into(), nv("TextEncoder", text_encoder_ctor));
    g.vars
        .insert("TextDecoder".into(), nv("TextDecoder", text_decoder_ctor));

    // DOMParser（DOM Parsing and Serialization API。HTML文字列からDOMツリーを生成）
    g.vars
        .insert("DOMParser".into(), nv("DOMParser", dom_parser_ctor));

    // crypto
    let crypto = Obj::plain();
    {
        let mut c = crypto.borrow_mut();
        c.props
            .insert("randomUUID".into(), nv("randomUUID", crypto_random_uuid));
        c.props.insert(
            "getRandomValues".into(),
            nv("getRandomValues", crypto_get_random_values),
        );
        // `crypto.subtle`（SubtleCrypto）が丸ごと未対応だった。`digest('SHA-256',
        // data)`のみの部分実装（詳細はbuiltins/crypto_subtle.rsのモジュール
        // doc参照。2026-07-18 発見・実装）。
        let subtle = Obj::plain();
        subtle
            .borrow_mut()
            .props
            .insert("digest".into(), nv("digest", subtle_digest));
        c.props.insert("subtle".into(), Value::Object(subtle));
    }
    g.vars.insert("crypto".into(), Value::Object(crypto));

    // structuredClone
    g.vars.insert(
        "structuredClone".into(),
        nv("structuredClone", structured_clone),
    );

    // AbortController（fetch のキャンセル等。signal.aborted を立てる最小実装）
    g.vars.insert(
        "AbortController".into(),
        nv("AbortController", abort_controller_ctor),
    );
    // `AbortSignal`（ES2022。`AbortSignal.timeout(ms)`/`.abort(reason)` という
    // fetch タイムアウト実装の定番イディオムで使われる静的ファクトリ）が、
    // `AbortController` 経由でしか signal を得られず丸ごと未対応だった。
    // `new AbortSignal()` は仕様上直接構築不可のため、静的メソッドのみを持つ
    // ただのオブジェクトとして登録する。
    // 【2026-10-17】素のオブジェクトだったため `AbortSignal.prototype` が無く、
    // `typeof AbortSignal.prototype.throwIfAborted` で判定するポリフィル（YouTube）が落ちていた。
    // 直接は構築できない関数（ブラウザと同じ）にし、prototype は下の補完で付く。
    {
        let abort_signal_ns = Obj::native("AbortSignal", abort_signal_illegal_ctor);
        abort_signal_ns
            .borrow_mut()
            .props
            .insert("timeout".into(), nv("AbortSignal.timeout", abort_signal_timeout));
        abort_signal_ns
            .borrow_mut()
            .props
            .insert("abort".into(), nv("AbortSignal.abort", abort_signal_abort_static));
        abort_signal_ns
            .borrow_mut()
            .props
            .insert("any".into(), nv("AbortSignal.any", abort_signal_any));
        g.vars
            .insert("AbortSignal".into(), Value::Object(abort_signal_ns));
    }
    // EventTarget（丸ごと未対応だった。DOM 要素以外で独自のイベント発行/購読の
    // 基盤として使う定番パターン。他の EventTarget 風オブジェクト[XHR/AbortSignal]と
    // 違い、型ごとに複数リスナを保持する仕様どおりの実装）。
    // EventTarget.prototype（ShadyDOM が native のメソッドを写す元。Node/Window の原型の親）。
    let event_target_proto = Obj::plain();
    {
        let mut b = event_target_proto.borrow_mut();
        b.props.insert("addEventListener".into(), nv("addEventListener", event_target_proto_add));
        b.props.insert("removeEventListener".into(), nv("removeEventListener", event_target_proto_remove));
        b.props.insert("dispatchEvent".into(), nv("dispatchEvent", event_target_proto_dispatch));
    }
    {
        let et_ctor = nv("EventTarget", event_target_ctor);
        if let Value::Object(c) = &et_ctor {
            c.borrow_mut().props.insert("prototype".into(), Value::Object(event_target_proto.clone()));
            event_target_proto.borrow_mut().props.insert("constructor".into(), et_ctor.clone());
        }
        g.vars.insert("EventTarget".into(), et_ctor);
    }
    // MessageChannel/MessagePort（丸ごと未対応だった。`new MessageChannel()` の
    // `.port1`/`.port2` 双方向チャネルで Worker 間通信を模す定番パターン。
    // 詳細は message_channel_ctor 参照）。
    g.vars
        .insert("MessageChannel".into(), nv("MessageChannel", message_channel_ctor));
    // BroadcastChannel（丸ごと未対応だった。`new BroadcastChannel(name)` で同名の
    // 他インスタンス全てへブロードキャストする定番パターン。詳細は
    // broadcast_channel_ctor 参照）。
    g.vars
        .insert("BroadcastChannel".into(), nv("BroadcastChannel", broadcast_channel_ctor));
    g.vars.insert("CSSStyleSheet".into(), Value::Object(Obj::plain()));
    g.vars.insert("CSSStyleRule".into(), Value::Object(Obj::plain()));
    // DOM コンストラクタ階層 (Node -> Element -> HTMLElement -> HTMLXxxElement)
    // 仕様どおり TypeError("Illegal constructor") を投げる NativeFunction コンストラクタと
    // 正しい prototype 継承チェーンを構築し、`el instanceof HTMLInputElement` や `el instanceof Node` を可能にする。
    {
        let make_dom_cls = |name: &str, parent_proto: Option<&ObjRef>| -> (Value, ObjRef) {
            // `new Node()`/`new HTMLElement()`等（仕様上どれも直接構築不可の
            // 抽象/イリーガルコンストラクタ）は`TypeError`を投げるべきだが、
            // 以前は`it.error()`（`Error.prototype`に繋がる汎用エラー）を
            // 使っていたため、メッセージ文字列こそ"TypeError: ..."だが
            // `instanceof TypeError`は満たさないバグだった（2026-07-18
            // 発見・修正）。
            // カスタム要素のクラスの `super()` では this が DOM 要素のハンドル（`construct_object`
            // が用意する）。そのときは何もしない。
            let ctor = Obj::native(name, |it, this, _| match &this {
                Value::Object(o) if matches!(o.borrow().kind, ObjKind::DomElement(_)) => Ok(this.clone()),
                _ => Err(it.type_error("Illegal constructor")),
            });
            let proto = Obj::plain();
            if let Some(parent) = parent_proto {
                proto.borrow_mut().proto = Some(parent.clone());
            }
            proto
                .borrow_mut()
                .props
                .insert("constructor".into(), Value::Object(ctor.clone()));
            ctor.borrow_mut()
                .props
                .insert("prototype".into(), Value::Object(proto.clone()));
            (Value::Object(ctor), proto)
        };

        let (node_ctor, node_proto) = make_dom_cls("Node", Some(&event_target_proto));
        let (element_ctor, element_proto) = make_dom_cls("Element", Some(&node_proto));
        dom_forward::install(&node_proto, &element_proto);
        let (html_element_ctor, html_element_proto) = make_dom_cls("HTMLElement", Some(&element_proto));

        let consts: &[(&str, f64)] = &[
            ("ELEMENT_NODE", 1.0),
            ("ATTRIBUTE_NODE", 2.0),
            ("TEXT_NODE", 3.0),
            ("CDATA_SECTION_NODE", 4.0),
            ("PROCESSING_INSTRUCTION_NODE", 7.0),
            ("COMMENT_NODE", 8.0),
            ("DOCUMENT_NODE", 9.0),
            ("DOCUMENT_TYPE_NODE", 10.0),
            ("DOCUMENT_FRAGMENT_NODE", 11.0),
            ("DOCUMENT_POSITION_DISCONNECTED", 1.0),
            ("DOCUMENT_POSITION_PRECEDING", 2.0),
            ("DOCUMENT_POSITION_FOLLOWING", 4.0),
            ("DOCUMENT_POSITION_CONTAINS", 8.0),
            ("DOCUMENT_POSITION_CONTAINED_BY", 16.0),
            ("DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", 32.0),
        ];
        if let Value::Object(c) = &node_ctor {
            for (name, val) in consts {
                c.borrow_mut()
                    .props
                    .insert(String::from(*name), Value::Number(*val));
            }
        }

        g.vars.insert("Node".into(), node_ctor);
        g.vars.insert("Element".into(), element_ctor);
        g.vars.insert("HTMLElement".into(), html_element_ctor);
        // その他の DOM インターフェース（`instanceof`・`X.prototype` の参照・ポリフィルの存在確認用）。
        // 【2026-10-17】`Document is not defined` 等で YouTube のポリフィルが落ちていた。
        {
            let (_, chardata_proto) = {
                let (c, p) = make_dom_cls("CharacterData", Some(&node_proto));
                g.vars.insert("CharacterData".into(), c);
                ((), p)
            };
            for name in ["Text", "Comment", "CDATASection", "ProcessingInstruction"] {
                let (c, _) = make_dom_cls(name, Some(&chardata_proto));
                g.vars.insert(name.into(), c);
            }
            // 【2026-10-19】`Window`（大域オブジェクトの型。YouTube の視聴ページが参照し、
            // 「Window is not defined」で止まっていた）。`window instanceof Window` が真になるよう
            // window の原型を Window.prototype にする。
            let (win_ctor, win_proto) = make_dom_cls("Window", Some(&event_target_proto));
            g.vars.insert("Window".into(), win_ctor);
            if let Some(Value::Object(w)) = g.vars.get("window").cloned() {
                let mut wb = w.borrow_mut();
                if wb.proto.is_none() {
                    wb.proto = Some(win_proto.clone());
                }
            }
            let (doc_ctor, doc_proto) = make_dom_cls("Document", Some(&node_proto));
            dom_forward::install_document(&doc_proto);
            g.vars.insert("Document".into(), doc_ctor);
            let (hdoc, hdoc_proto) = make_dom_cls("HTMLDocument", Some(&doc_proto));
            g.vars.insert("HTMLDocument".into(), hdoc);
            // document の原型を HTMLDocument.prototype に（→ Document → Node → EventTarget）。
            if let Some(Value::Object(d)) = g.vars.get("document").cloned() {
                let mut db = d.borrow_mut();
                if db.proto.is_none() {
                    db.proto = Some(hdoc_proto.clone());
                }
            }
            for name in ["DocumentType", "Attr"] {
                let (c, _) = make_dom_cls(name, Some(&node_proto));
                g.vars.insert(name.into(), c);
            }
            let (df, df_proto) = make_dom_cls("DocumentFragment", Some(&node_proto));
            dom_forward::install_fragment(&df_proto);
            g.vars.insert("DocumentFragment".into(), df);
            // ShadowRoot は DocumentFragment を継承する（DOM 標準）。
            let (sr, _) = make_dom_cls("ShadowRoot", Some(&df_proto));
            g.vars.insert("ShadowRoot".into(), sr);
            let (svg, _) = make_dom_cls("SVGElement", Some(&element_proto));
            g.vars.insert("SVGElement".into(), svg);
            let (media, media_proto) = make_dom_cls("HTMLMediaElement", Some(&html_element_proto));
            g.vars.insert("HTMLMediaElement".into(), media);
            for name in ["HTMLVideoElement", "HTMLAudioElement"] {
                let (c, _) = make_dom_cls(name, Some(&media_proto));
                g.vars.insert(name.into(), c);
            }
            for name in [
                "HTMLDivElement", "HTMLSpanElement", "HTMLAnchorElement", "HTMLImageElement",
                "HTMLButtonElement", "HTMLFormElement", "HTMLSelectElement", "HTMLOptionElement",
                "HTMLTextAreaElement", "HTMLLabelElement", "HTMLScriptElement", "HTMLStyleElement",
                "HTMLLinkElement", "HTMLMetaElement", "HTMLHeadElement", "HTMLBodyElement",
                "HTMLHtmlElement", "HTMLTemplateElement", "HTMLIFrameElement", "HTMLCanvasElement",
                "HTMLParagraphElement", "HTMLHeadingElement", "HTMLUListElement", "HTMLOListElement",
                "HTMLLIElement", "HTMLTableElement", "HTMLTableRowElement", "HTMLTableCellElement",
                "HTMLSlotElement", "HTMLUnknownElement", "HTMLDialogElement", "HTMLPreElement",
                "HTMLBRElement", "HTMLHRElement", "HTMLSourceElement", "HTMLTrackElement",
            ] {
                if !g.vars.contains_key(name) {
                    let (c, _) = make_dom_cls(name, Some(&html_element_proto));
                    g.vars.insert(name.into(), c);
                }
            }
        }
        // `new Image(w, h)` / `new Audio(src)`（HTML の「名前付きコンストラクタ」。丸ごと未対応で
        // `Image is not defined` になっていた。YouTube のエラー報告・計測ビーコンが使う）。
        g.vars.insert("Image".into(), nv("Image", image_ctor));
        g.vars.insert("Audio".into(), nv("Audio", audio_ctor));

        let (nodelist_ctor, nodelist_proto) = make_dom_cls("NodeList", None);
        let (htmlcollection_ctor, _) = make_dom_cls("HTMLCollection", None);
        let (radionodelist_ctor, _) = make_dom_cls("RadioNodeList", Some(&nodelist_proto));
        g.vars.insert("NodeList".into(), nodelist_ctor);
        g.vars.insert("HTMLCollection".into(), htmlcollection_ctor);
        g.vars.insert("RadioNodeList".into(), radionodelist_ctor);

        let html_classes = &[
            "HTMLInputElement",
            "HTMLFormElement",
            "HTMLAnchorElement",
            "HTMLImageElement",
            "HTMLButtonElement",
            "HTMLSelectElement",
            "HTMLOptionElement",
            "HTMLTextAreaElement",
            "HTMLDivElement",
            "HTMLSpanElement",
            "HTMLScriptElement",
            "HTMLStyleElement",
            "HTMLIFrameElement",
            "HTMLCanvasElement",
            "HTMLParagraphElement",
            "HTMLHeadingElement",
            "HTMLTableElement",
            "HTMLTableRowElement",
            "HTMLTableCellElement",
            "HTMLUListElement",
            "HTMLLIElement",
            "HTMLTemplateElement",
            "HTMLUnknownElement",
        ];

        for cls_name in html_classes {
            let (ctor, _) = make_dom_cls(cls_name, Some(&html_element_proto));
            if *cls_name == "HTMLScriptElement" {
                if let Value::Object(c) = &ctor {
                    c.borrow_mut().props.insert(
                        String::from("supports"),
                        nv("HTMLScriptElement.supports", |_: &mut Interp, _: Value, a: &[Value]| {
                            let ty = a.first().map(|v| v.to_js_string()).unwrap_or_default();
                            Ok(Value::Bool(matches!(ty.as_str(), "classic" | "module")))
                        }),
                    );
                }
            }
            g.vars.insert((*cls_name).into(), ctor);
        }
    }

    // IntersectionObserver（DOM Ready 後にコールバックを全要素 visible で発火）
    g.vars.insert(
        "IntersectionObserver".into(),
        nv("IntersectionObserver", intersection_observer_ctor),
    );

    // ResizeObserver（observe 時に即時コールバック発火）
    g.vars.insert(
        "ResizeObserver".into(),
        nv("ResizeObserver", resize_observer_ctor),
    );

    // MutationObserver（observe/disconnect no-op として登録）
    g.vars.insert(
        "MutationObserver".into(),
        nv("MutationObserver", mutation_observer_ctor),
    );

    // CustomEvent コンストラクタ
    g.vars
        .insert("CustomEvent".into(), nv("CustomEvent", custom_event_ctor));

    // Event コンストラクタ（new Event('foo', {bubbles, cancelable})）
    // `Event.NONE`/`.CAPTURING_PHASE`/`.AT_TARGET`/`.BUBBLING_PHASE`
    // （`event.eventPhase === Event.AT_TARGET` という `Node.ELEMENT_NODE` と
    // 同型の定番パターンで使われる標準定数）が丸ごと未対応だった。
    {
        let event_ctor_val = nv("Event", event_ctor);
        if let Value::Object(o) = &event_ctor_val {
            let phase_consts: &[(&str, f64)] = &[
                ("NONE", 0.0),
                ("CAPTURING_PHASE", 1.0),
                ("AT_TARGET", 2.0),
                ("BUBBLING_PHASE", 3.0),
            ];
            for (name, val) in phase_consts {
                o.borrow_mut()
                    .props
                    .insert(String::from(*name), Value::Number(*val));
            }
        }
        g.vars.insert("Event".into(), event_ctor_val);
    }

    // KeyboardEvent/MouseEvent コンストラクタ（丸ごと未対応だった。
    // `el.dispatchEvent(new KeyboardEvent('keydown', {key:'a'}))`/
    // `new MouseEvent('click', {clientX, clientY})` というシミュレーション
    // イベント構築の定番パターン。詳細は各 ctor 参照）。
    g.vars
        .insert("KeyboardEvent".into(), nv("KeyboardEvent", keyboard_event_ctor));
    g.vars
        .insert("MouseEvent".into(), nv("MouseEvent", mouse_event_ctor));
    // WheelEvent/FocusEvent コンストラクタ（丸ごと未対応だった。詳細は
    // 各 ctor 参照）。
    g.vars
        .insert("WheelEvent".into(), nv("WheelEvent", wheel_event_ctor));
    g.vars
        .insert("FocusEvent".into(), nv("FocusEvent", focus_event_ctor));
    // Touch/TouchEvent コンストラクタ（丸ごと未対応だった。詳細は各 ctor 参照）。
    g.vars.insert("Touch".into(), nv("Touch", touch_ctor));
    g.vars
        .insert("TouchEvent".into(), nv("TouchEvent", touch_event_ctor));
    // `DOMRect`/`DOMRectReadOnly`コンストラクタ（丸ごと未対応だった。
    // Geometry Interfaces Module Level 1 仕様準拠。2026-07-21 拡張）。
    let dom_rect_fn = nv("DOMRect", dom_rect_ctor);
    if let Value::Object(ref o) = dom_rect_fn {
        o.borrow_mut().props.insert("fromRect".into(), nv("fromRect", dom_rect_from_rect));
    }
    g.vars.insert("DOMRect".into(), dom_rect_fn.clone());
    g.vars.insert("DOMRectReadOnly".into(), dom_rect_fn);

    // `DOMPoint`/`DOMPointReadOnly`コンストラクタ（丸ごと未対応だった。
    // Geometry Interfaces Module Level 1 仕様準拠。2026-07-21 拡張）。
    let dom_point_fn = nv("DOMPoint", dom_point_ctor);
    if let Value::Object(ref o) = dom_point_fn {
        o.borrow_mut().props.insert("fromPoint".into(), nv("fromPoint", dom_point_from_point));
    }
    g.vars.insert("DOMPoint".into(), dom_point_fn.clone());
    g.vars.insert("DOMPointReadOnly".into(), dom_point_fn);
    // `DOMMatrix`/`DOMMatrixReadOnly`/`DOMQuad`コンストラクタ（丸ごと未対応だった。
    // Geometry Interfaces Module Level 1 仕様準拠。2026-07-21 実装）。
    let dom_matrix_fn = nv("DOMMatrix", dom_matrix_ctor);
    if let Value::Object(ref o) = dom_matrix_fn {
        o.borrow_mut().props.insert("fromMatrix".into(), nv("fromMatrix", |it, _, a| dom_matrix_ctor(it, Value::Undefined, a)));
        o.borrow_mut().props.insert("fromFloat32Array".into(), nv("fromFloat32Array", |it, _, a| dom_matrix_ctor(it, Value::Undefined, a)));
        o.borrow_mut().props.insert("fromFloat64Array".into(), nv("fromFloat64Array", |it, _, a| dom_matrix_ctor(it, Value::Undefined, a)));
    }
    g.vars.insert("DOMMatrix".into(), dom_matrix_fn.clone());
    g.vars.insert("DOMMatrixReadOnly".into(), dom_matrix_fn);

    let dom_quad_fn = nv("DOMQuad", dom_quad_ctor);
    if let Value::Object(ref o) = dom_quad_fn {
        o.borrow_mut().props.insert("fromRect".into(), nv("fromRect", |it, _, a| {
            let r = arg(a, 0);
            let rx = it.get_property(&r, "x").unwrap_or(Value::Number(0.0)).to_number();
            let ry = it.get_property(&r, "y").unwrap_or(Value::Number(0.0)).to_number();
            let rw = it.get_property(&r, "width").unwrap_or(Value::Number(0.0)).to_number();
            let rh = it.get_property(&r, "height").unwrap_or(Value::Number(0.0)).to_number();
            let p1 = dom_point_ctor(it, Value::Undefined, &[Value::Number(rx), Value::Number(ry)])?;
            let p2 = dom_point_ctor(it, Value::Undefined, &[Value::Number(rx + rw), Value::Number(ry)])?;
            let p3 = dom_point_ctor(it, Value::Undefined, &[Value::Number(rx + rw), Value::Number(ry + rh)])?;
            let p4 = dom_point_ctor(it, Value::Undefined, &[Value::Number(rx), Value::Number(ry + rh)])?;
            dom_quad_ctor(it, Value::Undefined, &[p1, p2, p3, p4])
        }));
    }
    g.vars.insert("DOMQuad".into(), dom_quad_fn);
    g.vars.insert("Path2D".into(), nv("Path2D", dom_path2d_ctor));
    g.vars.insert("ImageData".into(), nv("ImageData", dom_image_data_ctor));

    let range_ctor_fn = nv("Range", |it, t, a| dom_document::document_create_range(it, t, a));
    if let Value::Object(ref ro) = range_ctor_fn {
        let mut rb = ro.borrow_mut();
        rb.props.insert(
            "START_TO_START".into(),
            Value::Number(crate::os_lib::dom_range::START_TO_START as f64),
        );
        rb.props.insert(
            "START_TO_END".into(),
            Value::Number(crate::os_lib::dom_range::START_TO_END as f64),
        );
        rb.props.insert(
            "END_TO_END".into(),
            Value::Number(crate::os_lib::dom_range::END_TO_END as f64),
        );
        rb.props.insert(
            "END_TO_START".into(),
            Value::Number(crate::os_lib::dom_range::END_TO_START as f64),
        );
    }
    g.vars.insert("Range".into(), range_ctor_fn);

    // HashChangeEvent/PageTransitionEvent コンストラクタ（丸ごと未対応
    // だった。詳細は各 ctor 参照）。
    g.vars.insert(
        "HashChangeEvent".into(),
        nv("HashChangeEvent", hash_change_event_ctor),
    );
    g.vars.insert(
        "PageTransitionEvent".into(),
        nv("PageTransitionEvent", page_transition_event_ctor),
    );
    // PopStateEvent コンストラクタ（丸ごと未対応だった。詳細は
    // `pop_state_event_ctor` 参照。2026-07-17 発見・実装）。
    g.vars.insert(
        "PopStateEvent".into(),
        nv("PopStateEvent", pop_state_event_ctor),
    );
    // PointerEvent/InputEvent コンストラクタ（丸ごと未対応だった。詳細は
    // 各 ctor 参照）。
    g.vars
        .insert("PointerEvent".into(), nv("PointerEvent", pointer_event_ctor));
    g.vars
        .insert("InputEvent".into(), nv("InputEvent", input_event_ctor));
    // ProgressEvent/StorageEvent コンストラクタ（丸ごと未対応だった。詳細は
    // 各 ctor 参照）。
    g.vars
        .insert("ProgressEvent".into(), nv("ProgressEvent", progress_event_ctor));
    g.vars
        .insert("StorageEvent".into(), nv("StorageEvent", storage_event_ctor));
    // CommandEvent/ToggleEvent/FormDataEvent コンストラクタ（WHATWG HTML Standard 準拠）
    g.vars
        .insert("CommandEvent".into(), nv("CommandEvent", command_event_ctor));
    g.vars
        .insert("ToggleEvent".into(), nv("ToggleEvent", toggle_event_ctor));
    g.vars
        .insert("FormDataEvent".into(), nv("FormDataEvent", form_data_event_ctor));

    // CompositionEvent/ClipboardEvent コンストラクタ（丸ごと未対応だった。
    // 詳細は各 ctor 参照）。
    g.vars.insert(
        "CompositionEvent".into(),
        nv("CompositionEvent", composition_event_ctor),
    );
    g.vars
        .insert("ClipboardEvent".into(), nv("ClipboardEvent", clipboard_event_ctor));
    // AnimationEvent/TransitionEvent/DragEvent/SubmitEvent コンストラクタ
    // （丸ごと未対応だった。詳細は各 ctor 参照）。
    g.vars
        .insert("AnimationEvent".into(), nv("AnimationEvent", animation_event_ctor));
    g.vars
        .insert("TransitionEvent".into(), nv("TransitionEvent", transition_event_ctor));
    g.vars.insert("DragEvent".into(), nv("DragEvent", drag_event_ctor));
    g.vars
        .insert("SubmitEvent".into(), nv("SubmitEvent", submit_event_ctor));
    // MessageEvent/ErrorEvent コンストラクタ（丸ごと未対応だった。詳細は
    // 各 ctor 参照）。
    g.vars
        .insert("MessageEvent".into(), nv("MessageEvent", message_event_ctor));
    g.vars.insert("ErrorEvent".into(), nv("ErrorEvent", error_event_ctor));

    // window.scrollY / pageYOffset / scrollTo / scrollX
    g.vars.insert("scrollY".into(), Value::Number(0.0));
    g.vars.insert("pageYOffset".into(), Value::Number(0.0));
    g.vars.insert("scrollX".into(), Value::Number(0.0));
    g.vars.insert("pageXOffset".into(), Value::Number(0.0));
    g.vars
        .insert("scrollTo".into(), nv("scrollTo", window_scroll_to));
    g.vars
        .insert("scroll".into(), nv("scroll", window_scroll_to));
    // `window.scrollBy(x, y)`（丸ごと未対応だった。`dom_noop`のまま何もせず
    // 相対スクロールが一切機能しなかった。2026-07-16 発見・実装）。
    g.vars
        .insert("scrollBy".into(), nv("scrollBy", window_scroll_by));
    g.vars
        .insert("matchMedia".into(), nv("matchMedia", window_match_media));

    // window.load イベント（addEventListener('load', cb) → cb を即発火）
    // 実装は window の addEventListener で load を即時処理。
    g.vars.insert("location".into(), Value::Object(location));
    g.vars.insert("history".into(), Value::Object(history));
    g.vars.insert("alert".into(), nv("alert", console_log));
    // `confirm`/`prompt`（bare修飾無し形。丸ごと未対応だった。理由は
    // `window.confirm`/`.prompt`と同じ。2026-07-16 発見・実装）。
    g.vars
        .insert("confirm".into(), nv("confirm", window_confirm));
    g.vars.insert("prompt".into(), nv("prompt", window_prompt));
    // `open`/`close`/`focus`/`blur`（bare修飾無し形。丸ごと未対応だった。
    // 理由は`window.open`等と同じ。2026-07-16 発見・実装）。
    g.vars.insert("open".into(), nv("open", window_open));
    g.vars.insert("close".into(), nv("close", window_close));
    // `stop`（bare修飾無し形。丸ごと未対応だった。2026-07-17 発見・実装）。
    g.vars.insert("stop".into(), nv("stop", window_stop));
    g.vars.insert("focus".into(), nv("focus", window_focus));
    g.vars.insert("blur".into(), nv("blur", window_focus));
    // `getSelection`（bare修飾無し形。丸ごと未対応だった。理由は
    // `window.getSelection`と同じ。2026-07-16 発見・実装）。
    g.vars
        .insert("getSelection".into(), nv("getSelection", document_get_selection));

    // Map / Set コンストラクタ
    let map_ctor_v = nv("Map", map_ctor);
    if let Value::Object(mc) = &map_ctor_v {
        mc.borrow_mut()
            .props
            .insert("groupBy".into(), nv("Map.groupBy", map_group_by));
    }
    g.vars.insert("Map".into(), map_ctor_v);
    g.vars.insert("Set".into(), nv("Set", set_ctor));

    // Promise コンストラクタ + 静的メソッド
    let promise_ctor_v = nv("Promise", promise_ctor);
    if let Value::Object(pc) = &promise_ctor_v {
        pc.borrow_mut().props.insert(
            "resolve".into(),
            nv("Promise.resolve", promise_resolve_static),
        );
        pc.borrow_mut()
            .props
            .insert("reject".into(), nv("Promise.reject", promise_reject_static));
        pc.borrow_mut()
            .props
            .insert("all".into(), nv("Promise.all", promise_all_static));
        pc.borrow_mut().props.insert(
            "allSettled".into(),
            nv("Promise.allSettled", promise_all_settled_static),
        );
        pc.borrow_mut()
            .props
            .insert("race".into(), nv("Promise.race", promise_race_static));
        pc.borrow_mut()
            .props
            .insert("any".into(), nv("Promise.any", promise_any_static));
        pc.borrow_mut().props.insert(
            "withResolvers".into(),
            nv("Promise.withResolvers", promise_with_resolvers_static),
        );
        pc.borrow_mut()
            .props
            .insert("try".into(), nv("Promise.try", promise_try_static));
    }
    g.vars.insert("Promise".into(), promise_ctor_v);

    // Proxy コンストラクタ
    g.vars.insert("Proxy".into(), nv("Proxy", proxy_ctor));

    // Reflect グローバルオブジェクト
    let reflect = Obj::plain();
    {
        let mut r = reflect.borrow_mut();
        r.props.insert("get".into(), nv("Reflect.get", reflect_get));
        r.props.insert("set".into(), nv("Reflect.set", reflect_set));
        r.props.insert("has".into(), nv("Reflect.has", reflect_has));
        r.props.insert(
            "deleteProperty".into(),
            nv("Reflect.deleteProperty", reflect_delete_property),
        );
        r.props
            .insert("ownKeys".into(), nv("Reflect.ownKeys", reflect_own_keys));
        r.props.insert(
            "getPrototypeOf".into(),
            nv("Reflect.getPrototypeOf", reflect_get_prototype_of),
        );
        r.props.insert(
            "defineProperty".into(),
            nv("Reflect.defineProperty", reflect_define_property),
        );
        r.props
            .insert("apply".into(), nv("Reflect.apply", reflect_apply));
        r.props.insert(
            "construct".into(),
            nv("Reflect.construct", reflect_construct),
        );
        // `setPrototypeOf`/`isExtensible`/`preventExtensions`/`getOwnPropertyDescriptor` が
        // 丸ごと欠落していた（`Object` 側の対応する静的メソッドと引数の形が同じなので
        // そのまま流用する）。
        r.props.insert(
            "setPrototypeOf".into(),
            nv("Reflect.setPrototypeOf", object_set_prototype_of),
        );
        r.props.insert(
            "isExtensible".into(),
            nv("Reflect.isExtensible", object_is_extensible),
        );
        r.props.insert(
            "preventExtensions".into(),
            nv("Reflect.preventExtensions", object_prevent_extensions),
        );
        r.props.insert(
            "getOwnPropertyDescriptor".into(),
            nv(
                "Reflect.getOwnPropertyDescriptor",
                object_get_own_property_descriptor,
            ),
        );
    }
    g.vars.insert("Reflect".into(), Value::Object(reflect));

    // Iterator（ES2025）。コンストラクタ自体は呼び出し不可扱いとし、静的メソッド
    // `Iterator.from(iterable)` のみを提供する簡略実装。
    let iterator_ctor = nv("Iterator", |_: &mut Interp, _: Value, _: &[Value]| {
        Ok(Value::Undefined)
    });
    if let Value::Object(ic) = &iterator_ctor {
        ic.borrow_mut()
            .props
            .insert("from".into(), nv("Iterator.from", iterator_from));
        ic.borrow_mut()
            .props
            .insert("range".into(), nv("Iterator.range", iterator_range));
        ic.borrow_mut()
            .props
            .insert("concat".into(), nv("Iterator.concat", iterator_concat_static));
    }
    g.vars.insert("Iterator".into(), iterator_ctor);

    // タイマー（イベントループのマクロタスク）。遅延は無視し、登録順に実行する。
    g.vars
        .insert("setTimeout".into(), nv("setTimeout", set_timeout));
    g.vars
        .insert("setInterval".into(), nv("setInterval", set_interval));
    g.vars
        .insert("clearTimeout".into(), nv("clearTimeout", clear_timeout));
    g.vars
        .insert("clearInterval".into(), nv("clearInterval", clear_interval));
    g.vars.insert(
        "queueMicrotask".into(),
        nv("queueMicrotask", queue_microtask),
    );
    // `reportError(error)`（丸ごと未対応だった。未捕捉例外と同じ経路で
    // `window.onerror`/`window.addEventListener('error', fn)` へ報告する
    // 標準グローバル関数。詳細は report_error 参照）。
    g.vars
        .insert("reportError".into(), nv("reportError", report_error));
    g.vars.insert(
        "requestAnimationFrame".into(),
        nv("requestAnimationFrame", request_animation_frame),
    );
    g.vars.insert(
        "cancelAnimationFrame".into(),
        nv("cancelAnimationFrame", clear_timeout),
    );
    g.vars.insert(
        "requestIdleCallback".into(),
        nv("requestIdleCallback", request_idle_callback),
    );
    g.vars.insert(
        "cancelIdleCallback".into(),
        nv("cancelIdleCallback", dom_noop),
    );

    // Date。`RegExp`/`Map`/`Set` と同じ設計で、ネイティブコンストラクタが
    // `construct_object` が用意する `this` を無視して `ObjKind::DateObj` を積んだ
    // 新規オブジェクトを直接返す（メソッドは `.proto` 経由ではなく、`get_property` の
    // `ObjKind` 特殊扱いで解決される。`instanceof Date` は組込み Array/Object と同様に
    // false になる既知の簡略化）。
    let date_ctor_obj = Obj::native("Date", date_ctor);
    date_ctor_obj
        .borrow_mut()
        .props
        .insert("now".into(), nv("Date.now", date_now_static));
    date_ctor_obj
        .borrow_mut()
        .props
        .insert("parse".into(), nv("Date.parse", date_parse_static));
    // `Date.now`/`Date.parse` は登録済みだったが、3つ揃いのはずの `Date.UTC`
    // （年月日等の成分から epoch ミリ秒を直接得る静的ファクトリ。`new Date(...)`
    // の多引数コンストラクタと違い、これ自体は Date インスタンスではなく数値を
    // 返す）が丸ごと未対応だった。
    date_ctor_obj
        .borrow_mut()
        .props
        .insert("UTC".into(), nv("Date.UTC", date_utc_static));
    g.vars.insert("Date".into(), Value::Object(date_ctor_obj));

    // Error 階層。各サブタイプの `.prototype` は `Error.prototype` を proto に持つため、
    // `new TypeError() instanceof Error` 等が正しく true になる（OrdinaryHasInstance 相当の
    // `instanceof` 実装と対で意味を持つ。詳細は spec/walkthrough.md 2026-07-07 参照）。
    let error_proto = Obj::plain();
    error_proto
        .borrow_mut()
        .props
        .insert("name".into(), Value::str("Error"));
    error_proto
        .borrow_mut()
        .props
        .insert("message".into(), Value::str(""));
    let error_ctor_obj = Obj::native("Error", error_ctor);
    error_ctor_obj
        .borrow_mut()
        .props
        .insert("prototype".into(), Value::Object(error_proto.clone()));
    error_proto
        .borrow_mut()
        .props
        .insert("constructor".into(), Value::Object(error_ctor_obj.clone()));
    error_ctor_obj
        .borrow_mut()
        .props
        .insert("isError".into(), nv("Error.isError", error_is_error));
    g.vars.insert("Error".into(), Value::Object(error_ctor_obj));

    fn make_error_subtype(
        name: &str,
        error_proto: &ObjRef,
        ctor_fn: NativeFn,
    ) -> Value {
        let proto = Obj::plain();
        proto.borrow_mut().proto = Some(error_proto.clone());
        proto
            .borrow_mut()
            .props
            .insert("name".into(), Value::str(name));
        let ctor_obj = Obj::native(name, ctor_fn);
        ctor_obj
            .borrow_mut()
            .props
            .insert("prototype".into(), Value::Object(proto.clone()));
        proto
            .borrow_mut()
            .props
            .insert("constructor".into(), Value::Object(ctor_obj.clone()));
        Value::Object(ctor_obj)
    }
    g.vars.insert(
        "TypeError".into(),
        make_error_subtype("TypeError", &error_proto, type_error_ctor),
    );
    g.vars.insert(
        "RangeError".into(),
        make_error_subtype("RangeError", &error_proto, range_error_ctor),
    );
    g.vars.insert(
        "SyntaxError".into(),
        make_error_subtype("SyntaxError", &error_proto, syntax_error_ctor),
    );
    g.vars.insert(
        "SuppressedError".into(),
        make_error_subtype("SuppressedError", &error_proto, suppressed_error_ctor),
    );
    g.vars.insert(
        "AggregateError".into(),
        make_error_subtype("AggregateError", &error_proto, aggregate_error_ctor),
    );

    // `DOMException`（丸ごと未対応だった。Web API 全般が送出する標準例外型。
    // `AbortController.abort()` 等の内部エラーはこれまで `name`/`message` のみ
    // 持つ簡易オブジェクトで代用していたが、`new DOMException(message, name)`
    // というユーザーコードからの直接構築や、レガシーな `.code` 数値定数
    // （`err.code === DOMException.NOT_FOUND_ERR` 等）に対応する本物の
    // グローバルコンストラクタ自体が存在しなかった。詳細は
    // dom_exception_ctor/make_dom_exception 参照）。
    {
        let dom_exception_ctor_val = nv("DOMException", dom_exception_ctor);
        if let Value::Object(o) = &dom_exception_ctor_val {
            let mut b = o.borrow_mut();
            let legacy_codes: &[(&str, f64)] = &[
                ("INDEX_SIZE_ERR", 1.0),
                ("HIERARCHY_REQUEST_ERR", 3.0),
                ("WRONG_DOCUMENT_ERR", 4.0),
                ("INVALID_CHARACTER_ERR", 5.0),
                ("NO_MODIFICATION_ALLOWED_ERR", 7.0),
                ("NOT_FOUND_ERR", 8.0),
                ("NOT_SUPPORTED_ERR", 9.0),
                ("INUSE_ATTRIBUTE_ERR", 10.0),
                ("INVALID_STATE_ERR", 11.0),
                ("SYNTAX_ERR", 12.0),
                ("INVALID_MODIFICATION_ERR", 13.0),
                ("NAMESPACE_ERR", 14.0),
                ("INVALID_ACCESS_ERR", 15.0),
                ("SECURITY_ERR", 18.0),
                ("NETWORK_ERR", 19.0),
                ("ABORT_ERR", 20.0),
                ("TIMEOUT_ERR", 23.0),
                ("DATA_CLONE_ERR", 25.0),
            ];
            for (name, code) in legacy_codes {
                b.props.insert(String::from(*name), Value::Number(*code));
            }
        }
        g.vars.insert("DOMException".into(), dom_exception_ctor_val);
    }

    // NodeFilter インターフェース（W3C DOM Standard §6 Traversal）
    {
        let node_filter = Obj::plain();
        {
            let mut b = node_filter.borrow_mut();
            b.props.insert("FILTER_ACCEPT".into(), Value::Number(1.0));
            b.props.insert("FILTER_REJECT".into(), Value::Number(2.0));
            b.props.insert("FILTER_SKIP".into(), Value::Number(3.0));
            b.props.insert("SHOW_ALL".into(), Value::Number(0xFFFF_FFFFu32 as f64));
            b.props.insert("SHOW_ELEMENT".into(), Value::Number(0x1 as f64));
            b.props.insert("SHOW_ATTRIBUTE".into(), Value::Number(0x2 as f64));
            b.props.insert("SHOW_TEXT".into(), Value::Number(0x4 as f64));
            b.props.insert("SHOW_CDATA_SECTION".into(), Value::Number(0x8 as f64));
            b.props.insert("SHOW_ENTITY_REFERENCE".into(), Value::Number(0x10 as f64));
            b.props.insert("SHOW_ENTITY".into(), Value::Number(0x20 as f64));
            b.props.insert("SHOW_PROCESSING_INSTRUCTION".into(), Value::Number(0x40 as f64));
            b.props.insert("SHOW_COMMENT".into(), Value::Number(0x80 as f64));
            b.props.insert("SHOW_DOCUMENT".into(), Value::Number(0x100 as f64));
            b.props.insert("SHOW_DOCUMENT_TYPE".into(), Value::Number(0x200 as f64));
            b.props.insert("SHOW_DOCUMENT_FRAGMENT".into(), Value::Number(0x400 as f64));
            b.props.insert("SHOW_NOTATION".into(), Value::Number(0x800 as f64));
        }
        g.vars.insert("NodeFilter".into(), Value::Object(node_filter));
    }

    // FinalizationRegistry（GC コールバック。AtmOS は GC 非搭載のため register は no-op）
    g.vars.insert(
        "FinalizationRegistry".into(),
        nv("FinalizationRegistry", finalization_registry_ctor),
    );

    // fetch（同期HTTP GET を Promise/Response 互換で。data: URL も対応）。
    g.vars.insert("fetch".into(), nv("fetch", fetch));
    g.vars.insert("Request".into(), nv("Request", request_ctor));
    g.vars.insert("Headers".into(), nv("Headers", headers_ctor));
    // `Response` コンストラクタ自体が丸ごと未対応だった（これまで `fetch()`
    // 内部の `make_response`/`make_response_with_url` からしか生成できず、
    // Service Worker やテストコードでの `new Response(JSON.stringify(x),
    // {status:200})`/`Response.json(x)` という定番パターンが使えなかった）。
    {
        let response_ctor_val = nv("Response", response_ctor);
        if let Value::Object(o) = &response_ctor_val {
            let mut b = o.borrow_mut();
            b.props.insert("json".into(), nv("Response.json", response_json_static));
            b.props.insert("error".into(), nv("Response.error", response_error_static));
            b.props
                .insert("redirect".into(), nv("Response.redirect", response_redirect_static));
        }
        g.vars.insert("Response".into(), response_ctor_val);
    }
    // XMLHttpRequest（同期取得 + onload/onreadystatechange 発火）。
    g.vars
        .insert("XMLHttpRequest".into(), nv("XMLHttpRequest", xhr_ctor));

    // RegExp コンストラクタ
    let regexp_ctor_v = nv("RegExp", regexp_ctor);
    if let Value::Object(rc) = &regexp_ctor_v {
        rc.borrow_mut()
            .props
            .insert("escape".into(), nv("RegExp.escape", regexp_escape_static));
        // 【2026-10-19】`RegExp.prototype` のメソッド。実体（`/x/.exec`）は `regexp_get` が
        // 同じ関数を返すが、プロトタイプから直接読む形（XRegExp の
        // `{exec: RegExp.prototype.exec, …}`、YouTube の kevlar_base）が undefined だった。
        let proto = Obj::plain();
        {
            let mut pb = proto.borrow_mut();
            let methods: [(&str, NativeFn); 9] = [
                ("test", re_test),
                ("exec", re_exec),
                ("toString", re_to_string),
                ("compile", re_compile),
                ("Symbol(Symbol.match)", re_symbol_match),
                ("Symbol(Symbol.replace)", re_symbol_replace),
                ("Symbol(Symbol.search)", re_symbol_search),
                ("Symbol(Symbol.split)", re_symbol_split),
                ("Symbol(Symbol.matchAll)", re_symbol_match_all),
            ];
            for (name, f) in methods {
                pb.props.insert(name.into(), nv(name, f));
            }
            pb.props.insert("constructor".into(), regexp_ctor_v.clone());
        }
        rc.borrow_mut().props.insert("prototype".into(), Value::Object(proto));
    }
    g.vars.insert("RegExp".into(), regexp_ctor_v);

    // WeakMap / WeakSet / WeakRef（Rc ベース近似実装: キーはオブジェクト参照で識別）
    g.vars.insert("WeakMap".into(), nv("WeakMap", weakmap_ctor));
    g.vars.insert("WeakSet".into(), nv("WeakSet", weakset_ctor));
    g.vars.insert("WeakRef".into(), nv("WeakRef", weakref_ctor));

    // Symbol（グローバル `Symbol()` 関数: 文字列ラベルを付与した一意値を返す）
    {
        let sym_fn = nv("Symbol", symbol_fn);
        if let Value::Object(sf) = &sym_fn {
            sf.borrow_mut().props.insert("for".into(), nv("Symbol.for", symbol_for));
            sf.borrow_mut().props.insert("keyFor".into(), nv("Symbol.keyFor", symbol_key_for));
            sf.borrow_mut().props.insert("iterator".into(), Value::str("Symbol(Symbol.iterator)"));
            sf.borrow_mut().props.insert("toPrimitive".into(), Value::str("Symbol(Symbol.toPrimitive)"));
            sf.borrow_mut().props.insert("hasInstance".into(), Value::str("Symbol(Symbol.hasInstance)"));
            sf.borrow_mut().props.insert("toStringTag".into(), Value::str("Symbol(Symbol.toStringTag)"));
            sf.borrow_mut().props.insert("asyncIterator".into(), Value::str("Symbol(Symbol.asyncIterator)"));
            // `Array.prototype.concat` が参照する well-known symbol。定数自体が丸ごと
            // 未登録だったため `Symbol.isConcatSpreadable` が常に `undefined` になり、
            // `arr[Symbol.isConcatSpreadable] = ...` が実質 `arr["undefined"] = ...` という
            // 無関係なプロパティ代入に化けていた。
            sf.borrow_mut()
                .props
                .insert("isConcatSpreadable".into(), Value::str("Symbol(Symbol.isConcatSpreadable)"));
            // `Symbol.species`/`unscopables`/`match`/`replace`/`search`/`split` も同じ理由
            // （定数自体が未登録だと `obj[Symbol.species] = ...` 等が `obj["undefined"] = ...`
            // という無関係なプロパティ代入に化ける）で追加登録する。派生コンストラクタ選択
            // （`species`）やカスタムマッチャープロトコル（`match`/`replace`/`search`/`split`。
            // `String.prototype` 側のメソッドはこれらを見ずに常に組み込み `RegExp` 実装へ
            // 委譲する簡略実装のまま）、`with` 文の `unscopables` フィルタは非対応のままだが、
            // 定数自体は仕様どおり存在させ、キー衝突による静かな破壊だけは防ぐ。
            for name in [
                "species",
                "unscopables",
                "match",
                "matchAll",
                "replace",
                "search",
                "split",
            ] {
                sf.borrow_mut()
                    .props
                    .insert(String::from(name), Value::str(format!("Symbol(Symbol.{})", name)));
            }
            // Explicit Resource Management（`using`/`await using` 宣言、ES2023→ES2026ベースライン）。
            sf.borrow_mut().props.insert("dispose".into(), Value::str("Symbol(Symbol.dispose)"));
            sf.borrow_mut().props.insert("asyncDispose".into(), Value::str("Symbol(Symbol.asyncDispose)"));
        }
        g.vars.insert("Symbol".into(), sym_fn);

        // 各組み込みコンストラクタ関数への Symbol(Symbol.species) アクセサ配線。
        // `Symbol.species`は仕様上ゲッターアクセサ（`this`を返すだけ）であり、
        // 呼び出し可能な関数値をそのまま`props`にデータプロパティとして
        // 差し込んでしまうと、`Array[Symbol.species]`はそのゲッター関数
        // オブジェクト自体を返してしまい（呼び出されない）、`=== Array`が
        // 常に`false`になるバグだった（2026-07-18 発見・修正）。他の
        // アクセサ登録箇所と同じ`accessors`マップへ`Accessor{get,set}`として
        // 登録する必要がある。
        use super::value::Accessor;
        let species_fn = nv("get [Symbol.species]", symbol_species_getter);
        for ctor_name in [
            "Array", "RegExp", "Promise", "Map", "Set", "ArrayBuffer",
            "Uint8Array", "Int8Array", "Uint8ClampedArray", "Int16Array",
            "Uint16Array", "Int32Array", "Uint32Array", "Float16Array", "Float32Array",
            "Float64Array", "BigInt64Array", "BigUint64Array",
        ] {
            if let Some(Value::Object(ctor_obj)) = g.vars.get(ctor_name).cloned() {
                ctor_obj.borrow_mut().accessors.insert(
                    "Symbol(Symbol.species)".into(),
                    Accessor { get: Some(species_fn.clone()), set: None },
                );
            }
        }
    }

    // 定数
    g.vars.insert("NaN".into(), Value::Number(f64::NAN));
    g.vars
        .insert("Infinity".into(), Value::Number(f64::INFINITY));
    g.vars.insert("undefined".into(), Value::Undefined);
    // globalThis は window オブジェクトを指す（location/history/fetch 等にアクセス可能）。
    let global_this = g.vars.get("window").cloned().unwrap_or(Value::Undefined);
    g.vars.insert("globalThis".into(), global_this);
    // `self`/`top`/`parent`/`frames`（丸ごと未対応だった。`globalThis`は
    // 実装済みだったのに、同じ「windowオブジェクト自身を指す別名」仲間の
    // うちこれら4つだけ登録が漏れていた。2026-07-16 発見・実装）。
    // `self`はワーカー/メインスレッド両対応コードで`typeof self !==
    // 'undefined'`という定番の環境判定に使われる。`top`/`parent`/`frames`は
    // 本来フレーム階層を表すが、この処理系にはiframeの独立JSレルムが無く
    // 常に単一フレームのため、仕様上「フレームが無い最上位ウィンドウでは
    // top/parent/framesはいずれも自分自身」という規定どおり`window`自身を
    // 指す（`window.top === window`という定番のフレーム内判定イディオムが
    // 正しく`true`になる）。
    // 【2026-09-05】グローバルにはあるのに `window.` 経由で読めないものを塞ぐ。
    //
    // `window` は個別に用意したプロパティしか持たず、`navigator` などは
    // 別のグローバル変数として登録されているだけだった。
    // ブラウザでは同じ物を両方から読めるので、`window.navigator` が
    // `undefined` になる。jQuery 1.8.2 は
    // `p.uaMatch(a.navigator.userAgent)`（`a` は window）と書くため、
    // ここで初期化が止まっていた。
    //
    // 既に `window` に入っているものは上書きしない（個別に用意した実装を
    // 壊さないため）。
    if let Some(Value::Object(w)) = g.vars.get("window").cloned() {
        for name in WINDOW_MIRRORED_GLOBALS {
            if w.borrow().props.contains_key(*name) {
                continue;
            }
            if let Some(v) = g.vars.get(*name).cloned() {
                w.borrow_mut()
                    .props
                    .insert(alloc::string::String::from(*name), v);
            }
        }
    }
    // 【2026-10-17】組込みのコンストラクタの多くは `.prototype` を持たない（メソッドは実体から
    // 動的に解決する簡略実装）。`typeof X.prototype.m !== "function" && (X.prototype.m = ...)`
    // というポリフィルの定番判定が `undefined` の読み取りで落ちるため、大文字で始まる
    // 呼び出し可能なグローバルに `prototype` が無ければ空の prototype（`constructor` 付き）を補う。
    {
        let ctors: alloc::vec::Vec<(alloc::string::String, Rc<RefCell<Obj>>)> = g
            .vars
            .iter()
            .filter(|(k, _)| k.chars().next().is_some_and(|c| c.is_ascii_uppercase()))
            .filter_map(|(k, v)| match v {
                Value::Object(o) if o.borrow().is_callable() && !o.borrow().props.contains_key("prototype") => {
                    Some((k.clone(), o.clone()))
                }
                _ => None,
            })
            .collect();
        for (_name, ctor) in ctors {
            let proto = Obj::plain();
            proto.borrow_mut().props.insert("constructor".into(), Value::Object(ctor.clone()));
            ctor.borrow_mut().props.insert("prototype".into(), Value::Object(proto));
        }
    }
    let window_ref = g.vars.get("window").cloned().unwrap_or(Value::Undefined);
    g.vars.insert("self".into(), window_ref.clone());
    g.vars.insert("top".into(), window_ref.clone());
    g.vars.insert("parent".into(), window_ref.clone());
    g.vars.insert("frames".into(), window_ref);
}


// ===== 分割サブモジュール（2026-07-16 リファクタ フェーズ2） =====
// builtins.rs が肥大化したため、install() 以降の各セクションを builtins/ 配下へ
// 機械的に切り出した。ロジックは不変。`builtins::<name>` の外部参照パスを保つため
// ここで pub(crate) use で全て再エクスポートする。詳細は walkthrough.md 参照。
mod dom;
mod console_math_json;
mod object_array;
mod props_methods;
mod collections;
mod promise;
mod web_forms;
mod encoding;
mod extra_methods;
mod typed_array;
mod text_clone;
mod extra_static;
mod dom_document;
mod observers;
mod events;
mod window_api;
mod static_classlist;
mod timers_gen;
mod weak_symbol;
mod regexp;
mod dom_forward;
pub(crate) use dom_forward::{named_node_map_get, named_node_map_item};
mod date;
mod errors_misc;
mod intl;
mod crypto_subtle;
mod streams;
mod mse;
mod worker;

pub(crate) use dom::*;
pub(crate) use console_math_json::*;
pub(crate) use object_array::*;
pub(crate) use props_methods::*;
pub(crate) use collections::*;
pub(crate) use promise::*;
pub(crate) use web_forms::*;
pub(crate) use encoding::*;
pub(crate) use extra_methods::*;
pub(crate) use typed_array::*;
pub(crate) use text_clone::*;
pub(crate) use extra_static::*;
pub(crate) use dom_document::*;
pub(crate) use observers::*;
pub(crate) use events::*;
pub(crate) use window_api::*;
pub(crate) use static_classlist::*;
pub(crate) use timers_gen::*;
pub(crate) use weak_symbol::*;
pub(crate) use regexp::*;
pub(crate) use date::*;
pub(crate) use errors_misc::*;
pub(crate) use intl::*;
pub(crate) use crypto_subtle::*;
pub(crate) use streams::*;
pub(crate) use mse::*;
pub(crate) use worker::*;