atmos/os_lib/js/

selftest.rs

//! JS エンジン自己テスト（mod.rs から分割。2026-07-16 リファクタ フェーズ4）。
//! ロジック不変。`super::*` で mod.rs の JsRuntime/eval/Value 等を取り込む。
use super::*;

/// JS エンジンの自己テスト。各ケースを評価し、最後の式の文字列化が期待値と一致するか確認。
/// 起動時に呼ばれ `JS_SELFTEST: PASS n/n` をシリアルへ出す（CI スモークの判定マーカー）。
pub fn selftest() -> (usize, usize) {
    let cases: &[(&str, &str)] = &[
        // 演算子・優先順位
        ("1 + 2 * 3", "7"),
        ("(1 + 2) * 3", "9"),
        ("2 ** 10", "1024"),
        ("7 % 3", "1"),
        ("10 / 4", "2.5"),
        ("true && false || true", "true"),
        ("null ?? 'x'", "x"),
        ("1 < 2 ? 'a' : 'b'", "a"),
        // テンプレートリテラル `${}` 補間（ES2015）。以前はレキサーが `${...}` を
        // 単なる生文字列として保持するだけで実際の補間評価が行われず（Phase 4 として
        // 未実装のまま放置されていた）、自己テストも一件も存在しない状態だった。
        ("var name='World'; `Hello, ${name}!`", "Hello, World!"),
        ("`1+2=${1+2}`", "1+2=3"),
        ("var a=1,b=2; `${a}-${b}-${a+b}`", "1-2-3"),
        ("`no interpolation here`", "no interpolation here"),
        ("``", ""),
        ("`${'a'+'b'}${'c'}`", "abc"),
        // 補間式の中に文字列リテラル（波括弧に見える文字を含む可能性がある）や
        // オブジェクトリテラル（ネストした `{}`）があっても深さ計算が壊れないこと。
        ("`x=${'{not a brace}'}`", "x={not a brace}"),
        ("`obj=${JSON.stringify({a:1})}`", "obj={\"a\":1}"),
        // 補間式内でのネストしたテンプレートリテラル（二重ネストではない単純な形）。
        ("`outer ${`inner`}`", "outer inner"),
        // 文字列
        ("'a' + 'b' + 'c'", "abc"),
        ("'Hello'.toUpperCase()", "HELLO"),
        ("'a,b,c'.split(',').length", "3"),
        ("'  hi  '.trim()", "hi"),
        ("'abc'.slice(1)", "bc"),
        // 変数・制御構文
        ("var s = 0; for (var i = 1; i <= 5; i++) s += i; s", "15"),
        ("let n = 0; while (n < 3) n++; n", "3"),
        ("let x = 10; if (x > 5) { x = 1 } else { x = 2 } x", "1"),
        // ラベル付き break/continue（ES3以降の基礎機能。以前は AST に Label 相当の
        // variant 自体が存在せず完全に未サポートだった）。
        (
            "var out=''; outer: for(var i=0;i<3;i++){ for(var j=0;j<3;j++){ if(j===1) continue outer; out+=i+''+j; } } out",
            "001020",
        ),
        (
            "var found=null; outer: for(var i=0;i<3;i++){ for(var j=0;j<3;j++){ if(i===1&&j===1){ found=i+''+j; break outer; } } } found",
            "11",
        ),
        // ラベル無しの break/continue は従来通り最も内側のループのみに作用する
        // （ラベル対応追加による回帰が無いことの確認）。
        (
            "var out=''; for(var i=0;i<3;i++){ for(var j=0;j<3;j++){ if(j===1) break; out+=i+''+j; } } out",
            "001020",
        ),
        // 三項演算子の `:` とラベル構文の衝突が無いこと（`x ? 1 : 2` の `:` は
        // ラベル判定の対象にならない）。
        ("var x=5; x > 0 ? 1 : 2", "1"),
        // `**` の右結合性（`2**3**2` は `2**(3**2)`=512。左結合だと `(2**3)**2`=64になり誤り）。
        ("2 ** 3 ** 2", "512"),
        // 論理代入演算子（ES2021）: 値としての結果。
        ("var a=0; a ||= 5; a", "5"),
        ("var a=1; a ||= 5; a", "1"),
        ("var a=1; a &&= 5; a", "5"),
        ("var a=0; a &&= 5; a", "0"),
        ("var a=null; a ??= 5; a", "5"),
        ("var a=0; a ??= 5; a", "0"),
        // 論理代入演算子は仕様上の短絡評価が必須: 条件を満たさない場合、右辺の副作用は
        // 一切実行されてはならない（以前は関数の先頭で右辺を無条件に評価してから分岐して
        // いたため、代入されない場合でも副作用が毎回発生してしまう仕様違反バグがあった）。
        (
            "var calls=0; function rhs(){calls++; return 9;} var a=1; a ||= rhs(); calls",
            "0",
        ),
        (
            "var calls=0; function rhs(){calls++; return 9;} var a=0; a &&= rhs(); calls",
            "0",
        ),
        (
            "var calls=0; function rhs(){calls++; return 9;} var a=5; a ??= rhs(); calls",
            "0",
        ),
        // 条件を満たす場合は右辺が（1回だけ）評価される。
        (
            "var calls=0; function rhs(){calls++; return 9;} var a=0; a ||= rhs(); calls+','+a",
            "1,9",
        ),
        // 関数・クロージャ・再帰
        ("function add(a, b) { return a + b } add(3, 4)", "7"),
        ("let f = (a, b) => a + b; f(5, 6)", "11"),
        ("function fib(n){ return n < 2 ? n : fib(n-1) + fib(n-2) } fib(10)", "55"),
        ("let mk = () => { let c = 0; return () => ++c }; let g = mk(); g(); g(); g()", "3"),
        // 配列
        ("[1,2,3].map(x => x * 2).join(',')", "2,4,6"),
        ("[1,2,3,4].filter(x => x % 2 === 0).join(',')", "2,4"),
        ("[1,2,3,4].reduce((s, x) => s + x, 0)", "10"),
        ("[3,1,2].sort((a,b) => a - b).join('')", "123"),
        ("let a = [1]; a.push(2); a.push(3); a.length", "3"),
        // オブジェクト
        ("var o = {a:1, b:2}; o.a + o.b", "3"),
        ("var o = {}; o['k'] = 9; o.k", "9"),
        ("Object.keys({x:1, y:2, z:3}).length", "3"),
        // typeof / 例外
        ("typeof undefinedVar", "undefined"),
        ("typeof 42", "number"),
        ("try { throw 'boom' } catch (e) { e }", "boom"),
        // JSON
        ("JSON.stringify({x:[1,2], y:'z'})", "{\"x\":[1,2],\"y\":\"z\"}"),
        ("JSON.parse('{\"n\":5}').n", "5"),
        // Math
        ("Math.max(3, 7, 2)", "7"),
        ("Math.floor(3.9)", "3"),
        ("Math.abs(-5)", "5"),
        // switch（フォールスルー・default 含む）
        ("function f(x){ switch(x){ case 1: return 'one'; case 2: return 'two'; default: return 'other' } } f(2)", "two"),
        ("function f(x){ switch(x){ case 1: return 'one'; default: return 'd' } } f(9)", "d"),
        ("var r=''; switch(1){ case 1: r+='a'; case 2: r+='b'; break; case 3: r+='c' } r", "ab"),
        // スプレッド/レスト
        ("var a=[1,2]; var b=[...a,3,4]; b.join(',')", "1,2,3,4"),
        ("function sum(...xs){ return xs.reduce((s,x)=>s+x,0) } sum(1,2,3,4)", "10"),
        ("function add(a,b,c){ return a+b+c } add(...[1,2,3])", "6"),
        ("var o={a:1}; var p={...o, b:2}; p.a + p.b", "3"),
        ("Math.max(...[5,2,9,1])", "9"),
        ("function tail(first, ...rest){ return rest.join('-') } tail(1,2,3,4)", "2-3-4"),
        // Map
        ("var m=new Map(); m.set('a',1).set('b',2); m.get('a') + m.size", "3"),
        ("var m=new Map([['x',10],['y',20]]); m.has('y') + ',' + m.get('y')", "true,20"),
        ("var m=new Map(); m.set(1,'one'); m.delete(1); m.has(1)", "false"),
        // `new Map(iterable)` の各要素が非オブジェクト（ペアでない）場合は仕様どおり
        // TypeError を投げる必要があるが、以前は黙って {undefined: undefined} という
        // 意味のない1エントリだけの Map が静かに作られていた。
        (
            "try { new Map([1,2,3]); 'no throw'; } catch(e) { 'threw'; }",
            "threw",
        ),
        (
            "try { new Map(['ab']); 'no throw'; } catch(e) { 'threw'; }",
            "threw",
        ),
        // Set
        ("var s=new Set([1,2,2,3,3,3]); s.size", "3"),
        ("var s=new Set(); s.add(5).add(5).add(6); s.has(5) + ',' + s.size", "true,2"),
        ("var s=new Set([1,2,3]); var t=0; s.forEach(v=>t+=v); t", "6"),
        ("[...new Set([1,1,2,3,3])].join(',')", "1,2,3"),
        // 分割代入（オブジェクト）
        ("var {a, b} = {a:1, b:2}; a + b", "3"),
        ("var {a: x, b: y} = {a:10, b:20}; x + y", "30"),
        ("var {a, c = 9} = {a:1}; a + c", "10"),
        ("var {a, ...rest} = {a:1, b:2, c:3}; rest.b + rest.c", "5"),
        ("var {p: {q}} = {p:{q:42}}; q", "42"),
        // 分割代入（配列）
        ("var [a, b] = [1, 2]; a + b", "3"),
        ("var [a, , c] = [1, 2, 3]; a + c", "4"),
        ("var [a, ...rest] = [1, 2, 3, 4]; rest.join('-')", "2-3-4"),
        ("var [a = 5, b = 6] = [1]; a + b", "7"),
        ("var [[a], [b]] = [[1],[2]]; a + b", "3"),
        ("var t=0; for (const [k,v] of [['a',1],['b',2]]) t += v; t", "3"),
        // デフォルト引数
        ("function f(a, b = 10) { return a + b } f(5)", "15"),
        ("function f(a, b = 10) { return a + b } f(5, 7)", "12"),
        // 引数の分割代入
        ("function f({x, y}) { return x * y } f({x:3, y:4})", "12"),
        ("function f([a, b]) { return a - b } f([9, 2])", "7"),
        // 算出キー
        ("var k = 'dyn'; var o = {[k]: 99}; o.dyn", "99"),
        ("var o = {['a' + 'b']: 1}; o.ab", "1"),
        // class（基本）
        ("class A { constructor(x){ this.x = x } get(){ return this.x } } new A(7).get()", "7"),
        ("class A { constructor(){ this.n = 0 } inc(){ this.n++; return this.n } } var a=new A(); a.inc(); a.inc()", "2"),
        ("class P { area(){ return 0 } } class C extends P { area(){ return 5 } } new C().area()", "5"),
        // class（継承・super）
        ("class A { constructor(x){ this.x = x } } class B extends A { constructor(x,y){ super(x); this.y = y } sum(){ return this.x + this.y } } new B(3,4).sum()", "7"),
        ("class A { greet(){ return 'A' } } class B extends A { greet(){ return super.greet() + 'B' } } new B().greet()", "AB"),
        ("class A { constructor(){ this.v = 1 } } class B extends A {} new B().v", "1"),
        // class field 宣言（ES2022。コンストラクタ本体の先頭で this.x = init される）
        ("class C { x = 5; } new C().x", "5"),
        ("class C { x; } typeof new C().x", "undefined"),
        ("class C { x = 1; y = this.x + 1; } var c = new C(); c.x + ',' + c.y", "1,2"),
        (
            "class C { x = 1; constructor(){ this.x = this.x + 10 } } new C().x",
            "11",
        ),
        (
            "class A { x = 1; } class B extends A { y = 2; } var b = new B(); b.x + ',' + b.y",
            "1,2",
        ),
        // private field（#x）。'#' が識別子の一部として扱われ、通常のプロパティアクセス
        // 経路をそのまま通る（真の隠蔽ではないが、構文としては正しく動作する）。
        (
            "class Counter { #n = 0; inc(){ this.#n++; return this.#n } } var c = new Counter(); c.inc(); c.inc()",
            "2",
        ),
        (
            "class C { #secret = 'hidden'; reveal(){ return this.#secret } } new C().reveal()",
            "hidden",
        ),
        // private メソッド（#method()）
        (
            "class C { #double(n){ return n * 2 } calc(n){ return this.#double(n) } } new C().calc(21)",
            "42",
        ),
        // プライベートフィールドのブランドチェック `#x in obj`（ES2022）が丸ごと
        // 未対応で、`#x is not defined` の例外に必ずなっていた。
        (
            "class C { #x = 1; static has(o){ return #x in o; } } C.has(new C()) + ',' + C.has({})",
            "true,false",
        ),
        // static field
        ("class C { static count = 7; } C.count", "7"),
        // static メソッド
        ("class M { static twice(n){ return n * 2 } } M.twice(21)", "42"),
        // メソッドからメソッド呼び出し
        ("class C { a(){ return 2 } b(){ return this.a() * 10 } } new C().b()", "20"),
        // Promise / async / await（await はマイクロタスクを駆動して同期解決）
        ("await Promise.resolve(42)", "42"),
        // **重要**: 汎用 thenable（本物の Promise ではないが呼び出し可能な `.then` を
        // 持つオブジェクト。古いライブラリの独自 Promise 実装等でよく使われる）の
        // 同化が丸ごと未対応で、`await`/`Promise.resolve` がオブジェクト自体を
        // 履行値にしてしまうバグだった。
        (
            "await Promise.resolve({ then(resolve){ resolve(99); } })",
            "99",
        ),
        (
            "await { then(resolve){ resolve(7); } }",
            "7",
        ),
        (
            "try { await { then(resolve, reject){ reject('bad'); } } } catch(e) { e }",
            "bad",
        ),
        // thenable の連鎖（thenable の then が別の thenable で resolve する）も
        // 再帰的に同化されること。
        (
            "await { then(resolve){ resolve({ then(r){ r(5); } }); } }",
            "5",
        ),
        // **重要**: thenable 検出が own プロパティしか見ていなかったため、
        // `then` メソッドが `.prototype` 側にある class インスタンスの thenable
        // を取りこぼすバグだった（自己検証で発見）。
        (
            "class MyThenable { then(resolve){ resolve(42); } } await new MyThenable()",
            "42",
        ),
        (
            "class MyThenable { then(_, reject){ reject('bad'); } } try { await new MyThenable() } catch(e) { e }",
            "bad",
        ),
        ("await Promise.resolve(1).then(v => v + 1)", "2"),
        ("await Promise.resolve(1).then(v => v + 1).then(v => v * 10)", "20"),
        ("await Promise.reject('e').catch(e => 'caught:' + e)", "caught:e"),
        ("async function f(){ return 7 } await f()", "7"),
        ("async function f(){ let x = await Promise.resolve(10); return x * 2 } await f()", "20"),
        ("async function f(){ try { await Promise.reject('x') } catch(e){ return 'C' + e } } await f()", "Cx"),
        ("await (async () => 5)()", "5"),
        ("await new Promise((res) => res(99))", "99"),
        ("await new Promise((res, rej) => rej('bad')).catch(e => 'got:' + e)", "got:bad"),
        ("await Promise.all([Promise.resolve(1), Promise.resolve(2), 3]).then(a => a.join(','))", "1,2,3"),
        // **重要**: `Promise.all` の配列要素に汎用 thenable（本物の Promise ではないが
        // 呼び出し可能な `.then` を持つオブジェクト）が混ざっていると、`Promise.resolve`/
        // `await` 単体では既に同化対応済みだったのに、要素がそのままオブジェクトとして
        // 混入してしまう非対称なバグだった。
        (
            "await Promise.all([1, { then(r){ r(2); } }, Promise.resolve(3)]).then(a => a.join(','))",
            "1,2,3",
        ),
        (
            "await Promise.all([{ then(resolve, reject){ reject('bad'); } }]).catch(e => 'caught:' + e)",
            "caught:bad",
        ),
        ("typeof Promise.resolve(1)", "object"),
        ("var log=''; await Promise.resolve(1).finally(() => log = 'F'); log", "F"),
        // `finally` は元の値/理由をそのまま次へ渡す（コールバックの戻り値は無視）。
        ("await Promise.resolve(1).finally(() => 2)", "1"),
        // `finally` のコールバックが例外を投げた場合、それが settle を上書きすべき
        // （以前は副作用としてだけ実行し戻り値/例外を完全に無視していたバグ）。
        (
            "await Promise.resolve(1).finally(() => { throw 'x'; }).catch(e => 'caught:' + e)",
            "caught:x",
        ),
        // `finally` のコールバックが reject する Promise を返した場合も同様。
        (
            "await Promise.resolve(1).finally(() => Promise.reject('y')).catch(e => 'caught:' + e)",
            "caught:y",
        ),
        // reject 経路でも `finally` はコールバック実行後、元の reason で reject し続ける。
        (
            "await Promise.reject('orig').finally(() => 'ignored').catch(e => 'caught:' + e)",
            "caught:orig",
        ),
        ("async function sq(n){ return n*n } var s=0; for (const n of [1,2,3]) s += await sq(n); s", "14"),
        // generator（遅延評価 / replay 駆動）
        ("function* g(){ yield 1; yield 2; yield 3 } [...g()].join(',')", "1,2,3"),
        ("function* g(){ yield* [1,2]; yield 3 } [...g()].join(',')", "1,2,3"),
        ("function* g(){ for (let i=0;i<3;i++) yield i*i } [...g()].join(',')", "0,1,4"),
        ("function* g(){ yield 1; yield 2; yield 3 } var s=0; for (const v of g()) s += v; s", "6"),
        ("function* g(){ yield 'a'; yield 'b' } var it=g(); it.next().value + it.next().value + it.next().done", "abtrue"),
        ("function* g(){ yield 1; return 99; } var it=g(); it.next(); it.next().done", "true"),
        // 無限 generator を有限個だけ消費（真の遅延評価。eager だと無限ループ）
        ("function* nat(){ let i=0; while(true) yield i++; } var it=nat(); it.next().value + ',' + it.next().value + ',' + it.next().value", "0,1,2"),
        ("function* nat(){ let i=1; while(true) yield i++; } var it=nat(); var s=0; for(let k=0;k<5;k++) s += it.next().value; s", "15"),
        // .next(v) による双方向の値受け渡し
        ("function* g(){ var a = yield 1; var b = yield a + 10; return a + b; } var it=g(); it.next(); var r1=it.next(5); var r2=it.next(100); r1.value + ',' + r2.value", "15,105"),
        ("function* g(){ var x = yield 'first'; yield 'got:' + x; } var it=g(); it.next(); it.next('hello').value", "got:hello"),
        // yield* で別の generator へ委譲（generator 同士のネスト）
        ("function* inner(){ yield 1; yield 2; } function* outer(){ yield 0; yield* inner(); yield 3; } [...outer()].join(',')", "0,1,2,3"),
        // **重要**: `async function*`（非同期 generator。ES2018）の `.next()` が
        // 仕様上必ず Promise を返すべきところ、`is_generator` の分岐が `is_async` を
        // 完全に無視しており、普通の同期 generator と同じ `{value,done}` プレーン
        // オブジェクトを直接返してしまっていたバグ。
        (
            "async function* g(){ yield 1; yield 2; } typeof g().next().then",
            "function",
        ),
        (
            "async function* g(){ yield 1; yield 2; } var it = g(); await it.next().then(r => r.value + ',' + r.done)",
            "1,false",
        ),
        (
            "async function* g(){ yield await Promise.resolve(42); } var it = g(); await it.next().then(r => r.value)",
            "42",
        ),
        ("function* g(){ yield* 'abc'; } [...g()].join('-')", "a-b-c"),
        // return() で早期終了
        ("function* g(){ yield 1; yield 2; yield 3; } var it=g(); it.next(); var r=it.return(99); r.value + ',' + r.done + ',' + it.next().done", "99,true,true"),
        // return() と try...finally の連携（return() 時に finally が実行される）
        ("var log=''; function* g(){ try { yield 1; } finally { log+='f'; } } var it=g(); it.next(); var r=it.return(99); r.value + ',' + r.done + ',' + log", "99,true,f"),
        // finally の中で return がある場合はそちらが優先される
        ("function* g(){ try { yield 1; } finally { return 42; } } var it=g(); it.next(); it.return(99).value", "42"),
        // finally の中で yield がある場合はそこで一時停止し、次の再開で強制Return値で完了する。
        // value/done は正しいが、下の replay 特性（368行目）どおり finally 冒頭の
        // `log+='f'` は forced-return 契機の replay と次の .next() の replay の
        // 計2回実行されるため 'f' が2つになる（2026-07-14、期待値の計算ミスを
        // QEMU JS_SELFTEST FAIL で発見・修正。本体側の finally 実行ロジックは正しい）。
        ("var log=''; function* g(){ try { yield 1; } finally { log+='f'; yield 2; log+='end'; } } var it=g(); it.next(); var r1=it.return(99); var r2=it.next(); r1.value+','+r1.done+','+r2.value+','+r2.done+','+log", "2,false,99,true,ffend"),
        // replay 方式の帰結: resume のたびに本体を先頭から再実行するため、外部副作用は
        // 複数回発生する（yield される値・.next(v) の受け渡しは正しい）。この再実行特性を
        // 明示的に検証する（2 回目の next で log+='a' が再実行され 'aab' になる）。
        ("var log=''; function* g(){ log+='a'; yield 1; log+='b'; yield 2; } var it=g(); it.next(); it.next(); log", "aab"),
        // Array.from が generator を消費できる（+ mapFn）
        ("function* g(){ yield 1; yield 2; yield 3; } Array.from(g()).join(',')", "1,2,3"),
        ("function* g(){ yield 1; yield 2; yield 3; } Array.from(g(), x => x * 10).join(',')", "10,20,30"),
        // try/finally を跨ぐ yield（中断中は finally を実行せず、resume で継続）
        ("function* g(){ try { yield 1; yield 2; } finally { } yield 3; } [...g()].join(',')", "1,2,3"),
        // Symbol.match/replace/search/split のオブジェクト委譲
        ("var custom = { [Symbol.match](s) { return s === 'hello' ? 'yes' : 'no'; } }; 'hello'.match(custom) + ',' + 'world'.match(custom)", "yes,no"),
        ("var custom = { [Symbol.replace](s, r) { return s + '-' + r; } }; 'abc'.replace(custom, '123')", "abc-123"),
        ("var custom = { [Symbol.search](s) { return s.length; } }; 'abc'.search(custom)", "3"),
        ("var custom = { [Symbol.split](s, lim) { return [s.length, lim]; } }; 'abc'.split(custom, 5).join(',')", "3,5"),
        // RegExp.prototype[Symbol.*] 直接呼び出し & RegExp 委譲動作
        ("typeof /a/[Symbol.match]", "function"),
        ("/b/[Symbol.match]('abc').join(',')", "b"),
        ("/b/[Symbol.replace]('abc', 'X')", "aXc"),
        ("/b/[Symbol.search]('abc')", "1"),
        ("/b/[Symbol.split]('abc').join(',')", "a,c"),
        // Symbol.species 静的アクセサ
        ("Array[Symbol.species] === Array", "true"),
        ("RegExp[Symbol.species] === RegExp", "true"),
        ("Promise[Symbol.species] === Promise", "true"),
        // ArraySpeciesCreate (Symbol.species による派生生成)
        ("class SubArr extends Array {}; const sa = new SubArr(1, 2, 3); sa.map(x => x*2) instanceof SubArr", "true"),
        ("class SubArr extends Array {}; const sa = new SubArr(1, 2, 3); sa.filter(x => x > 1) instanceof SubArr", "true"),
        ("class SubArr extends Array {}; const sa = new SubArr(1, 2, 3); sa.slice(1) instanceof SubArr", "true"),
        ("class SubArr extends Array {}; const sa = new SubArr(1, 2, 3); sa.concat([4]) instanceof SubArr", "true"),
        ("class SubArr extends Array {}; const sa = new SubArr(1, 2, 3); sa.splice(1, 1) instanceof SubArr", "true"),
        ("class SubArr extends Array {}; const sa = new SubArr(1, 2, 3); sa.flatMap(x => [x]) instanceof SubArr", "true"),
        ("class CustomArr extends Array { static get [Symbol.species]() { return Array; } }; const ca = new CustomArr(1, 2); !(ca.map(x => x) instanceof CustomArr) && ca.map(x => x) instanceof Array", "true"),
        // Array.prototype[Symbol.unscopables]
        ("Array.prototype[Symbol.unscopables].includes", "true"),
        ("Array.prototype[Symbol.unscopables].at", "true"),
        // setTimeout（マクロタスク。Promise を介して await で駆動）
        ("var x=0; await new Promise(r => setTimeout(() => { x = 5; r(); }, 0)); x", "5"),
        ("var done=false; await new Promise(r => setTimeout(() => { done = true; r(); }, 0)); done", "true"),
        ("await new Promise(res => setTimeout(() => res(7), 0))", "7"),
        // requestAnimationFrame（マクロタスク。timestamp 引数 + cancelAnimationFrame）
        ("typeof requestAnimationFrame", "function"),
        ("var x=0; await new Promise(r => requestAnimationFrame(() => { x = 5; r(); })); x", "5"),
        ("var ty=''; await new Promise(r => requestAnimationFrame(t => { ty = typeof t; r(); })); ty", "number"),
        ("var L=''; requestAnimationFrame(() => L+='a'); var id=requestAnimationFrame(() => L+='b'); cancelAnimationFrame(id); await new Promise(r => requestAnimationFrame(() => r())); L", "a"),
        // localStorage / sessionStorage（静的マップ共有のため各テスト先頭で clear）
        ("localStorage.clear(); localStorage.setItem('a','1'); localStorage.getItem('a')", "1"),
        ("localStorage.clear(); localStorage.getItem('missing')", "null"),
        ("localStorage.clear(); localStorage.setItem('x','9'); localStorage.length", "1"),
        ("localStorage.clear(); localStorage.setItem('a','1'); localStorage.removeItem('a'); localStorage.getItem('a')", "null"),
        ("localStorage.clear(); localStorage.foo='bar'; localStorage.getItem('foo')", "bar"),
        ("sessionStorage.clear(); sessionStorage.setItem('s','2'); sessionStorage.getItem('s')", "2"),
        // `delete localStorage.foo` も同じ種類の黙殺バグだった（`removeItem` と同義のはずが
        // Host プロキシが `.props` を持たないため何も起きていなかった）。
        (
            "localStorage.clear(); localStorage.foo='bar'; delete localStorage.foo; localStorage.getItem('foo')",
            "null",
        ),
        // `Object.keys/values/entries(localStorage)` と `for...in localStorage` が実データ
        // (専用マップ側にある) を一切見ておらず常に空になっていたバグの修正確認。
        (
            "localStorage.clear(); localStorage.setItem('a','1'); localStorage.setItem('b','2'); Object.keys(localStorage).sort().join(',')",
            "a,b",
        ),
        (
            "localStorage.clear(); localStorage.setItem('a','1'); localStorage.setItem('b','2'); Object.values(localStorage).sort().join(',')",
            "1,2",
        ),
        (
            "localStorage.clear(); localStorage.setItem('a','1'); Object.entries(localStorage)[0].join(':')",
            "a:1",
        ),
        (
            "localStorage.clear(); localStorage.setItem('a','1'); localStorage.setItem('b','2'); var out=[]; for (var k in localStorage) out.push(k); out.sort().join(',')",
            "a,b",
        ),
        (
            "localStorage.clear(); localStorage.setItem('a','1'); Object.assign({}, localStorage).a",
            "1",
        ),
        // `Object.keys/values/entries(el.dataset)` と `for...in el.dataset` も同種の
        // バグで実データ（DOM 要素側の `data-*` 属性）を一切見ておらず常に空になって
        // いた（`localStorage`/`sessionStorage` で修正済みのバグと同型）。
        (
            "var e=document.createElement('div'); e.dataset.userId='42'; e.dataset.fooBar='x'; Object.keys(e.dataset).sort().join(',')",
            "fooBar,userId",
        ),
        (
            "var e=document.createElement('div'); e.dataset.a='1'; e.dataset.b='2'; Object.values(e.dataset).sort().join(',')",
            "1,2",
        ),
        (
            "var e=document.createElement('div'); e.dataset.a='1'; Object.entries(e.dataset)[0].join(':')",
            "a:1",
        ),
        (
            "var e=document.createElement('div'); e.dataset.a='1'; e.dataset.b='2'; var out=[]; for (var k in e.dataset) out.push(k); out.sort().join(',')",
            "a,b",
        ),
        (
            "var e=document.createElement('div'); e.dataset.a='1'; Object.assign({}, e.dataset).a",
            "1",
        ),
        // タグ付きテンプレート `` tag`...${e}...` ``（ES2015）が丸ごと未対応で、`Template`
        // トークンが式の直後に来ると静かにパースが崩れるバグだった。基本形・複数補間・
        // `this` 束縛（メソッド呼出形）・組込み `String.raw` を確認。
        (
            "function tag(s, ...v){ return s.join('|') + '::' + v.join(','); } tag`a${1}b${2}c`",
            "a|b|c::1,2",
        ),
        (
            "var o={ tag(s){ return this===o ? s[0] : 'bad'; } }; o.tag`hi`",
            "hi",
        ),
        ("String.raw`a\\nb`", "a\\nb"),
        ("String.raw`x${1+1}y`", "x2y"),
        // `strings.raw` はエスケープ未解決のまま渡る（cooked とは別）ことの確認。
        (
            "function tag(s){ return s[0] + '|' + s.raw[0]; } tag`a\\nb`",
            "a\nb|a\\nb",
        ),
        // `Object.is(a, b)`（ES2015、SameValue）が丸ごと欠落していた。`===` と違い
        // `NaN` 同士は等しく、`+0`/`-0` は区別する。
        ("Object.is(NaN, NaN)", "true"),
        ("NaN === NaN", "false"),
        ("Object.is(0, -0)", "false"),
        ("0 === -0", "true"),
        ("Object.is(1, 1)", "true"),
        ("Object.is('a', 'a')", "true"),
        ("Object.is({}, {})", "false"),
        // `Reflect.setPrototypeOf`/`isExtensible`/`preventExtensions`/
        // `getOwnPropertyDescriptor` が丸ごと欠落していた。
        (
            "var o={}; var p={x:1}; Reflect.setPrototypeOf(o,p); o.x",
            "1",
        ),
        ("var o={}; Reflect.isExtensible(o)", "true"),
        (
            "var o={}; Reflect.preventExtensions(o); Reflect.isExtensible(o)",
            "false",
        ),
        (
            "Reflect.getOwnPropertyDescriptor({x:1}, 'x').value",
            "1",
        ),
        // `Array.prototype.fill(value, start, end)` が第2/第3引数を完全に無視し、
        // 常に配列全体を上書きしていた。
        ("[1,2,3,4,5].fill(0,1,3).join(',')", "1,0,0,4,5"),
        ("[1,2,3,4,5].fill(9).join(',')", "9,9,9,9,9"),
        ("[1,2,3,4,5].fill(0,-2).join(',')", "1,2,3,0,0"),
        ("[1,2,3].fill(0,1).join(',')", "1,0,0"),
        // `Array.prototype.indexOf`/`includes` の `fromIndex`（第2引数）が完全に無視され、
        // 常に先頭から探索していた。
        ("[1,2,3,2,1].indexOf(2, 2)", "3"),
        ("[1,2,3].indexOf(1, 1)", "-1"),
        ("[1,2,3].indexOf(2, -2)", "1"),
        ("[1,2,3].includes(1, 1)", "false"),
        ("[1,2,3].includes(2, 1)", "true"),
        // `lastIndexOf` にも同じ `fromIndex` 無視バグがあった。
        ("[1,2,1,2,1].lastIndexOf(2, 2)", "1"),
        ("[1,2,3].lastIndexOf(3, 1)", "-1"),
        ("[1,2,3].lastIndexOf(1, -1)", "0"),
        ("[1,2,3,2].lastIndexOf(2)", "3"),
        // `fromIndex` に NaN を渡すと仕様上 `ToIntegerOrInfinity(NaN)=0` として扱われ
        // index 0 のみを見るはずだが、以前は無条件に -1 を返していた。
        ("[5,1,2].lastIndexOf(5, NaN)", "0"),
        ("[5,1,2].lastIndexOf(1, NaN)", "-1"),
        // URLSearchParams
        ("new URLSearchParams('a=1&b=2').get('a')", "1"),
        ("new URLSearchParams('?a=1&b=2').get('b')", "2"),
        ("new URLSearchParams('a=1&a=2').getAll('a').join(',')", "1,2"),
        ("new URLSearchParams('a=1').has('a') + ',' + new URLSearchParams('a=1').has('z')", "true,false"),
        ("var p=new URLSearchParams('a=1'); p.append('b','2'); p.toString()", "a=1&b=2"),
        ("var p=new URLSearchParams('a=1&b=2'); p.delete('a'); p.toString()", "b=2"),
        ("var p=new URLSearchParams('a=1'); p.set('a','9'); p.get('a')", "9"),
        // `new URLSearchParams(init)` の init がオブジェクトの場合（sequence of
        // pairs / record / 既存インスタンス）が丸ごと壊れていたバグ（`to_js_string`
        // 丸投げで常に `"[object Object]"` 相当に落ちていた）。
        ("new URLSearchParams([['a','1'],['b','2']]).toString()", "a=1&b=2"),
        ("new URLSearchParams({a:'1',b:'2'}).toString()", "a=1&b=2"),
        (
            "var p1=new URLSearchParams('a=1&b=2'); new URLSearchParams(p1).toString()",
            "a=1&b=2",
        ),
        // URLSearchParams: %XX / + デコード（form-urlencoded）
        ("new URLSearchParams('a=hello%20world').get('a')", "hello world"),
        ("new URLSearchParams('a=hello+world').get('a')", "hello world"),
        ("var p=new URLSearchParams(); p.set('a','hello world'); p.toString()", "a=hello+world"),
        ("var p=new URLSearchParams(); p.set('a','a&b=c'); p.get('a')", "a&b=c"),
        // `entries`/`keys`/`values`/`forEach` が `URLSearchParams` に丸ごと欠落していた
        // （`FormData` は既にあったが、内部表現が同じなのに移植されていなかった）。
        (
            "[...new URLSearchParams('a=1&b=2').entries()].map(e=>e[0]+':'+e[1]).join(',')",
            "a:1,b:2",
        ),
        ("new URLSearchParams('a=1&b=2').keys().join(',')", "a,b"),
        ("new URLSearchParams('a=1&b=2').values().join(',')", "1,2"),
        (
            "var s=''; new URLSearchParams('a=1&b=2').forEach(function(v,k){ s+=k+'='+v+';'; }); s",
            "a=1;b=2;",
        ),
        // `Symbol.iterator` 未登録で `for (const [k,v] of params)`（`entries()` と同義の
        // 既定イテレーション）が丸ごと非対応だったバグ。`FormData` にも同じ修正を適用。
        (
            "var out=[]; for (const [k,v] of new URLSearchParams('a=1&b=2')) out.push(k+':'+v); out.join(',')",
            "a:1,b:2",
        ),
        (
            "var fd=new FormData(); fd.set('x','9'); var out=[]; for (const [k,v] of fd) out.push(k+':'+v); out.join(',')",
            "x:9",
        ),
        // URLPattern API (HTML Standard)
        ("new URLPattern('/users/:id').test('/users/123')", "true"),
        ("new URLPattern({ pathname: '/about' }).test('/about')", "true"),
        ("new URLPattern('/users/:id').exec('/users/123').pathname.input", "/users/123"),
        ("new URLPattern('/admin/*').test('/users/123')", "false"),
        // encodeURIComponent / decodeURIComponent
        ("encodeURIComponent('hello world')", "hello%20world"),
        ("encodeURIComponent('a=1&b=2')", "a%3D1%26b%3D2"),
        ("decodeURIComponent('hello%20world')", "hello world"),
        ("decodeURIComponent(encodeURIComponent('日本語'))", "日本語"),
        ("encodeURIComponent(\"!'()*\")", "!'()*"),
        // encodeURI / decodeURI（予約文字は残す）
        ("encodeURI('https://example.com/a b?x=1&y=2')", "https://example.com/a%20b?x=1&y=2"),
        ("decodeURI('https://example.com/a%20b')", "https://example.com/a b"),
        // `escape`/`unescape`（Annex B.2.1）が丸ごと未対応だった。
        ("escape('a b?c')", "a%20b%3Fc"),
        ("unescape(escape('a b?c'))", "a b?c"),
        // ASCII 範囲外は `%uXXXX` 形式になる。
        ("escape('日')", "%u65E5"),
        ("unescape('%u65E5')", "日"),
        // Annex B.2.3 の `String.prototype` HTML ラッパーメソッド群が丸ごと未対応だった。
        ("'hi'.bold()", "<b>hi</b>"),
        ("'hi'.italics()", "<i>hi</i>"),
        ("'hi'.big()", "<big>hi</big>"),
        ("'hi'.small()", "<small>hi</small>"),
        ("'hi'.strike()", "<strike>hi</strike>"),
        ("'hi'.sub()", "<sub>hi</sub>"),
        ("'hi'.sup()", "<sup>hi</sup>"),
        ("'hi'.fixed()", "<tt>hi</tt>"),
        ("'hi'.blink()", "<blink>hi</blink>"),
        ("'hi'.anchor('top')", "<a name=\"top\">hi</a>"),
        ("'hi'.link('x.html')", "<a href=\"x.html\">hi</a>"),
        ("'hi'.fontcolor('red')", "<font color=\"red\">hi</font>"),
        ("'hi'.fontsize(3)", "<font size=\"3\">hi</font>"),
        // 属性値の `\"` は `&quot;` へエスケープする（仕様どおり）。
        ("'hi'.anchor('a\"b')", "<a name=\"a&quot;b\">hi</a>"),
        // `trimLeft`/`trimRight`（Annex B.2.2。`trimStart`/`trimEnd` の別名）が
        // 丸ごと未対応だった。
        ("'  hi  '.trimLeft()", "hi  "),
        ("'  hi  '.trimRight()", "  hi"),
        // FormData (空生成 + API)
        ("var f=new FormData(); f.append('a','1'); f.append('b','2'); f.get('a')", "1"),
        ("var f=new FormData(); f.append('a','1'); f.append('a','2'); f.getAll('a').join(',')", "1,2"),
        ("var f=new FormData(); f.append('a','1'); f.append('b','2'); f.toString()", "a=1&b=2"),
        ("var f=new FormData(); f.append('a','1'); f.set('a','9'); f.get('a')", "9"),
        ("var f=new FormData(); f.append('a','1'); f.has('a')+','+f.has('z')", "true,false"),
        ("var f=new FormData(); f.append('a','1'); f.append('b','2'); f.entries().map(function(e){return e[0]+'='+e[1]}).join('&')", "a=1&b=2"),
        ("var f=new FormData(); f.append('a','1'); f.append('b','2'); f.keys().join(',')", "a,b"),
        ("var f=new FormData(); f.append('a','1'); f.append('b','2'); var s=''; f.forEach(function(v,k){s+=k+':'+v+';'}); s", "a:1;b:2;"),
        // URL
        ("new URL('https://e.com/p?x=1#h').pathname", "/p"),
        ("new URL('https://e.com/p?x=1').searchParams.get('x')", "1"),
        // `new URL(url, base)` の第2引数 base が丸ごと無視され、相対URL解決という
        // URL API 最も基本的な使い方が機能しなかったバグ（既存の `resolve_url`
        // ヘルパは `fetch`/XHR では既に使われていたが `URL` コンストラクタには
        // 配線されていなかった。`.`/`..` セグメントの解決は非対応の簡略実装
        // という既存の制約はそのまま）。
        ("new URL('/a/b', 'https://e.com/x/y').href", "https://e.com/a/b"),
        ("new URL('c', 'https://e.com/a/b').href", "https://e.com/a/c"),
        // `user:pass@host` 形式のユーザー情報（userinfo）が丸ごと未対応で、
        // `hostname`（引いては `host`/`port`/`origin`）にそのまま混入し
        // 壊れた値になるバグだった（`user` が `hostname` の一部に化ける）。
        ("new URL('https://user:pass@example.com/p').hostname", "example.com"),
        ("new URL('https://user:pass@example.com/p').username", "user"),
        ("new URL('https://user:pass@example.com/p').password", "pass"),
        ("new URL('https://user:pass@example.com/p').origin", "https://example.com"),
        // ユーザー情報無しの通常URLでは既定値が空文字列のまま（回帰確認）。
        ("new URL('https://example.com/p').username", ""),
        // `url.href = '...'`（URL全体を再パースして全コンポーネントを書き換える
        // 定番の再代入パターン）が丸ごと未対応で、セッターが無いため代入が
        // 黙って無視されていた。
        (
            "var u=new URL('https://a.com/x'); u.href='https://b.com/y?z=1'; u.hostname",
            "b.com",
        ),
        (
            "var u=new URL('https://a.com/x'); u.href='https://b.com/y?z=1'; u.pathname",
            "/y",
        ),
        (
            "var u=new URL('https://a.com/x'); u.href='https://b.com/y?z=1'; u.searchParams.get('z')",
            "1",
        ),
        (
            // オブジェクト自体は再代入せず同じインスタンスを書き換えるため、
            // 元の変数参照からも新しい値が見える。
            "var u=new URL('https://a.com/x'); var u2=u; u.href='https://b.com/y'; u2.href",
            "https://b.com/y",
        ),
        // `url.pathname`/`.search`/`.hash`の個別再代入が丸ごと未対応だった。
        // 特に`.search`は`url.toString()`/`.href`が`searchParams`だけを見て
        // `search`プロパティ自体は読まないため、代入しても何も反映されない
        // という`.href`丸ごと差し替えとは別種の静かな不整合があった。
        (
            "var u=new URL('https://a.com/x'); u.pathname='y'; u.href",
            "https://a.com/y",
        ),
        (
            "var u=new URL('https://a.com/x'); u.search='z=1'; u.href",
            "https://a.com/x?z=1",
        ),
        (
            "var u=new URL('https://a.com/x'); u.search='z=1'; u.searchParams.get('z')",
            "1",
        ),
        (
            "var u=new URL('https://a.com/x?old=1'); u.search='new=2'; u.href",
            "https://a.com/x?new=2",
        ),
        (
            "var u=new URL('https://a.com/x'); u.hash='frag'; u.href",
            "https://a.com/x#frag",
        ),
        (
            // 空文字列への代入はコンポーネントを除去する（クエリ/フラグメント無しに戻る）。
            "var u=new URL('https://a.com/x?y=1#z'); u.search=''; u.hash=''; u.href",
            "https://a.com/x",
        ),
        // `url.protocol`/`.host`/`.hostname`/`.port`の個別再代入も丸ごと
        // 未対応だった。これら4つは互いに依存する派生値（`host`=`hostname`+
        // `:`+`port`、`origin`=`protocol`+`//`+`host`）を持つため、どれを
        // 代入しても`host`/`origin`を再計算し直す必要がある。
        (
            "var u=new URL('https://a.com:8080/x'); u.hostname='b.com'; u.href",
            "https://b.com:8080/x",
        ),
        (
            "var u=new URL('https://a.com:8080/x'); u.hostname='b.com'; u.origin",
            "https://b.com:8080",
        ),
        (
            "var u=new URL('https://a.com/x'); u.port='9090'; u.host",
            "a.com:9090",
        ),
        (
            "var u=new URL('https://a.com:8080/x'); u.host='c.com:7070'; u.hostname + ',' + u.port",
            "c.com,7070",
        ),
        (
            "var u=new URL('http://a.com/x'); u.protocol='https'; u.href",
            "https://a.com/x",
        ),
        // クエリのみ/フラグメントのみの相対参照（`?x=2`/`#frag`）が、他の
        // 相対パス解決と同じ「ディレクトリ相対」ロジックに落ちてベースの
        // パスの最後のセグメントごと消えるバグだった。
        ("new URL('?x=2', 'https://e.com/a/b?x=1').href", "https://e.com/a/b?x=2"),
        ("new URL('#frag', 'https://e.com/a/b?x=1').href", "https://e.com/a/b?x=1#frag"),
        // プロトコル相対URL（`//host/path`）が、ベースのホスト配下の相対パスと
        // して誤解決されるバグだった（`//cdn.example.com/x.js` は別ホストへの
        // 参照であり、ベースホスト配下のパスにしてはいけない）。
        ("new URL('//cdn.example.com/x.js', 'https://e.com/a/b').href", "https://cdn.example.com/x.js"),
        // `URL.canParse(url, base?)`（ES2023/WHATWG）が丸ごと未対応だった。
        ("URL.canParse('https://example.com')", "true"),
        ("URL.canParse('not a url')", "false"),
        ("URL.canParse('/path', 'https://example.com')", "true"),
        ("URL.canParse('/path')", "false"),
        // `URL.parse(url, base?)`（ES2024/WHATWG）が丸ごと未対応だった。
        // `try { new URL(x) } catch { null }` の1メソッド版。
        ("URL.parse('https://example.com/p').pathname", "/p"),
        ("URL.parse('not a url') === null", "true"),
        ("URL.parse('/path', 'https://example.com').host", "example.com"),
        ("URL.parse('/path') === null", "true"),
        // `URL.createObjectURL(blob)`/`.revokeObjectURL(url)` が丸ごと未対応だった。
        ("URL.createObjectURL(new Blob(['x'])).startsWith('blob:')", "true"),
        // 呼び出す毎に一意な URL を発行する。
        (
            "URL.createObjectURL(new Blob(['x'])) === URL.createObjectURL(new Blob(['x']))",
            "false",
        ),
        ("typeof URL.revokeObjectURL('blob:x')", "undefined"),
        // `URLSearchParams.prototype.size`（ES2023）が丸ごと未対応だった。
        ("new URLSearchParams('a=1&b=2').size", "2"),
        (
            "var p=new URLSearchParams('a=1'); p.append('b','2'); p.size",
            "2",
        ),
        (
            "var p=new URLSearchParams('a=1&b=2'); p.delete('a'); p.size",
            "1",
        ),
        ("new URLSearchParams('').size", "0"),
        // `has(name, value)`/`delete(name, value)`（ES2023 の第2引数）が丸ごと
        // 無視され、値を問わず同名エントリを判定/削除してしまうバグだった。
        ("new URLSearchParams('a=1&a=2').has('a', '1')", "true"),
        ("new URLSearchParams('a=1&a=2').has('a', '9')", "false"),
        (
            "var p=new URLSearchParams('a=1&a=2'); p.delete('a','1'); p.getAll('a').join(',')",
            "2",
        ),
        (
            "var p=new URLSearchParams('a=1&a=2'); p.delete('a'); p.getAll('a').join(',')",
            "",
        ),
        // `URLSearchParams.prototype.sort()`（ES2020）が丸ごと未対応だった。
        (
            "var p=new URLSearchParams('c=3&a=1&b=2'); p.sort(); p.toString()",
            "a=1&b=2&c=3",
        ),
        (
            "var p=new URLSearchParams('b=2&a=1&a=0'); p.sort(); p.getAll('a').join(',')",
            "1,0",
        ),
        // `url.toString()`（暗黙の文字列化 `fetch(url)` 等でも使われる）が `href` の
        // 構築時点スナップショットのままで、`searchParams` の変更を反映しないバグ。
        (
            "var u=new URL('https://e.com/p?x=1'); u.searchParams.set('x','9'); u.toString()",
            "https://e.com/p?x=9",
        ),
        (
            "var u=new URL('https://e.com/p'); u.searchParams.append('a','1'); u.searchParams.append('b','2'); u.toString()",
            "https://e.com/p?a=1&b=2",
        ),
        (
            "var u=new URL('https://e.com/p?x=1#h'); u.searchParams.delete('x'); u.toString()",
            "https://e.com/p#h",
        ),
        // `URL.prototype.toJSON`（仕様上 `toString()` と同じ href を返すだけの
        // エイリアス）が丸ごと未対応で、`JSON.stringify(url)` がプロパティ丸ごとの
        // JSON になってしまうバグだった。
        (
            "JSON.stringify({u: new URL('https://e.com/p?x=1')})",
            "{\"u\":\"https://e.com/p?x=1\"}",
        ),
        // base64
        ("btoa('hello')", "aGVsbG8="),
        ("atob('aGVsbG8=')", "hello"),
        ("atob(btoa('AtmOS roundtrip'))", "AtmOS roundtrip"),
        // navigator / performance
        ("navigator.platform", "AtmOS"),
        ("typeof navigator.userAgent", "string"),
        ("navigator.onLine", "true"),
        // `navigator.cookieEnabled`/`.hardwareConcurrency`/`.maxTouchPoints`/
        // `.languages`/`.webdriver`（丸ごと未対応だった）。
        ("navigator.cookieEnabled", "true"),
        ("navigator.hardwareConcurrency", "4"),
        ("navigator.maxTouchPoints", "0"),
        ("navigator.languages[0]", "ja-JP"),
        ("navigator.webdriver", "false"),
        // `navigator.userAgentData`（Client Hints API。丸ごと未対応だった。
        // `navigator.userAgent`文字列パースに代わる構造化版の定番フィー
        // チャー検出パターン。2026-07-17 発見・実装）。
        (
            "navigator.userAgentData.brands[0].brand + ',' + navigator.userAgentData.mobile + ',' + \
             navigator.userAgentData.platform",
            "AtmOSBrowser,false,AtmOS",
        ),
        (
            "await navigator.userAgentData.getHighEntropyValues(['architecture','bitness']).then(v => \
             v.architecture + ',' + v.bitness + ',' + v.platform)",
            "arm,64,AtmOS",
        ),
        // `navigator.storage`（StorageManager API。`.estimate()`/`.persist()`/
        // `.persisted()`が丸ごと未対応だった。2026-07-17 発見・実装。実際の
        // ディスク使用量計測機構が無いため`usage:0`の誠実な簡略値、
        // `persist`/`persisted`は常に`true`）。
        (
            "await navigator.storage.estimate().then(e => typeof e.usage + ',' + typeof e.quota)",
            "number,number",
        ),
        ("await navigator.storage.persist()", "true"),
        ("await navigator.storage.persisted()", "true"),
        ("typeof performance.now()", "number"),
        // Performance Timeline / User Timing API（`mark`/`measure`/
        // `getEntriesByType`/`getEntriesByName`/`clearMarks`/`clearMeasures`）
        // が `now()` 以外丸ごと未対応だった。
        ("performance.mark('a').entryType", "mark"),
        (
            "performance.mark('s1'); performance.mark('e1'); \
             performance.measure('m1','s1','e1').entryType",
            "measure",
        ),
        // `performance.timeOrigin`（丸ごと未対応だった。2026-07-16 発見・
        // 実装）。自己テストはブート初期段階（壁時計がまだ NTP 同期前）に
        // 実行されるため `epoch_ms_now()` が `0` を返しうる。数値型である
        // ことのみ検証し、正の値は断定しない。
        ("typeof performance.timeOrigin", "number"),
        ("performance.timeOrigin >= 0", "true"),
        // `performance.getEntries()`（フィルタ無し全件取得。丸ごと未対応
        // だった。2026-07-16 発見・実装）。
        (
            "performance.mark('ge1'); performance.getEntries().some(e => e.name === 'ge1')",
            "true",
        ),
        ("performance.mark('a'); performance.getEntriesByType('mark').length > 0", "true"),
        ("performance.mark('a'); performance.getEntriesByName('a', 'mark').length", "1"),
        (
            "performance.mark('to-clear'); performance.clearMarks('to-clear'); \
             performance.getEntriesByName('to-clear').length",
            "0",
        ),
        (
            "performance.mark('sX'); performance.mark('eX'); \
             performance.measure('mX','sX','eX'); performance.clearMeasures(); \
             performance.getEntriesByType('measure').length",
            "0",
        ),
        // `PerformanceObserver`（丸ごと未対応だった。`observe({entryTypes})`
        // で監視中の種別に一致する `mark`/`measure` を同期通知する）。
        (
            "let got; new PerformanceObserver((list) => { got = list.getEntries()[0].name; }) \
             .observe({entryTypes:['mark']}); performance.mark('obs1'); got",
            "obs1",
        ),
        (
            "let n = 0; new PerformanceObserver((list) => { n += list.getEntries().length; }) \
             .observe({entryTypes:['measure']}); performance.mark('s2'); \
             performance.mark('e2'); performance.measure('m2','s2','e2'); n",
            "1",
        ),
        (
            "let hit = false; let ob = new PerformanceObserver(() => { hit = true; }); \
             ob.observe({entryTypes:['mark']}); ob.disconnect(); performance.mark('after-disconnect'); hit",
            "false",
        ),
        // `PerformanceObserver.supportedEntryTypes`（丸ごと未対応だった。
        // 2026-07-16 発見・実装）。
        (
            "PerformanceObserver.supportedEntryTypes.join(',')",
            "mark,measure",
        ),
        // `observe({type: '...', buffered: true})`（単一種別＋既存エントリ
        // 即時配信の新形式）が丸ごと未対応だった（`entryTypes`しか読んで
        // おらず`type`単体では一切発火しない黙殺バグだった。2026-07-17
        // 発見・実装）。
        (
            "let got; new PerformanceObserver((list) => { got = list.getEntries()[0].name; }) \
             .observe({type:'mark'}); performance.mark('obs2'); got",
            "obs2",
        ),
        (
            "performance.mark('pre-existing'); let got=null; \
             new PerformanceObserver((list) => { got = list.getEntries()[0].name; }) \
             .observe({type:'mark', buffered:true}); got",
            "pre-existing",
        ),
        (
            "let n=0; new PerformanceObserver((list) => { n += list.getEntries().length; }) \
             .observe({type:'mark'}); n",
            "0",
        ),
        // MessageChannel/MessagePort（丸ごと未対応だった。`.port1`/`.port2` 間の
        // 双方向メッセージング）。
        (
            "let mc = new MessageChannel(); let got; \
             mc.port2.onmessage = e => { got = e.data; }; \
             mc.port1.postMessage('hi'); got",
            "hi",
        ),
        (
            "let mc2 = new MessageChannel(); let n = 0; \
             mc2.port2.addEventListener('message', e => { n += e.data; }); \
             mc2.port1.postMessage(1); mc2.port1.postMessage(2); n",
            "3",
        ),
        (
            "let mc3 = new MessageChannel(); let hit = false; \
             mc3.port2.onmessage = () => { hit = true; }; \
             mc3.port2.close(); mc3.port1.postMessage('x'); hit",
            "false",
        ),
        // BroadcastChannel（丸ごと未対応だった。同名インスタンス全体への配送、
        // 自分自身への配送除外、他名チャネルへの非配送を確認）。
        (
            "let a1 = new BroadcastChannel('ch'); let b1 = new BroadcastChannel('ch'); \
             let got; b1.onmessage = e => { got = e.data; }; \
             a1.postMessage('hi'); got",
            "hi",
        ),
        (
            "let a2 = new BroadcastChannel('ch2'); let selfHit = false; \
             a2.onmessage = () => { selfHit = true; }; \
             a2.postMessage('x'); selfHit",
            "false",
        ),
        (
            "let a3 = new BroadcastChannel('chX'); let b3 = new BroadcastChannel('chY'); \
             let hit = false; b3.onmessage = () => { hit = true; }; \
             a3.postMessage('x'); hit",
            "false",
        ),
        // `window.screen`（丸ごと未対応だった。`screen.width`/`.height`/
        // `.availWidth`/`.availHeight`/`.colorDepth`/`.orientation.type` という
        // レスポンシブ分岐の定番パターン）。
        ("typeof screen.width", "number"),
        ("screen.width === window.innerWidth", "true"),
        ("screen.availHeight === screen.height", "true"),
        ("screen.colorDepth", "24"),
        ("screen.orientation.type", "landscape-primary"),
        ("window.screen === screen", "true"),
        // `screen.orientation.lock()`/`.unlock()`（丸ごと未対応だった。実際に
        // 画面の向きを固定する機構は無いため状態のみ追跡する簡略実装）。
        (
            "typeof screen.orientation.lock('portrait-primary').then",
            "function",
        ),
        (
            "screen.orientation.lock('portrait-primary'); screen.orientation.type",
            "portrait-primary",
        ),
        (
            "screen.orientation.lock('portrait-primary'); screen.orientation.unlock(); \
             screen.orientation.type",
            "landscape-primary",
        ),
        // `reportError()`（丸ごと未対応だった。`window.onerror`/
        // `window.addEventListener('error', fn)` へ未捕捉例外と同じ経路で
        // 通知する標準グローバル関数）。
        (
            "let got; window.onerror = (msg) => { got = msg; }; \
             reportError(new Error('boom')); got",
            "boom",
        ),
        (
            "let ev; window.addEventListener('error', e => { ev = e; }); \
             reportError(new Error('e2')); ev.error.message",
            "e2",
        ),
        ("typeof reportError('plain string')", "undefined"),
        // `window.confirm`/`window.prompt`（丸ごと未対応だった。`alert`は
        // 既に`console_log`で代替されていたのに、対になるこの2つだけ
        // グローバルにも`window`にも未登録で`TypeError`になっていた。
        // ブロッキングUIが無いこの処理系では常に「OK」相当を返す簡略実装。
        // 2026-07-16 発見・実装）。
        ("confirm('are you sure?')", "true"),
        ("window.confirm('are you sure?')", "true"),
        ("prompt('name?', 'bob')", "bob"),
        ("window.prompt('name?')", "null"),
        // `window.open`/`.close`/`.focus`/`.blur`（丸ごと未対応だった。同じ
        // 監査で発見。呼び出すと`TypeError`になっていた。この処理系には
        // 複数ウィンドウ機構が無いため`open`はポップアップブロック相当の
        // `null`、他は無害なno-op。2026-07-16 発見・実装）。
        ("typeof open", "function"),
        ("open('https://example.com')", "null"),
        ("window.open('https://example.com', '_blank')", "null"),
        ("typeof close", "function"),
        ("close(); window.close(); 'ok'", "ok"),
        // `window.stop()`（丸ごと未対応だった。ページ読み込み中止ボタン
        // 相当の定番API。2026-07-17 発見・実装。`close`/`.print`と同じ
        // 無害なno-op）。
        ("typeof stop", "function"),
        ("stop(); window.stop(); 'ok'", "ok"),
        ("typeof focus", "function"),
        ("focus(); window.focus(); blur(); window.blur(); 'ok'", "ok"),
        // `window.getSelection()`（丸ごと未対応だった。`document.
        // getSelection()`は既に実装済みだったが、仕様上こちらが本来の
        // 正規の場所で、より一般的に使われる`window.getSelection().
        // toString()`等のイディオムが`TypeError`になっていた。
        // 2026-07-16 発見・実装。同じ実装を再利用するため戻り値も
        // `document.getSelection()`と同一の空文字列）。
        ("typeof window.getSelection", "function"),
        ("typeof getSelection", "function"),
        ("window.getSelection().toString()", ""),
        // `self`/`top`/`parent`/`frames`（丸ごと未対応だった。`globalThis`
        // は既に実装済みだったのに、同じ「windowを指す別名」仲間のこの4つ
        // だけ登録が漏れていた。この処理系には独立JSレルムを持つiframeが
        // 無く常に単一フレームのため、仕様どおり自分自身を指す。
        // 2026-07-16 発見・実装）。
        ("self === window", "true"),
        ("window.top === window", "true"),
        ("parent === window", "true"),
        ("window.frames === window", "true"),
        ("typeof window.name", "string"),
        // `iframe.contentWindow`/`.contentDocument`（同じ「フレームが無い
        // ので自分自身を指す」規定。丸ごと未対応だった。2026-07-17
        // 発見・実装）。
        (
            "document.createElement('iframe').contentWindow === window",
            "true",
        ),
        (
            "document.createElement('iframe').contentDocument === document",
            "true",
        ),
        (
            "document.createElement('div').contentWindow",
            "undefined",
        ),
        // `object.contentDocument`（丸ごと未対応だった。`HTMLObjectElement`
        // は`contentWindow`を持たず`contentDocument`のみが仕様上の対象。
        // 2026-07-17 発見・実装）。
        (
            "document.createElement('object').contentDocument === document",
            "true",
        ),
        (
            "document.createElement('object').contentWindow",
            "undefined",
        ),
        // `navigator.sendBeacon(url, data)`（丸ごと未対応だった。ページ離脱時の
        // 計測データ送信に使われる定番パターン。既存の `fetch()` POST経路を
        // 再利用して送信し常に `true` を返す）。
        ("typeof navigator.sendBeacon", "function"),
        ("navigator.sendBeacon('data:,x')", "true"),
        ("navigator.sendBeacon('data:,x', 'payload')", "true"),
        // `XMLSerializer`（丸ごと未対応だった。`.serializeToString(node)` は
        // 既存の `outerHTML` ゲッターと同じ `get_outer_html` を再利用する）。
        (
            "var e=document.createElement('div'); e.setAttribute('id','x'); \
             e.setAttribute('class','a b'); e.innerHTML='hi2'; \
             new XMLSerializer().serializeToString(e) === e.outerHTML",
            "true",
        ),
        (
            "var e=document.createElement('span'); e.textContent='z'; \
             new XMLSerializer().serializeToString(e) === e.outerHTML",
            "true",
        ),
        ("typeof new XMLSerializer().serializeToString", "function"),
        // `navigator.clipboard`（丸ごと未対応だった。`writeText`/`readText` という
        // コピー&ペースト UI の定番パターン）。実クリップボードは無いため単純な
        // プロセス内文字列保持で近似する。
        (
            "await navigator.clipboard.writeText('hello'); await navigator.clipboard.readText()",
            "hello",
        ),
        ("typeof navigator.clipboard.writeText('x')", "object"),
        // Array: at / flatMap / findLast / findLastIndex
        ("[10,20,30].at(-1)", "30"),
        ("[10,20,30].at(0)", "10"),
        ("[1,2,3].flatMap(x => [x, x*10]).join(',')", "1,10,2,20,3,30"),
        ("[1,2,3,4].findLast(x => x % 2 === 1)", "3"),
        ("[1,2,3,4].findLastIndex(x => x % 2 === 0)", "3"),
        // String: at
        ("'hello'.at(-1)", "o"),
        ("'hello'.at(1)", "e"),
        // 通常の呼び出しは影響を受けないことも確認。
        ("'hello world'.includes('world')", "true"),
        ("'hello'.startsWith('he')", "true"),
        ("'hello'.endsWith('lo')", "true"),
        // **重要**: `includes`/`startsWith`/`endsWith` は仕様上、第1引数に
        // `RegExp` を渡すと `TypeError` を投げる必要がある（うっかり正規表現を
        // 渡した誤用に対する意図的なガード）が、丸ごと未対応で常に無言で
        // リテラル文字列 `"/x/"` として検索してしまっていた。
        (
            "try { 'x'.includes(/x/); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "try { 'x'.startsWith(/x/); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "try { 'x'.endsWith(/x/); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // Promise: allSettled / race / any
        ("(await Promise.allSettled([Promise.resolve(1), Promise.reject('e')])).map(r => r.status).join(',')", "fulfilled,rejected"),
        ("await Promise.race([Promise.resolve('first'), Promise.resolve('second')])", "first"),
        ("await Promise.any([Promise.reject('x'), Promise.resolve('ok')])", "ok"),
        // `allSettled`/`race`/`any` も `Promise.all` と同じく配列要素の汎用 thenable を
        // 同化しない非対称なバグだった（共通ヘルパ `resolve_maybe_thenable` で解消）。
        (
            "(await Promise.allSettled([{ then(r){ r(1); } }, { then(_,rj){ rj('e'); } }])).map(r => r.status).join(',')",
            "fulfilled,rejected",
        ),
        (
            "await Promise.race([{ then(r){ r('first'); } }, Promise.resolve('second')])",
            "first",
        ),
        (
            "await Promise.any([{ then(_,rj){ rj('x'); } }, { then(r){ r('ok'); } }])",
            "ok",
        ),
        // TextEncoder / TextDecoder
        ("new TextEncoder().encode('Hi').join(',')", "72,105"),
        ("new TextDecoder().decode([72,105])", "Hi"),
        ("new TextDecoder().decode(new TextEncoder().encode('AtmOS'))", "AtmOS"),
        // `new TextDecoder(label)` が丸ごとラベル引数を無視し常に `utf-8` 決め打ち
        // だったバグ（`utf-16le`/`utf-16be` データを渡すと静かに文字化けしていた）。
        ("new TextDecoder('utf-16le').encoding", "utf-16le"),
        ("new TextDecoder('utf-16be').encoding", "utf-16be"),
        // 'H'=0x48 'i'=0x69 を UTF-16LE（下位バイト→上位バイト）で並べたバイト列。
        ("new TextDecoder('utf-16le').decode([0x48,0x00,0x69,0x00])", "Hi"),
        ("new TextDecoder('utf-16be').decode([0x00,0x48,0x00,0x69])", "Hi"),
        ("new TextDecoder('utf-16').encoding", "utf-16le"),
        // `decode(chunk, {stream: true})`（丸ごと未対応だった。チャンク境界で
        // マルチバイト文字が分断された場合の定番パターン。2026-07-14 発見・
        // 実装）。'€'（U+20AC）の UTF-8 表現 [0xE2,0x82,0xAC] を先頭2バイトと
        // 残り1バイトに分割して渡す。
        (
            "var d=new TextDecoder(); d.decode(new Uint8Array([0xE2,0x82]), {stream:true}) + \
             d.decode(new Uint8Array([0xAC]))",
            "€",
        ),
        // stream:true 無し（既定 false）で不完全なバイト列を渡すと、従来どおり
        // 即座に置換文字化される（持ち越されない）。
        ("new TextDecoder().decode(new Uint8Array([0xE2,0x82]))", "\u{FFFD}"),
        // crypto
        ("crypto.randomUUID().length", "36"),
        ("crypto.randomUUID().charAt(14)", "4"),
        ("crypto.getRandomValues([0,0,0]).length", "3"),
        // `crypto.getRandomValues` が種別を無視して常に `& 0xff`（0-255）で埋めており、
        // 8bit より広い型（`Uint16Array` 等）では値域のごく一部しか使わないバグだった。
        // 十分な試行数の中に 255 を超える値が1つでも現れれば、下位8bitマスクではなく
        // 実際に16bit幅を使っている証拠になる。
        (
            "crypto.getRandomValues(new Uint16Array(200)).some(v => v > 255)",
            "true",
        ),
        // `Uint8Array` は元々の挙動（0-255 の範囲内）を維持する。
        (
            "crypto.getRandomValues(new Uint8Array(50)).every(v => v >= 0 && v <= 255)",
            "true",
        ),
        // structuredClone（深いコピー: 元を変えても複製は不変）
        ("var o={a:{b:1}}; var c=structuredClone(o); o.a.b=9; c.a.b", "1"),
        ("structuredClone([1,[2,3]])[1][0]", "2"),
        // structuredClone(Error) — 汎用の plain object 複製に落ちると proto が
        // 引き継がれず `instanceof Error` を失っていたバグ（2026-07-14 発見・修正。
        // message/name/stack は元々コピーされていたが、プロトタイプ連鎖が
        // 途切れていた）。サブタイプ（TypeError 等）も正しいプロトタイプで
        // 複製されることを確認。
        (
            "var c=structuredClone(new TypeError('x')); c instanceof Error && c instanceof TypeError",
            "true",
        ),
        ("structuredClone(new Error('boom')).message", "boom"),
        ("structuredClone(new TypeError('x')).stack", "TypeError: x"),
        // `structuredClone(function)`が仕様上の`DataCloneError`を投げず、
        // 汎用plain object複製に落ちて「呼出不能な壊れたオブジェクト」に
        // 静かに化けていたバグ（`deep_clone_value`を`Result`化して修正。
        // 2026-07-17 発見・実装）。
        (
            "try { structuredClone(function(){}); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone({fn: () => 1}); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        ("structuredClone({a: 1, b: [2, 3]}).a", "1"),
        // 上記`DataCloneError`修正の副次効果として、`URLSearchParams`/
        // `FormData`/`Headers`（メソッド群が`.props`上の生の関数値として
        // 実装されている「疑似クラス」オブジェクト）を`structuredClone`
        // すると、以前は関数プロパティごと汎用複製されて壊れたオブジェクト
        // （メソッド呼び出し不能）に静かに化けていたのが、今回の修正で
        // 正しく`DataCloneError`を投げるようになったことを確認・記録する
        // （2026-07-17）。
        (
            "try { structuredClone(new URLSearchParams('a=1')); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone(new FormData()); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone(new Headers()); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        // `structuredClone(Promise)`も仕様上構造化複製不可（`DataCloneError`）
        // だが未対応で、`.then`/`.catch`が消えた呼出不能な壊れたオブジェクト
        // に静かに化けていた（丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "try { structuredClone(Promise.resolve(1)); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        // `WeakMap`/`WeakSet`も`URLSearchParams`/`FormData`/`Headers`と同じ
        // 「メソッド群が`.props`上の生の関数値」パターンの疑似クラスで、
        // 仕様上も構造化複製不可（`DataCloneError`）。前サイクルまでの
        // `deep_clone_value`関数検出修正の副次効果で既に正しく動作している
        // ことを確認・記録する（2026-07-17）。
        (
            "try { structuredClone(new WeakMap()); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone(new WeakSet()); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        // `AbortController`/`AbortSignal`/`MessagePort`/`MessageChannel`も
        // 同じ「メソッド群が`.props`上の生の関数値」パターンの疑似クラス
        // で、仕様上も構造化複製不可。前サイクルまでの`deep_clone_value`
        // 関数検出修正の副次効果で正しく動作していることを確認・記録し、
        // `DataCloneError`検証の横断監査を完了する（2026-07-17）。
        (
            "try { structuredClone(new AbortController()); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone(new AbortController().signal); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone(new MessageChannel()); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        (
            "try { structuredClone(new MessageChannel().port1); 'no-throw' } catch(e) { e.name }",
            "DataCloneError",
        ),
        // structuredClone(Map/Set) — 中身（エントリ/要素）まで正しく複製され、元を変えても
        // 複製に影響しないこと（以前は ObjKind::MapObj/SetObj 自体が複製されず消えていたバグ）。
        (
            "var m=new Map([['a',1],['b',2]]); var c=structuredClone(m); m.set('a',99); c.get('a')+','+c.get('b')+','+c.size",
            "1,2,2",
        ),
        (
            "var s=new Set([1,2,3]); var c=structuredClone(s); s.add(4); c.has(4)+','+c.size",
            "false,3",
        ),
        // structuredClone(TypedArray) — TypedArray も内部表現は ObjKind::Array 流用
        // （`_ta_kind` タグで区別）なため、素の配列複製経路に落ちると型情報
        // （`_ta_kind`/`BYTES_PER_ELEMENT`/`set`/`slice`/`fill`）が丸ごと失われる
        // バグだった（Date/RegExp/Map/Set と同種）。
        ("var a=new Int8Array([200,-100]); var c=structuredClone(a); c.join(',')", "-56,-100"),
        (
            "var a=new Int8Array(1); var c=structuredClone(a); c.BYTES_PER_ELEMENT",
            "1",
        ),
        ("var a=new Int8Array(1); var c=structuredClone(a); c[0]=200; c[0]", "-56"),
        (
            "var a=new Int8Array([1,2]); var c=structuredClone(a); a[0]=9; c[0]",
            "1",
        ),
        // structuredClone(buf, {transfer:[buf]}) — 第2引数 transfer が丸ごと
        // 無視されており、転送指定した ArrayBuffer が detached にならなかった
        // バグ。
        (
            "var b=new ArrayBuffer(4); var c=structuredClone(b,{transfer:[b]}); b.detached+','+c.byteLength",
            "true,4",
        ),
        // structuredClone(Blob/DataView) — どちらも `Obj::plain()` + 隠しプロパティで
        // 実バイト列を持つ実装のため、汎用の plain object 複製に落ちると
        // `slice`/`text`/`getUint8` 等のネイティブ関数プロパティが呼出不能な壊れた
        // オブジェクトに複製されてしまうバグだった（TypedArray と同種）。
        (
            "var b=new Blob(['hi']); var c=structuredClone(b); await c.text()",
            "hi",
        ),
        ("var b=new Blob(['hi']); var c=structuredClone(b); c.size", "2"),
        (
            "var dv=new DataView(new ArrayBuffer(1)); dv.setUint8(0,65); var c=structuredClone(dv); c.getUint8(0)",
            "65",
        ),
        // structuredClone(ArrayBuffer) — `slice` がネイティブ関数プロパティのため
        // 同種のバグで複製後は呼出不能になっていた。
        (
            "var buf=new ArrayBuffer(4); var c=structuredClone(buf); c.byteLength",
            "4",
        ),
        (
            "var buf=new ArrayBuffer(4); var c=structuredClone(buf); typeof c.slice",
            "function",
        ),
        // structuredClone(Proxy) — 実データが `.props` ではなく `ObjKind::Proxy`
        // 側にあるため、汎用の plain object 複製に落ちると常に空の `{}` になる
        // バグだった（`Date`/`Map`/`Set` 等と同種）。仕様上は本来複製不可
        // （`DataCloneError`）だが、他の Proxy 透過性修正と同じ「target へ
        // フォワード」方針で target を複製する簡略実装とした。
        (
            "var p=new Proxy({a:1,b:2},{}); var c=structuredClone(p); c.a+','+c.b",
            "1,2",
        ),
        (
            "var t={a:1}; var p=new Proxy(t,{}); var c=structuredClone(p); t.a=99; c.a",
            "1",
        ),
        (
            "var buf = await new Blob(['A']).arrayBuffer(); var c=structuredClone(buf); new DataView(c).getUint8(0)",
            "65",
        ),
        // Object: fromEntries / getOwnPropertyNames / freeze
        ("Object.fromEntries([['a',1],['b',2]]).b", "2"),
        ("Object.getOwnPropertyNames({x:1,y:2}).join(',')", "x,y"),
        ("var o=Object.freeze({a:1}); o.a", "1"),
        // Number 静的
        ("Number.isInteger(5)", "true"),
        ("Number.isInteger(5.5)", "false"),
        ("Number.isInteger('5')", "false"),
        ("Number.isSafeInteger(9007199254740991)", "true"),
        ("Number.MAX_SAFE_INTEGER", "9007199254740991"),
        ("Number.isNaN(NaN) + ',' + Number.isNaN(5)", "true,false"),
        // `Number.MIN_VALUE`/`Number.NaN`（ES1 以来の定数）が丸ごと未登録だった。
        // `MIN_VALUE` は「0に最も近い正の値」（非正規化数まで含む）であり
        // `MIN_SAFE_INTEGER`（大きな負の整数）とは別物であることに注意。
        ("Number.MIN_VALUE > 0", "true"),
        ("Number.MIN_VALUE < Number.EPSILON", "true"),
        ("Number.isNaN(Number.NaN)", "true"),
        // Math 追加
        ("Math.hypot(3,4)", "5"),
        ("Math.log2(8)", "3"),
        ("Math.round(Math.log10(1000))", "3"),
        ("Math.round(Math.cbrt(27))", "3"),
        ("Math.atan2(0,5)", "0"),
        // Math 追加2（ES2015。fround/clz32/imul/sinh系/expm1/log1p/定数群が丸ごと未対応だった）。
        ("Math.fround(1.5)", "1.5"),
        ("Math.fround(1.1) !== 1.1", "true"),
        ("Math.f16round(1.5)", "1.5"),
        ("Math.f16round(1.337) !== 1.337", "true"),
        ("Math.sumPrecise([1, 2, 3])", "6"),
        ("Math.sumPrecise([0.1, 0.2])", "0.30000000000000004"),
        ("Math.sumPrecise([1, Infinity])", "Infinity"),
        ("isNaN(Math.sumPrecise([Infinity, -Infinity]))", "true"),
        ("isNaN(Math.sumPrecise([1, NaN]))", "true"),
        ("new Headers({'Set-Cookie':'a=1'}).getSetCookie().join(',')", "a=1"),
        ("var h=new Headers(); h.append('Set-Cookie','a=1'); h.append('Set-Cookie','b=2'); h.getSetCookie().join('; ')", "a=1; b=2"),
        ("Math.clz32(1)", "31"),
        ("Math.clz32(0)", "32"),
        ("Math.clz32(1000)", "22"),
        ("Math.imul(3,4)", "12"),
        ("Math.imul(0xffffffff, 5)", "-5"),
        ("Math.round(Math.sinh(0))", "0"),
        ("Math.cosh(0)", "1"),
        ("Math.tanh(0)", "0"),
        ("Math.asinh(0)", "0"),
        ("Math.acosh(1)", "0"),
        ("Math.atanh(0)", "0"),
        ("Math.round(Math.expm1(0))", "0"),
        ("Math.log1p(0)", "0"),
        ("Math.round(Math.LN2*1000)", "693"),
        ("Math.round(Math.LN10*1000)", "2303"),
        ("Math.round(Math.SQRT2*1000)", "1414"),
        ("Math.round(Math.SQRT1_2*1000)", "707"),
        // AbortController
        ("var c=new AbortController(); var b=c.signal.aborted; c.abort(); b+','+c.signal.aborted", "false,true"),
        // `signal.addEventListener('abort', fn)` が丸ごと no-op で、`abort()` を呼んでも
        // 登録済みリスナが一切発火しないバグだった。`signal.reason` も未対応だった。
        (
            "var c=new AbortController(); var fired=false; c.signal.addEventListener('abort', function(){fired=true;}); c.abort(); fired",
            "true",
        ),
        ("var c=new AbortController(); c.abort(); c.signal.reason.name", "AbortError"),
        ("var c=new AbortController(); c.abort('custom'); c.signal.reason", "custom"),
        // 二重 abort() は2回目以降が黙殺される（リスナが2回発火しない）。
        (
            "var c=new AbortController(); var n=0; c.signal.addEventListener('abort', function(){n++;}); c.abort(); c.abort(); n",
            "1",
        ),
        // `AbortSignal.abort(reason)`（ES2022）が、`AbortController` 経由でしか
        // signal を得られず丸ごと未対応だった。
        ("AbortSignal.abort().aborted", "true"),
        ("AbortSignal.abort('why').reason", "why"),
        ("AbortSignal.abort().reason.name", "AbortError"),
        // `DOMException`（丸ごと未対応だった。`new DOMException(message, name)`
        // というユーザーコードからの直接構築、レガシー `.code` 数値定数）。
        ("new DOMException('boom', 'NotFoundError').message", "boom"),
        ("new DOMException('boom', 'NotFoundError').name", "NotFoundError"),
        ("new DOMException('boom', 'NotFoundError').code", "8"),
        ("DOMException.NOT_FOUND_ERR", "8"),
        ("new DOMException().name", "Error"),
        ("new DOMException('x', 'CustomError').code", "0"),
        // 既存の AbortError も同じ DOMException 経路で構築されるようになった
        // （`.code` が正しく `20`＝`ABORT_ERR` になることを確認）。
        ("AbortSignal.abort().reason.code", "20"),
        // `signal.removeEventListener('abort', fn)` が `addEventListener` は対応済み
        // なのに対をなす削除側だけ無条件 no-op のままだったバグ。
        (
            "var c=new AbortController(); var n=0; var fn=function(){n++;}; c.signal.addEventListener('abort', fn); c.signal.removeEventListener('abort', fn); c.abort(); n",
            "0",
        ),
        (
            "var c=new AbortController(); var n=0; c.signal.addEventListener('abort', function(){n++;}); c.signal.removeEventListener('abort', function(){}); c.abort(); n",
            "1",
        ),
        // `AbortSignal.any(iterable)`（ES2024）— 複数の中断条件を1つの signal にまとめる。
        (
            "var c1=new AbortController(); var c2=new AbortController(); var s=AbortSignal.any([c1.signal, c2.signal]); var before=s.aborted; c2.abort('two'); before+','+s.aborted+','+s.reason",
            "false,true,two",
        ),
        (
            "var c1=new AbortController(); c1.abort('already'); AbortSignal.any([c1.signal]).reason",
            "already",
        ),
        // `signal.throwIfAborted()` が丸ごと未対応だった。中断前は no-op。
        ("var c=new AbortController(); c.signal.throwIfAborted()", "undefined"),
        // 中断後は `reason` を投げる。
        (
            "var c=new AbortController(); c.abort('boom'); \
             var caught; try { c.signal.throwIfAborted(); } catch (e) { caught = e; } caught",
            "boom",
        ),
        // `EventTarget` が丸ごと未対応だった（DOM 要素以外で独自のイベント発行/購読の
        // 基盤として使う定番パターン）。他の EventTarget 風オブジェクトと違い型ごとに
        // 複数リスナを保持する。
        (
            "var t=new EventTarget(); var log=''; t.addEventListener('x', ()=>log+='a'); t.addEventListener('x', ()=>log+='b'); t.dispatchEvent(new Event('x')); log",
            "ab",
        ),
        (
            "var t=new EventTarget(); var n=0; var fn=()=>n++; t.addEventListener('x', fn); t.addEventListener('x', fn); t.dispatchEvent(new Event('x')); n",
            "1",
        ),
        (
            "var t=new EventTarget(); var n=0; var fn=()=>n++; t.addEventListener('x', fn); t.removeEventListener('x', fn); t.dispatchEvent(new Event('x')); n",
            "0",
        ),
        // 同一関数を capture/bubble 両方で登録すると重複扱いされず2件とも
        // 保持される（仕様上 `(listener, capture)` の組で区別すべきところ、
        // 以前は `capture` を見ずに `cb` だけで重複判定していたため2回目の
        // 登録が黙って無視されるバグだった。`document`のcapture対応
        // 〔2026-07-16〕で顕在化・同日発見・修正）。
        (
            "var t=new EventTarget(); var n=0; var fn=()=>n++; t.addEventListener('x', fn, true); t.addEventListener('x', fn, false); t.dispatchEvent(new Event('x')); n",
            "2",
        ),
        // `removeEventListener(type, fn)`（capture省略＝既定false）はcapture
        // 登録済みの同一関数を巻き込んで消してはいけない。
        (
            "var t=new EventTarget(); var n=0; var fn=()=>n++; t.addEventListener('x', fn, true); t.addEventListener('x', fn, false); t.removeEventListener('x', fn); t.dispatchEvent(new Event('x')); n",
            "1",
        ),
        // `addEventListener(type, fn, {signal})`（丸ごと未対応だった。
        // `AbortController` でリスナを一括解除する定番パターン。2026-07-14
        // 発見・実装）。abort 後は発火しなくなる。
        (
            "var t=new EventTarget(); var c=new AbortController(); var n=0; \
             t.addEventListener('x', ()=>n++, {signal: c.signal}); \
             t.dispatchEvent(new Event('x')); c.abort(); t.dispatchEvent(new Event('x')); n",
            "1",
        ),
        // 登録前に既に abort 済みの signal を渡した場合は登録自体が行われない。
        (
            "var t=new EventTarget(); var c=new AbortController(); c.abort(); var n=0; \
             t.addEventListener('x', ()=>n++, {signal: c.signal}); \
             t.dispatchEvent(new Event('x')); n",
            "0",
        ),
        // DOM 要素側（`Element.prototype.addEventListener`）でも同じく対応。
        (
            "var el=document.createElement('div'); var c=new AbortController(); var n=0; \
             el.addEventListener('click', ()=>n++, {signal: c.signal}); \
             el.click(); c.abort(); el.click(); n",
            "1",
        ),
        // `event.preventDefault()` が丸ごと no-op で `defaultPrevented` を一切
        // 追跡せず、`dispatchEvent()` の戻り値が常に `true` になるバグだった。
        (
            "var t=new EventTarget(); t.addEventListener('x', e => e.preventDefault()); t.dispatchEvent(new Event('x', {cancelable:true}))",
            "false",
        ),
        (
            "var t=new EventTarget(); t.addEventListener('x', e => e.preventDefault()); t.dispatchEvent(new Event('x'))",
            "true",
        ),
        // `event.isTrusted` が丸ごと未対応だった。スクリプトから発火した
        // イベントは仕様上常に `false`。
        (
            "var t=new EventTarget(); var r; t.addEventListener('x', e => { r = e.isTrusted; }); t.dispatchEvent(new Event('x')); r",
            "false",
        ),
        // `event.composed`（丸ごと未対応だった。`Event`/`CustomEvent`両方の
        // コンストラクタで`options.composed`が一切読まれず常に`undefined`に
        // なっていた。2026-07-16 発見・実装）。
        ("new Event('x', {composed: true}).composed", "true"),
        ("new Event('x').composed", "false"),
        (
            "new CustomEvent('x', {detail: 1, composed: true}).composed",
            "true",
        ),
        // `EventTarget` のイベントに `stopImmediatePropagation` が丸ごと
        // 未対応で、呼び出すと TypeError になっていた（そもそも呼び出しようが
        // ないため残りのリスナーを止める効果も一切なかった）。
        (
            "var t=new EventTarget(); var log=''; \
             t.addEventListener('x', e => { log+='a'; e.stopImmediatePropagation(); }); \
             t.addEventListener('x', () => { log+='b'; }); \
             t.dispatchEvent(new Event('x')); log",
            "a",
        ),
        // `EventTarget.addEventListener` の第3引数 `{once:true}` が丸ごと
        // 読まれておらず、一度発火しても解除されず何度でも呼ばれ続けていた。
        (
            "var t=new EventTarget(); var n=0; t.addEventListener('x', ()=>n++, {once:true}); \
             t.dispatchEvent(new Event('x')); t.dispatchEvent(new Event('x')); n",
            "1",
        ),
        // once 指定でも removeEventListener で明示的に解除できる。
        (
            "var t=new EventTarget(); var n=0; var fn=()=>n++; t.addEventListener('x', fn, {once:true}); \
             t.removeEventListener('x', fn); t.dispatchEvent(new Event('x')); n",
            "0",
        ),
        // `EventTarget` 発の `Event`/`CustomEvent` に `composedPath()` が丸ごと
        // 未対応で、呼び出すと TypeError になっていた（DOM 要素側は既に対応済み）。
        (
            "var t=new EventTarget(); var p; t.addEventListener('x', e => { p = e.composedPath(); }); \
             t.dispatchEvent(new Event('x')); p.length === 1 && p[0] === t",
            "true",
        ),
        // 発火前（target 未設定）は composedPath() が空配列を返す。
        ("new CustomEvent('x').composedPath().length", "0"),
        // `KeyboardEvent`/`MouseEvent`（丸ごと未対応だった。`el.dispatchEvent
        // (new KeyboardEvent('keydown', {key:'a'}))` というシミュレーション
        // イベント構築の定番パターン）。
        ("new KeyboardEvent('keydown', {key:'a', code:'KeyA'}).key", "a"),
        ("new KeyboardEvent('keydown', {key:'a', code:'KeyA'}).code", "KeyA"),
        (
            "var t=new EventTarget(); var got; \
             t.addEventListener('keydown', e => { got = e.ctrlKey + ':' + e.key; }); \
             t.dispatchEvent(new KeyboardEvent('keydown', {key:'Enter', ctrlKey:true})); got",
            "true:Enter",
        ),
        ("new MouseEvent('click', {clientX:10, clientY:20}).clientX", "10"),
        (
            "var t=new EventTarget(); var got; \
             t.addEventListener('click', e => { got = e.clientY + ':' + e.button; }); \
             t.dispatchEvent(new MouseEvent('click', {clientY:5, button:2})); got",
            "5:2",
        ),
        ("new MouseEvent('click').bubbles", "false"),
        ("new MouseEvent('click', {bubbles:true}).bubbles", "true"),
        // `WheelEvent`/`FocusEvent`（丸ごと未対応だった。`MouseEvent` を継承
        // する `WheelEvent` は座標系プロパティも合わせて持つべき仕様）。
        ("new WheelEvent('wheel', {deltaY:100}).deltaY", "100"),
        ("new WheelEvent('wheel', {deltaY:1, clientX:5}).clientX", "5"),
        ("new WheelEvent('wheel').deltaMode", "0"),
        ("new FocusEvent('focusout', {relatedTarget: null}).relatedTarget === null", "true"),
        (
            "var t=new EventTarget(); var r=new EventTarget(); var got; \
             t.addEventListener('focusout', e => { got = e.relatedTarget; }); \
             t.dispatchEvent(new FocusEvent('focusout', {relatedTarget: r})); got === r",
            "true",
        ),
        // `Touch`/`TouchEvent`（丸ごと未対応だった。この処理系にはタッチ
        // スクリーン入力機構自体が無いが、コンストラクタでのシミュレーション
        // パターンには対応する。2026-07-15 発見・実装）。
        ("new Touch({identifier:1, clientX:10, clientY:20}).clientX", "10"),
        ("new Touch({}).force", "1"),
        (
            "var t=new Touch({identifier:1}); \
             new TouchEvent('touchstart', {touches:[t], changedTouches:[t]}).touches[0] === t",
            "true",
        ),
        // `CommandEvent`/`ToggleEvent`/`FormDataEvent`（WHATWG HTML Standard / Invoker Commands API）
        ("new CommandEvent('command', {command:'show-modal'}).command", "show-modal"),
        ("new CommandEvent('command', {source:null}).source === null", "true"),
        ("new ToggleEvent('toggle', {oldState:'closed', newState:'open'}).newState", "open"),
        ("new ToggleEvent('toggle').oldState", "closed"),
        ("new FormDataEvent('formdata', {formData:null}).formData === null", "true"),

        ("new TouchEvent('touchend').changedTouches.length", "0"),
        // `HashChangeEvent`/`PageTransitionEvent`（丸ごと未対応だった。
        // 2026-07-15 発見・実装）。
        (
            "new HashChangeEvent('hashchange', {oldURL:'a', newURL:'b'}).oldURL + ',' + \
             new HashChangeEvent('hashchange', {oldURL:'a', newURL:'b'}).newURL",
            "a,b",
        ),
        (
            "new HashChangeEvent('hashchange').type",
            "hashchange",
        ),
        (
            "new PageTransitionEvent('pageshow', {persisted:true}).persisted",
            "true",
        ),
        // `PopStateEvent`（丸ごと未対応だった。実ナビゲーション経由の発火は
        // 既に`state`付きで動いていたが、手動シミュレーション用の専用
        // コンストラクタが無かった。2026-07-17 発見・実装）。
        (
            "new PopStateEvent('popstate', {state:{a:1}}).state.a",
            "1",
        ),
        ("new PopStateEvent('popstate').state", "null"),
        (
            "var got=null; window.addEventListener('popstate', e => got = e.state); \
             window.dispatchEvent(new PopStateEvent('popstate', {state:'s'})); got",
            "s",
        ),
        // `DOMRect`/`DOMRectReadOnly`コンストラクタ（丸ごと未対応だった。
        // `getBoundingClientRect()`と同じ形状で手動構築する定番パターン。
        // 2026-07-17 発見・実装）。
        (
            "var r=new DOMRect(10,20,30,40); \
             [r.x,r.y,r.width,r.height,r.left,r.top,r.right,r.bottom].join(',')",
            "10,20,30,40,10,20,40,60",
        ),
        ("new DOMRect().width", "0"),
        ("new DOMRectReadOnly(1,2,3,4).right", "4"),
        ("JSON.stringify(new DOMRect(1,2,3,4).toJSON()).includes('\"width\":3')", "true"),
        // `DOMPoint`/`DOMPointReadOnly`コンストラクタおよび DOMMatrix/DOMQuad (Geometry Interfaces)
        (
            "var p=new DOMPoint(1,2); p.x+','+p.y+','+p.z+','+p.w",
            "1,2,0,1",
        ),
        ("new DOMPoint(1,2,3,4).w", "4"),
        ("new DOMPointReadOnly().x", "0"),
        ("JSON.stringify(new DOMPoint(1,2).toJSON()).includes('\"y\":2')", "true"),
        ("new DOMPoint(10, 20).matrixTransform(new DOMMatrix().translate(5, 5)).x", "15"),
        ("new DOMMatrix().isIdentity", "true"),
        ("new DOMMatrix().is2D", "true"),
        ("new DOMMatrix([1,0,0,1,10,20]).toString()", "matrix(1, 0, 0, 1, 10, 20)"),
        ("new DOMMatrix().translate(10, 20).e", "10"),
        ("new DOMMatrix().scale(2, 3).d", "3"),
        ("DOMMatrix.fromFloat32Array(new Float32Array([1,0,0,1,10,20])).e", "10"),
        ("new DOMMatrix().rotate(90).b", "1"),
        ("new DOMMatrix([1,0,0,1,10,20]).invert().e", "-10"),
        ("new DOMMatrix().translateSelf(10, 20).e", "10"),
        ("new DOMMatrix().rotateSelf(90).b", "1"),
        ("new DOMMatrix().scaleSelf(2, 3).d", "3"),
        ("new DOMMatrix([1,0,0,1,10,20]).invertSelf().e", "-10"),
        ("DOMQuad.fromRect(new DOMRect(10, 20, 30, 40)).getBounds().width", "30"),
        ("DOMRect.fromRect({x: 5, y: 10, width: 15, height: 20}).width", "15"),
        ("DOMPoint.fromPoint({x: 3, y: 4, z: 5, w: 1}).z", "5"),
        ("'가'.normalize('NFD').normalize('NFC')", "가"),

        // `window.dispatchEvent(event)`（丸ごと未対応だった。前サイクルで
        // 発見した既知ギャップを本サイクルで解消。2026-07-15 発見・実装）。
        (
            "var got=null; window.addEventListener('hashchange', e => got = e.newURL); \
             window.dispatchEvent(new HashChangeEvent('hashchange', {newURL:'x'})); got",
            "x",
        ),
        (
            "window.dispatchEvent(new Event('unknown-type'))",
            "true",
        ),
        // `window.dispatchEvent()` は `addEventListener` 登録分だけでなく
        // `window.on<type>`（IDL属性スタイル）も合わせて呼び出す（丸ごと
        // 未対応だった。2026-07-15 発見・実装）。
        (
            "var n=0; window.onhashchange = () => n++; \
             window.dispatchEvent(new HashChangeEvent('hashchange')); n",
            "1",
        ),
        (
            "var order=[]; window.onresize = () => order.push('on'); \
             window.addEventListener('resize', () => order.push('listener')); \
             window.dispatchEvent(new Event('resize')); order.join(',')",
            "on,listener",
        ),
        // `window.removeEventListener()`（丸ごと未対応だった。以前は無害な
        // no-op のままで、`AbortSignal` 経由以外ではリスナが二度と解除
        // できなかった。2026-07-15 発見・実装）。
        (
            "var n=0; var cb = () => n++; window.addEventListener('resize', cb); \
             window.removeEventListener('resize', cb); \
             window.dispatchEvent(new Event('resize')); n",
            "0",
        ),
        (
            "var log=[]; var cb1 = () => log.push('1'); var cb2 = () => log.push('2'); \
             window.addEventListener('resize', cb1); window.addEventListener('resize', cb2); \
             window.removeEventListener('resize', cb1); \
             window.dispatchEvent(new Event('resize')); log.join(',')",
            "2",
        ),
        // `document.removeEventListener()`（丸ごと未対応だった。`addEventListener`
        // は `window` 版を再利用していたが、対になる `removeEventListener`
        // 自体が未登録で「関数ではない」`TypeError` になっていた。2026-07-15
        // 発見・実装）。
        (
            "typeof document.removeEventListener",
            "function",
        ),
        (
            "var n=0; var cb = () => n++; document.addEventListener('hashchange', cb); \
             document.removeEventListener('hashchange', cb); \
             window.dispatchEvent(new Event('hashchange')); n",
            "0",
        ),
        // `document.dispatchEvent`（丸ごと未対応だった。`addEventListener`/
        // `removeEventListener`と同じ兄弟ギャップ。2026-07-15 発見・実装）。
        (
            "var got=null; document.addEventListener('hashchange', e => got = e.newURL); \
             document.dispatchEvent(new HashChangeEvent('hashchange', {newURL:'y'})); got",
            "y",
        ),
        // `window.dispatchEvent()`/`document.dispatchEvent()` の戻り値が仕様
        // どおり `!defaultPrevented` になること（以前は無条件 `true` を返し、
        // リスナが `preventDefault()` を呼んでも常に `true` だった。要素用
        // `dom_dispatch_event`/`event_target_dispatch_event` は正しく実装済みで
        // window/document 経路にだけ同型バグが残っていた。2026-07-16 発見・修正）。
        (
            "window.addEventListener('resize', e => e.preventDefault()); \
             window.dispatchEvent(new Event('resize', {cancelable:true}))",
            "false",
        ),
        (
            "document.addEventListener('scroll', e => e.preventDefault()); \
             document.dispatchEvent(new Event('scroll', {cancelable:true}))",
            "false",
        ),
        // `preventDefault()` を呼ばなければ従来どおり `true` を返す。
        (
            "window.addEventListener('popstate', () => {}); \
             window.dispatchEvent(new Event('popstate'))",
            "true",
        ),
        // dispatch 中に `event.target` が dispatch 対象へ設定されること（以前は
        // window/document 経路では一切設定されず `undefined` だった。2026-07-16
        // 発見・修正）。
        (
            "var t='none'; window.addEventListener('message', e => t = (e.target === window)); \
             window.dispatchEvent(new Event('message')); t",
            "true",
        ),
        // `window.dispatchEvent(new ErrorEvent(...))` 経由でも `window.onerror`
        // がレガシー5引数シグネチャ `(message, source, lineno, colno, error)` で
        // 呼ばれること（以前は Event オブジェクトを1引数でそのまま渡していて
        // `reportError()`〔既に正しい5引数呼び出し〕と経路によって呼び出し形が
        // 食い違っていた。2026-07-16 発見・修正）。
        (
            "var got=''; window.onerror = (msg, src, line, col) => { got = msg+'|'+src+'|'+line+'|'+col; }; \
             window.dispatchEvent(new ErrorEvent('error', {message:'boom', filename:'a.js', lineno:3, colno:7})); got",
            "boom|a.js|3|7",
        ),
        // `online`/`offline`（丸ごと未対応だった。`addEventListener('online',
        // ...)` が登録経路自体無く黙って何もしなかった。2026-07-16 発見・実装）。
        (
            "var n=0; window.addEventListener('online', () => n++); \
             window.dispatchEvent(new Event('online')); n",
            "1",
        ),
        (
            "var n=0; var cb = () => n++; window.addEventListener('offline', cb); \
             window.removeEventListener('offline', cb); \
             window.dispatchEvent(new Event('offline')); n",
            "0",
        ),
        // `beforeunload`/`unload`/`pageshow`/`pagehide`/`visibilitychange`/
        // `languagechange`（丸ごと未対応だった。2026-07-16 発見・実装）。
        (
            "var log=[]; \
             window.addEventListener('beforeunload', () => log.push('bu')); \
             window.addEventListener('unload', () => log.push('u')); \
             window.addEventListener('pageshow', () => log.push('ps')); \
             window.addEventListener('pagehide', () => log.push('ph')); \
             document.addEventListener('visibilitychange', () => log.push('vc')); \
             window.addEventListener('languagechange', () => log.push('lc')); \
             window.dispatchEvent(new Event('beforeunload')); \
             window.dispatchEvent(new Event('unload')); \
             window.dispatchEvent(new Event('pageshow')); \
             window.dispatchEvent(new Event('pagehide')); \
             document.dispatchEvent(new Event('visibilitychange')); \
             window.dispatchEvent(new Event('languagechange')); \
             log.join(',')",
            "bu,u,ps,ph,vc,lc",
        ),
        // `document.visibilityState`/`.hidden`（丸ごと未対応だった。2026-07-16
        // 発見・実装）。
        ("document.visibilityState", "visible"),
        ("document.hidden", "false"),
        // `document.characterSet`/`.compatMode`/`.contentType`/`.doctype`
        // （丸ごと未対応だった。2026-07-16 発見・実装）。
        ("document.characterSet", "UTF-8"),
        ("document.compatMode", "CSS1Compat"),
        ("document.contentType", "text/html"),
        ("document.doctype", "null"),
        // `document.currentScript`（丸ごと未対応だった。2026-07-16 発見・
        // 実装。実行中スクリプト要素の追跡機構が無いため常に `null` を返す
        // 誠実な簡略実装）。
        ("document.currentScript", "null"),
        // `document.implementation`（`DOMImplementation`。丸ごと未対応
        // だった。2026-07-16 発見・実装。`hasFeature()`は仕様どおり常に
        // `true`を返すレガシー no-op、`createDocumentType()`は独立した
        // 読み取り専用簡略オブジェクトを返す）。
        ("document.implementation.hasFeature('x','1.0')", "true"),
        (
            "var dt=document.implementation.createDocumentType('html',' ',''); dt.name+','+dt.nodeType",
            "html,10",
        ),
        (
            "var doc=document.implementation.createHTMLDocument('MyDoc'); doc.title+','+doc.nodeType",
            "MyDoc,9",
        ),
        (
            "var doc=document.implementation.createDocument('http://www.w3.org/1999/xhtml','html'); doc.qualifiedName+','+doc.nodeType",
            "html,9",
        ),
        // `storage` イベント（丸ごと未対応だった。`StorageEvent` コンストラクタ
        // 自体は既に対応済みだったが登録経路が無かった。2026-07-16 発見・実装）。
        (
            "var got=null; window.addEventListener('storage', e => got = e.key); \
             window.dispatchEvent(new StorageEvent('storage', {key:'k'})); got",
            "k",
        ),
        // `document.addEventListener('readystatechange', ...)`（丸ごと未対応
        // だった。`document.readyState` は常に `"complete"` のため
        // `load`/`DOMContentLoaded` と同じ即時発火。2026-07-16 発見・実装）。
        (
            "var n=0; document.addEventListener('readystatechange', () => n++); n",
            "1",
        ),
        // `window.print()`/`beforeprint`/`afterprint`（丸ごと未対応だった。
        // 2026-07-16 発見・実装）。
        ("window.print(); true", "true"),
        (
            "var log=[]; \
             window.addEventListener('beforeprint', () => log.push('bp')); \
             window.addEventListener('afterprint', () => log.push('ap')); \
             window.dispatchEvent(new Event('beforeprint')); \
             window.dispatchEvent(new Event('afterprint')); \
             log.join(',')",
            "bp,ap",
        ),
        // `PointerEvent`/`InputEvent`（丸ごと未対応だった。`PointerEvent` は
        // `MouseEvent` を継承するため座標系プロパティも合わせて持つべき仕様）。
        ("new PointerEvent('pointerdown', {pointerId:7, pointerType:'touch'}).pointerId", "7"),
        ("new PointerEvent('pointerdown', {pointerType:'touch', clientX:9}).clientX", "9"),
        ("new PointerEvent('pointerdown').isPrimary", "false"),
        ("new PointerEvent('pointerdown', {isPrimary:true}).width", "1"),
        ("new InputEvent('input', {data:'a', inputType:'insertText'}).data", "a"),
        ("new InputEvent('input', {data:'a', inputType:'insertText'}).inputType", "insertText"),
        ("new InputEvent('beforeinput').isComposing", "false"),
        // `setPointerCapture`/`releasePointerCapture`/`hasPointerCapture`
        // （Pointer Events。丸ごと未対応だった）。
        (
            "var e=document.createElement('div'); e.hasPointerCapture(1)",
            "false",
        ),
        (
            "var e=document.createElement('div'); e.setPointerCapture(1); e.hasPointerCapture(1)",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.setPointerCapture(1); \
             e.releasePointerCapture(1); e.hasPointerCapture(1)",
            "false",
        ),
        // 別 pointerId には影響しない。
        (
            "var e=document.createElement('div'); e.setPointerCapture(1); e.hasPointerCapture(2)",
            "false",
        ),
        // `ProgressEvent`/`StorageEvent`（丸ごと未対応だった）。
        ("new ProgressEvent('progress', {loaded:50, total:100}).loaded", "50"),
        ("new ProgressEvent('progress', {lengthComputable:true}).lengthComputable", "true"),
        ("new ProgressEvent('progress').total", "0"),
        ("new StorageEvent('storage', {key:'k', newValue:'v'}).key", "k"),
        ("new StorageEvent('storage', {key:'k', newValue:'v'}).newValue", "v"),
        ("new StorageEvent('storage').oldValue === null", "true"),
        // `CompositionEvent`/`ClipboardEvent`（丸ごと未対応だった）。
        ("new CompositionEvent('compositionupdate', {data:'あ'}).data", "あ"),
        ("new CompositionEvent('compositionstart').data", ""),
        (
            "var t=new EventTarget(); var got; \
             t.addEventListener('paste', e => { got = e.clipboardData; }); \
             t.dispatchEvent(new ClipboardEvent('paste', {clipboardData:'X'})); got",
            "X",
        ),
        ("new ClipboardEvent('copy').clipboardData === null", "true"),
        // `AnimationEvent`/`TransitionEvent`/`DragEvent`/`SubmitEvent`（丸ごと
        // 未対応だった。`DragEvent` は `MouseEvent` を継承するため座標系
        // プロパティも合わせて持つべき仕様）。
        ("new AnimationEvent('animationend', {animationName:'spin'}).animationName", "spin"),
        ("new AnimationEvent('animationend').elapsedTime", "0"),
        ("new TransitionEvent('transitionend', {propertyName:'opacity'}).propertyName", "opacity"),
        ("new DragEvent('drop', {dataTransfer:'X'}).dataTransfer", "X"),
        ("new DragEvent('drop', {clientX:3}).clientX", "3"),
        ("new SubmitEvent('submit', {submitter:'BTN'}).submitter", "BTN"),
        ("new SubmitEvent('submit').submitter === null", "true"),
        // `MessageEvent`/`ErrorEvent`（丸ごと未対応だった。`window.
        // postMessage()`/`reportError()` の内部イベント形と同じ形をユーザー
        // コードから直接構築できる）。
        ("new MessageEvent('message', {data:'hi', origin:'https://a.com'}).data", "hi"),
        ("new MessageEvent('message', {data:'hi', origin:'https://a.com'}).origin", "https://a.com"),
        ("new MessageEvent('message').ports.length", "0"),
        ("new ErrorEvent('error', {message:'boom', lineno:5}).message", "boom"),
        ("new ErrorEvent('error', {message:'boom', lineno:5}).lineno", "5"),
        ("new ErrorEvent('error').error === null", "true"),
        // `EventTarget` 発のイベントで `currentTarget`/`eventPhase` が丸ごと
        // 未設定で常に undefined だった（DOM 要素側は既に対応済み）。
        (
            "var t=new EventTarget(); var ct, ph; \
             t.addEventListener('x', e => { ct = e.currentTarget; ph = e.eventPhase; }); \
             t.dispatchEvent(new Event('x')); ct === t && ph === 2",
            "true",
        ),
        // 発火完了後は currentTarget が null、eventPhase が 0 に戻る。
        (
            "var t=new EventTarget(); var e=new Event('x'); t.dispatchEvent(e); \
             e.currentTarget === null && e.eventPhase",
            "0",
        ),
        // `Event.timeStamp` がこのエンジン全体に丸ごと未対応で常に undefined
        // だった（DOM要素・EventTarget どちらの経路でも欠落していた）。
        ("typeof new Event('x').timeStamp", "number"),
        (
            "var b=document.createElement('button'); var ts; \
             b.addEventListener('click', e => { ts = e.timeStamp; }); \
             b.dispatchEvent({type:'click'}); typeof ts",
            "number",
        ),
        // レガシー DOM Level 0 の `returnValue`/`cancelBubble`/`srcElement` が
        // 丸ごと未対応だった。`e.returnValue = false` は `preventDefault()` と
        // 等価であるべき。
        (
            "var t=new EventTarget(); var r; \
             t.addEventListener('x', e => { e.returnValue = false; }); \
             r = t.dispatchEvent(new Event('x', {cancelable:true})); r",
            "false",
        ),
        // `e.cancelBubble = true` は `stopPropagation()` と等価であるべき。
        (
            "var b=document.createElement('button'); var p=document.createElement('div'); \
             p.appendChild(b); var s=''; \
             p.addEventListener('click', ()=>s+='P'); \
             b.addEventListener('click', e => { s+='B'; e.cancelBubble = true; }); \
             b.dispatchEvent({type:'click', bubbles:true}); s",
            "B",
        ),
        // `srcElement` は `target` と同じ値の別名。
        (
            "var t=new EventTarget(); var se; \
             t.addEventListener('x', e => { se = e.srcElement; }); \
             t.dispatchEvent(new Event('x')); se === t",
            "true",
        ),
        // `Event.NONE`/`.CAPTURING_PHASE`/`.AT_TARGET`/`.BUBBLING_PHASE`
        // （`Node.ELEMENT_NODE`と同型の標準定数）が丸ごと未対応だった。
        (
            "Event.NONE + ',' + Event.CAPTURING_PHASE + ',' + Event.AT_TARGET + ',' + Event.BUBBLING_PHASE",
            "0,1,2,3",
        ),
        (
            "var t=new EventTarget(); var ph; \
             t.addEventListener('x', e => { ph = e.eventPhase === Event.AT_TARGET; }); \
             t.dispatchEvent(new Event('x')); ph",
            "true",
        ),
        // `form.requestSubmit()`/`form.submit()`（HTML5）が丸ごと未対応だった。
        // `requestSubmit()` は `submit` イベントを発火する。
        (
            "var f=document.createElement('form'); var n=0; \
             f.addEventListener('submit', ()=>n++); f.requestSubmit(); n",
            "1",
        ),
        // `preventDefault()` で中止可能。
        (
            "var f=document.createElement('form'); \
             f.addEventListener('submit', e=>e.preventDefault()); \
             typeof f.requestSubmit()",
            "undefined",
        ),
        // `submit()` は無害な no-op（実際のフォーム送信/ページ遷移パイプラインが
        // 無いため）で、少なくとも例外を投げない。
        ("var f=document.createElement('form'); f.submit(); true", "true"),
        // `input.showPicker()`（丸ごと未対応だった。ネイティブピッカー UI 自体が
        // 無いため `submit()` と同じ無害な no-op。2026-07-15 発見・実装）。
        (
            "var i=document.createElement('input'); i.type='date'; i.showPicker(); true",
            "true",
        ),
        // `input.stepUp(n?)`/`.stepDown(n?)`（HTML5）が丸ごと未対応だった。
        (
            "var i=document.createElement('input'); i.type='number'; i.value='5'; \
             i.stepUp(); i.value",
            "6",
        ),
        ("var i=document.createElement('input'); i.type='number'; i.value='5'; i.stepDown(3); i.value", "2"),
        // `step` 属性を刻み幅として使う。
        (
            "var i=document.createElement('input'); i.type='number'; i.value='0'; i.step='0.5'; \
             i.stepUp(); i.value",
            "0.5",
        ),
        // `max` があればクランプする。
        (
            "var i=document.createElement('input'); i.type='number'; i.value='9'; i.max='10'; \
             i.stepUp(5); i.value",
            "10",
        ),
        // String / Array 静的・console・globalThis
        ("String.fromCharCode(72,105)", "Hi"),
        ("String.fromCodePoint(65)", "A"),
        ("Array.of(1,2,3).join(',')", "1,2,3"),
        // Array イテレータ系 + reduceRight
        ("[...[10,20].keys()].join(',')", "0,1"),
        ("[...[10,20].values()].join(',')", "10,20"),
        // entries() は本物の Array Iterator（.map 等の Array メソッドは持たない。仕様どおり）
        // を返すため、配列メソッドを使うにはまず spread/Array.from で配列化する必要がある。
        ("[...[5,6].entries()].map(e => e[0]+':'+e[1]).join(',')", "0:5,1:6"),
        ("[1,2,3].reduceRight((a,b) => a+'-'+b)", "3-2-1"),
        ("[1,2,3,4].reduceRight((a,b) => a+b, 0)", "10"),
        // document.title 読み書き
        ("document.title = 'AtmOS'; document.title", "AtmOS"),
        ("document.readyState", "complete"),
        // `document.compatMode`/`.characterSet`/`.charset`/`.contentType`/
        // `.scrollingElement`（HTML5。丸ごと未対応だった）。
        ("document.compatMode", "CSS1Compat"),
        ("document.characterSet", "UTF-8"),
        ("document.charset", "UTF-8"),
        ("document.contentType", "text/html"),
        ("document.scrollingElement === document.documentElement", "true"),
        // `document.children`/`.firstElementChild`/`.lastElementChild`/
        // `.childElementCount`（`ParentNode`ミックスインの`Document`側配線
        // 漏れ。丸ごと未対応だった。2026-07-17 発見・実装。この配列は
        // bare `JsRuntime::new()` で `<html>` 自体が未構築のため、実際の
        // 検証は `dom_cases`（HTML フィクスチャ付き）側で行う）。
        ("document.firstElementChild === document.documentElement", "true"),
        ("document.lastElementChild === document.documentElement", "true"),
        ("document.children.length", "0"),
        ("document.childElementCount", "0"),
        // `document.referrer`/`.lastModified`/`.domain`（HTML5。丸ごと未対応
        // だった）。
        ("document.referrer", ""),
        (
            "/^\\d{2}\\/\\d{2}\\/\\d{4} \\d{2}:\\d{2}:\\d{2}$/.test(document.lastModified)",
            "true",
        ),
        ("typeof document.domain", "string"),
        // `navigator.geolocation`（丸ごと未対応だった。実ハードウェアが無いため
        // 常に `PERMISSION_DENIED` で `error` コールバックを同期的に呼ぶ簡略実装）。
        ("typeof navigator.geolocation.getCurrentPosition", "function"),
        (
            "var code; navigator.geolocation.getCurrentPosition(() => {}, e => { code = e.code; }); \
             code === 1",
            "true",
        ),
        (
            "typeof navigator.geolocation.watchPosition(() => {}, () => {})",
            "number",
        ),
        ("typeof navigator.geolocation.clearWatch(1)", "undefined"),
        // `navigator.wakeLock.request(type)`（Screen Wake Lock API。丸ごと
        // 未対応だった。実際の電源管理機構は無いため状態のみ追跡する簡略実装）。
        (
            "(await navigator.wakeLock.request('screen')).released",
            "false",
        ),
        ("(await navigator.wakeLock.request('screen')).type", "screen"),
        (
            "var s = await navigator.wakeLock.request('screen'); await s.release(); s.released",
            "true",
        ),
        // `navigator.share(data)`/`navigator.canShare(data)`（Web Share API。
        // 丸ごと未対応だった。実際の共有先 UI が無いため `canShare` は常に
        // `false`、`share` は仕様どおり `AbortError` で拒否する）。
        ("navigator.canShare({title:'x'})", "false"),
        (
            "try { await navigator.share({title:'x'}); 'resolved' } \
             catch(e) { e.name }",
            "AbortError",
        ),
        // `new EyeDropper().open()`（丸ごと未対応だった。実際のピッカー UI が
        // 無いため、ユーザーがキャンセルした場合と同じ `AbortError` で拒否）。
        (
            "try { await new EyeDropper().open(); 'resolved' } \
             catch(e) { e.name }",
            "AbortError",
        ),
        // `navigator.vibrate(pattern)`（Vibration API。丸ごと未対応だった。
        // 戻り値はリクエスト受理の可否のみを表しハードウェアの有無とは
        // 無関係なため、常に `true`）。
        ("navigator.vibrate(200)", "true"),
        ("navigator.vibrate([100,50,100])", "true"),
        // `navigator.getBattery()`（Battery Status API。丸ごと未対応だった。
        // バッテリー非搭載・常時 AC 電源動作というこの OS のターゲット
        // 実態に即した「常時満充電で給電中」を返す簡略実装）。
        ("(await navigator.getBattery()).charging", "true"),
        ("(await navigator.getBattery()).level", "1"),
        ("(await navigator.getBattery()).chargingTime", "0"),
        // `navigator.connection`（Network Information API。丸ごと未対応
        // だった。実測機構は無いため一般的なブロードバンド相当の代表値を返す
        // 簡略実装）。
        ("navigator.connection.saveData", "false"),
        ("navigator.connection.effectiveType", "4g"),
        ("typeof navigator.connection.downlink", "number"),
        // `navigator.locks.request(name, callback)`（Web Locks API。丸ごと
        // 未対応だった。複数タブ間の実際の排他機構が無いため、コールバックを
        // 即座に同期呼び出しし戻り値で解決する簡略実装。2026-07-15 発見・実装）。
        ("await navigator.locks.request('x', lock => lock.name)", "x"),
        ("await navigator.locks.request('x', lock => lock.mode)", "exclusive"),
        (
            "var ran=false; await navigator.locks.request('x', () => { ran=true; }); ran",
            "true",
        ),
        ("(await navigator.locks.query()).held.length", "0"),
        // Storage Access API（`document.hasStorageAccess()`/
        // `.requestStorageAccess()`。丸ごと未対応だった。サードパーティ
        // Cookie 分離機構自体が無いため常に成功する簡略実装）。
        ("await document.hasStorageAccess()", "true"),
        ("typeof await document.requestStorageAccess()", "undefined"),
        // `navigator.clipboard.write(items)`/`.read()`（`ClipboardItem` 配列版。
        // 丸ごと未対応だった。`text/plain` エントリのみ対応する簡略実装で、
        // `writeText`/`readText` と同じ内部状態を共有する）。
        (
            "await navigator.clipboard.write([new ClipboardItem({'text/plain': \
             new Blob(['hello-clip'], {type:'text/plain'})})]); \
             await navigator.clipboard.readText()",
            "hello-clip",
        ),
        (
            "await navigator.clipboard.writeText('via-text'); \
             (await navigator.clipboard.read())[0].types[0]",
            "text/plain",
        ),
        (
            "await navigator.clipboard.writeText('via-text2'); \
             var items = await navigator.clipboard.read(); \
             var blob = await items[0].getType('text/plain'); await blob.text()",
            "via-text2",
        ),
        // `navigator.permissions.query({name})`（丸ごと未対応だった。`geolocation`
        // は常に `PERMISSION_DENIED` を返す実装と、`notifications` は
        // `Notification.permission === 'granted'` と、それぞれ整合させる）。
        (
            "(await navigator.permissions.query({name:'geolocation'})).state",
            "denied",
        ),
        (
            "(await navigator.permissions.query({name:'notifications'})).state",
            "granted",
        ),
        (
            "(await navigator.permissions.query({name:'camera'})).state",
            "denied",
        ),
        // IntersectionObserver（コールバック即時発火・isIntersecting=true）
        ("var seen=false; var io=new IntersectionObserver(entries => { seen=entries[0].isIntersecting; }); io.observe(document.body); seen", "true"),
        // `IntersectionObserverEntry` の `boundingClientRect`/`intersectionRect`/
        // `rootBounds`/`time`（丸ごと未対応だった。2026-07-16 発見・実装）。
        (
            "var e=null; var io=new IntersectionObserver(entries => { e=entries[0]; }); \
             io.observe(document.body); \
             typeof e.boundingClientRect.width + ',' + \
             (e.intersectionRect === e.boundingClientRect ? 'same' : 'diff') + ',' + \
             (e.rootBounds === null) + ',' + (typeof e.time)",
            "number,same,true,number",
        ),
        // `IntersectionObserver`のコンストラクタ第2引数`options`
        // （`root`/`rootMargin`/`threshold`）が丸ごと無視されており、対応
        // する`.root`/`.rootMargin`/`.thresholds`読み取り専用プロパティも
        // 存在しなかった（丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "var io=new IntersectionObserver(()=>{}); \
             (io.root===null)+','+io.rootMargin+','+io.thresholds.join(',')",
            "true,0px 0px 0px 0px,0",
        ),
        (
            "var r=document.body; \
             var io=new IntersectionObserver(()=>{}, {root:r, rootMargin:'10px', threshold:0.5}); \
             (io.root===r)+','+io.rootMargin+','+io.thresholds.join(',')",
            "true,10px,0.5",
        ),
        (
            "var io=new IntersectionObserver(()=>{}, {threshold:[0,0.25,1]}); io.thresholds.join(',')",
            "0,0.25,1",
        ),
        // `ResizeObserverEntry.contentRect` が常に 0/0/0/0 固定だったバグと、
        // `borderBoxSize`/`contentBoxSize`（丸ごと未対応だった）を修正・追加。
        // 2026-07-16 発見・実装。
        (
            "var e=null; var ro=new ResizeObserver(entries => { e=entries[0]; }); \
             ro.observe(document.createElement('div')); \
             typeof e.contentRect.width + ',' + \
             Array.isArray(e.borderBoxSize) + ',' + \
             typeof e.borderBoxSize[0].inlineSize + ',' + \
             Array.isArray(e.contentBoxSize) + ',' + \
             typeof e.contentBoxSize[0].blockSize",
            "number,true,number,true,number",
        ),
        // `ResizeObserverEntry.devicePixelContentBoxSize`が丸ごと未対応
        // だった（`borderBoxSize`/`contentBoxSize`のみ対応済みで漏れて
        // いた。2026-07-17 発見・実装。`devicePixelRatio`が常に`1.0`固定
        // のため数値上は`contentBoxSize`と同一になる簡略実装）。
        (
            "var e=null; var ro=new ResizeObserver(entries => { e=entries[0]; }); \
             ro.observe(document.createElement('div')); \
             Array.isArray(e.devicePixelContentBoxSize) + ',' + \
             typeof e.devicePixelContentBoxSize[0].inlineSize",
            "true,number",
        ),
        // window.matchMedia（max-width 判定）
        ("window.matchMedia('(max-width: 9999px)').matches", "true"),
        ("window.matchMedia('(max-width: 0px)').matches", "false"),
        ("window.matchMedia('(min-width: 1px)').matches", "true"),
        // `window.matchMedia()` が `max-width`/`min-width` しか判定できず、CSS 側の
        // `@media` 評価（`prefers-color-scheme` 等）と食い違う非対称なバグだった。
        // 同じ判定ロジックへ統一した後の確認（既定は light テーマ）。
        ("window.matchMedia('(prefers-color-scheme: light)').matches", "true"),
        ("window.matchMedia('(prefers-color-scheme: dark)').matches", "false"),
        // window.scrollY / scrollTo
        ("typeof scrollY", "number"),
        ("scrollTo({top:100}); scrollY", "0"),
        // window.addEventListener load → 即時コールバック
        ("var loaded=false; window.addEventListener('load', () => { loaded=true; }); loaded", "true"),
        // `document.addEventListener('DOMContentLoaded', fn)` が丸ごと no-op だった
        // バグ（`window` 版は既に即時発火していたが `document` 側の配線が漏れていた）。
        // `window` 版よりもむしろよく使われる定番パターン。
        (
            "var ready=false; document.addEventListener('DOMContentLoaded', () => { ready=true; }); ready",
            "true",
        ),
        // `input.checked`（チェックボックス/ラジオボタンの選択状態）が JS プロパティとして
        // 丸ごと未実装で、`checkbox.checked`/`checkbox.checked = true` が常に
        // `undefined`/黙殺になっていた。
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.checked",
            "false",
        ),
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.checked=true; c.checked",
            "true",
        ),
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.checked=true; c.checked=false; c.checked",
            "false",
        ),
        // `input.files`（`<input type="file">`のFileList。丸ごと未対応
        // だった。2026-07-17 発見・実装。実際のファイルピッカーUIが無い
        // ため常に空配列を返す誠実な簡略実装）。
        (
            "var f=document.createElement('input'); f.type='file'; f.files.length",
            "0",
        ),
        (
            "var f=document.createElement('input'); f.type='text'; f.files",
            "undefined",
        ),
        // `input[type=file].value`はセキュリティ上重要な仕様（`value`content
        // 属性は常に無視/未反映で、選択済みファイルが無ければ常に空文字列を
        // 返すべき）だが、以前は汎用の属性直結フォールバックに落ちており、
        // `<input type="file" value="...">`の属性値がそのまま漏れる
        // 静かなバグだった。
        (
            "var f=document.createElement('input'); f.type='file'; \
             f.setAttribute('value','c:\\\\secret.txt'); f.value",
            "",
        ),
        (
            "var f=document.createElement('input'); f.type='file'; f.value='x'; f.value",
            "",
        ),
        // `a`/`area`要素のURL分解プロパティ（`URLUtils`ミックスイン。
        // `.protocol`/`.host`/`.hostname`/`.port`/`.pathname`/`.search`/
        // `.hash`/`.origin`）が丸ごと未対応だった（`location`/`URL`は
        // 既に対応済みだったが`<a>`側への配線漏れ。2026-07-17 発見・実装）。
        (
            "var a=document.createElement('a'); a.href='https://sub.example.org:8080/x/y?z=1#top'; \
             [a.protocol,a.host,a.hostname,a.port,a.pathname,a.search,a.hash,a.origin].join('|')",
            "https:|sub.example.org:8080|sub.example.org|8080|/x/y|?z=1|#top|https://sub.example.org:8080",
        ),
        (
            "var a=document.createElement('area'); a.href='http://x.com/'; a.protocol",
            "http:",
        ),
        // `checkbox.indeterminate`（不確定表示状態。HTML 属性としては反映されない
        // JS 専用プロパティ）が丸ごと未対応だった。
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.indeterminate",
            "false",
        ),
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.indeterminate=true; c.indeterminate",
            "true",
        ),
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.indeterminate=true; c.hasAttribute('indeterminate')",
            "false",
        ),
        // `input`/`textarea.selectionStart`/`.selectionEnd`/
        // `.selectionDirection`/`textarea.textLength`（丸ごと未対応
        // だった。2026-07-17 発見・実装。実際のキャレット機構が無いため
        // 状態追跡のみの簡略実装。未設定時は仕様どおり`0`/`"none"`）。
        (
            "var i=document.createElement('input'); i.selectionStart + ',' + i.selectionEnd + ',' + i.selectionDirection",
            "0,0,none",
        ),
        (
            "var i=document.createElement('input'); i.selectionStart=2; i.selectionEnd=5; i.selectionDirection='forward'; \
             i.selectionStart + ',' + i.selectionEnd + ',' + i.selectionDirection",
            "2,5,forward",
        ),
        (
            "var t=document.createElement('textarea'); t.value='hello'; t.textLength",
            "5",
        ),
        // `setSelectionRange`/`setRangeText`（丸ごと未対応だった。
        // `selectionStart`等と対になる操作メソッド。2026-07-17 発見・
        // 実装）。
        (
            "var i=document.createElement('input'); i.setSelectionRange(1,3,'forward'); \
             i.selectionStart + ',' + i.selectionEnd + ',' + i.selectionDirection",
            "1,3,forward",
        ),
        (
            "var i=document.createElement('input'); i.value='hello world'; \
             i.setRangeText('there', 6, 11); i.value",
            "hello there",
        ),
        (
            "var i=document.createElement('input'); i.value='hello world'; \
             i.setRangeText('there', 6, 11, 'select'); \
             i.value + '|' + i.selectionStart + ',' + i.selectionEnd",
            "hello there|6,11",
        ),
        (
            "var i=document.createElement('input'); i.value='hello world'; \
             i.selectionStart=0; i.selectionEnd=5; i.setRangeText('hi'); i.value",
            "hi world",
        ),
        // `checkbox.click()` は仕様上、リスナ実行前に自身の `checked` を切り替える。
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.click(); c.checked",
            "true",
        ),
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.click(); c.click(); c.checked",
            "false",
        ),
        (
            "var r=document.createElement('input'); r.type='radio'; r.click(); r.checked",
            "true",
        ),
        // `node.ownerDocument`（`element.ownerDocument.createElement(...)` という
        // 定番イディオムで使われる）が丸ごと未対応だった。
        (
            "document.createElement('div').ownerDocument === document",
            "true",
        ),
        (
            "typeof document.createElement('div').ownerDocument.createElement",
            "function",
        ),
        // **重要**: ラジオボタンの最も基本的な仕様上の挙動（同じ `name` を持つグループ内で
        // 1つだけが `checked` になる排他選択）が以前は非対応の簡略化として明示的に
        // 見送られていた。`element.click()` と `.checked = true` 代入の両方で効くこと。
        (
            "var r1=document.createElement('input'); r1.type='radio'; r1.name='g'; \
             var r2=document.createElement('input'); r2.type='radio'; r2.name='g'; \
             r1.click(); r2.click(); r1.checked + ',' + r2.checked",
            "false,true",
        ),
        (
            "var r1=document.createElement('input'); r1.type='radio'; r1.name='g2'; \
             var r2=document.createElement('input'); r2.type='radio'; r2.name='g2'; \
             r1.checked=true; r2.checked=true; r1.checked + ',' + r2.checked",
            "false,true",
        ),
        // 異なる `name` を持つ radio 同士は互いに影響しない。
        (
            "var r1=document.createElement('input'); r1.type='radio'; r1.name='ga'; \
             var r2=document.createElement('input'); r2.type='radio'; r2.name='gb'; \
             r1.click(); r2.click(); r1.checked + ',' + r2.checked",
            "true,true",
        ),
        // `input.disabled`/`option.selected`/`input.placeholder`/`input.name` も
        // `checked`/`type` と同じ理由で JS プロパティとして丸ごと未実装だった。
        (
            "var b=document.createElement('button'); b.disabled=true; b.disabled",
            "true",
        ),
        (
            "var b=document.createElement('button'); b.disabled=true; b.disabled=false; b.disabled",
            "false",
        ),
        (
            "var o=document.createElement('option'); o.selected=true; o.selected",
            "true",
        ),
        // `option.text`（`textContent` の別名。`new Option(...)`/`option.text = '...'`
        // という定番パターン）が丸ごと未対応だった。
        (
            "var o=document.createElement('option'); o.text='Label'; o.text",
            "Label",
        ),
        (
            "var o=document.createElement('option'); o.text='Label'; o.textContent",
            "Label",
        ),
        // `option`/`optgroup.label`（丸ごと未対応だった。`option.label`は
        // 仕様上`label`属性が無ければテキスト内容にフォールバックする。
        // 2026-07-17 発見・実装）。
        (
            "var o=document.createElement('option'); o.textContent='hi'; o.label",
            "hi",
        ),
        (
            "var o=document.createElement('option'); o.textContent='hi'; o.label='explicit'; o.label",
            "explicit",
        ),
        (
            "var g=document.createElement('optgroup'); g.textContent='hi'; g.label",
            "",
        ),
        (
            "var g=document.createElement('optgroup'); g.label='Group A'; g.label",
            "Group A",
        ),
        // `input.required`/`input.readOnly`/`input.multiple`/`img.src`/`img.alt`/
        // `a.href` も同じ理由で JS プロパティとして丸ごと未実装だった。
        (
            "var i=document.createElement('input'); i.required=true; i.required",
            "true",
        ),
        (
            "var i=document.createElement('input'); i.readOnly=true; i.readOnly",
            "true",
        ),
        (
            "var s=document.createElement('select'); s.multiple=true; s.multiple",
            "true",
        ),
        (
            "var img=document.createElement('img'); img.src='a.png'; img.alt='pic'; img.src+','+img.alt",
            "a.png,pic",
        ),
        (
            "var a=document.createElement('a'); a.href='/x'; a.href",
            "/x",
        ),
        // `label.htmlFor`/`form.action`/`form.method`/`input.min`/`max`/`step`/
        // `maxLength`/`a.target`/`rel`/`download` も同種の未実装だった。
        (
            "var l=document.createElement('label'); l.htmlFor='name'; l.htmlFor",
            "name",
        ),
        (
            "var f=document.createElement('form'); f.action='/submit'; f.method='post'; f.action+','+f.method",
            "/submit,post",
        ),
        // `form.method`（`method`属性が無いか既知の列挙値以外なら既定
        // `"get"`にフォールバックする。`fieldset.type`等と同じバグ
        // パターンで丸ごと未対応だった。2026-07-17 発見・実装）。
        ("document.createElement('form').method", "get"),
        (
            "var f=document.createElement('form'); f.setAttribute('method','DIALOG'); f.method",
            "dialog",
        ),
        (
            "var f=document.createElement('form'); f.setAttribute('method','bogus'); f.method",
            "get",
        ),
        // `form.enctype`/`.encoding`（丸ごと未対応だった。`encoding`は
        // `enctype`のレガシー別名で同じ属性を指す。既知の列挙値3種以外
        // なら既定`"application/x-www-form-urlencoded"`にフォールバック
        // する。2026-07-17 発見・実装）。
        (
            "document.createElement('form').enctype",
            "application/x-www-form-urlencoded",
        ),
        (
            "var f=document.createElement('form'); f.enctype='multipart/form-data'; f.enctype+','+f.encoding",
            "multipart/form-data,multipart/form-data",
        ),
        (
            "var f=document.createElement('form'); f.encoding='text/plain'; f.enctype",
            "text/plain",
        ),
        // `form.acceptCharset`（`accept-charset`属性のcamelCase IDL
        // プロパティ版。`htmlFor`と同じパターンだが丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        (
            "var f=document.createElement('form'); f.acceptCharset='UTF-8'; f.getAttribute('accept-charset')",
            "UTF-8",
        ),
        (
            "var f=document.createElement('form'); f.setAttribute('accept-charset','UTF-8'); f.acceptCharset",
            "UTF-8",
        ),
        // `button`/`input`の「送信オーバーライド」IDLプロパティ（`formAction`/
        // `formEnctype`/`formMethod`/`formNoValidate`/`formTarget`）が丸ごと
        // 未対応だった。`form.action`/`.method`/`.enctype`と同じ既定値
        // フォールバックパターンを踏襲する。2026-07-17 発見・実装）。
        (
            "var b=document.createElement('button'); b.formAction='/x'; b.getAttribute('formaction')",
            "/x",
        ),
        (
            "document.createElement('input').formEnctype",
            "application/x-www-form-urlencoded",
        ),
        (
            "var b=document.createElement('button'); b.formEnctype='multipart/form-data'; b.formEnctype",
            "multipart/form-data",
        ),
        ("document.createElement('button').formMethod", "get"),
        (
            "var i=document.createElement('input'); i.formMethod='post'; i.formMethod",
            "post",
        ),
        (
            "document.createElement('button').formNoValidate",
            "false",
        ),
        (
            "var b=document.createElement('button'); b.formNoValidate=true; b.getAttribute('formnovalidate')",
            "formnovalidate",
        ),
        (
            "var i=document.createElement('input'); i.formTarget='_blank'; i.formTarget",
            "_blank",
        ),
        (
            "var i=document.createElement('input'); i.defaultValue='hello'; i.defaultValue+','+i.getAttribute('value')",
            "hello,hello",
        ),
        (
            "var i=document.createElement('input'); i.defaultChecked=true; i.defaultChecked+','+i.hasAttribute('checked')",
            "true,true",
        ),
        (
            "var o=document.createElement('option'); o.defaultSelected=true; o.defaultSelected+','+o.hasAttribute('selected')",
            "true,true",
        ),
        // `img.loading`/`.decoding`（既知の列挙値以外なら仕様上の既定値
        // `"auto"`にフォールバックする必要があるが、`fieldset.type`等と
        // 同じバグパターンで空文字列になっていた。2026-07-17 発見・実装）。
        ("document.createElement('img').loading", "auto"),
        (
            "var i=document.createElement('img'); i.loading='lazy'; i.loading",
            "lazy",
        ),
        (
            "var i=document.createElement('img'); i.setAttribute('loading','bogus'); i.loading",
            "auto",
        ),
        ("document.createElement('img').decoding", "auto"),
        (
            "var i=document.createElement('img'); i.decoding='sync'; i.decoding",
            "sync",
        ),
        (
            "var i=document.createElement('img'); i.setAttribute('decoding','bogus'); i.decoding",
            "auto",
        ),
        // `audio`/`video.preload`（欠落時既定値`"metadata"`、不正値既定値
        // `"auto"`。`fieldset.type`等と同じバグパターンで空文字列になって
        // いた。2026-07-17 発見・実装）。
        ("document.createElement('audio').preload", "metadata"),
        (
            "var v=document.createElement('video'); v.preload='none'; v.preload",
            "none",
        ),
        (
            "var v=document.createElement('video'); v.setAttribute('preload','bogus'); v.preload",
            "auto",
        ),
        // `textarea.wrap`（`"soft"`/`"hard"`。既知値以外・欠落時は仕様上の
        // 既定値`"soft"`にフォールバックする必要があるが、丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        ("document.createElement('textarea').wrap", "soft"),
        (
            "var t=document.createElement('textarea'); t.wrap='hard'; t.wrap",
            "hard",
        ),
        (
            "var t=document.createElement('textarea'); t.setAttribute('wrap','bogus'); t.wrap",
            "soft",
        ),
        // `track.kind`（欠落時既定`"subtitles"`／不正値既定`"metadata"`の
        // 2段階フォールバック。プロパティ自体が丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        ("document.createElement('track').kind", "subtitles"),
        (
            "var t=document.createElement('track'); t.kind='captions'; t.kind",
            "captions",
        ),
        (
            "var t=document.createElement('track'); t.setAttribute('kind','bogus'); t.kind",
            "metadata",
        ),
        // `track.label`/`.srclang`（単純な文字列反映）と`track.default`
        // （ブール型）が丸ごと未対応だった。あわせて`option`/`optgroup`/
        // `track`共通の`label`セッターが丸ごと存在しなかった重複バグも
        // 解消。2026-07-18 発見・実装）。
        (
            "var t=document.createElement('track'); t.label='English'; t.getAttribute('label')",
            "English",
        ),
        (
            "var t=document.createElement('track'); t.srclang='en'; t.srclang",
            "en",
        ),
        ("document.createElement('track').default", "false"),
        (
            "var t=document.createElement('track'); t.default=true; t.getAttribute('default')",
            "default",
        ),
        // `link.as`（`rel="preload"`/`"prefetch"`の取得先種別ヒント。単純な
        // 文字列反映だが丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "var l=document.createElement('link'); l.as='script'; l.getAttribute('as')",
            "script",
        ),
        (
            "var l=document.createElement('link'); l.setAttribute('as','style'); l.as",
            "style",
        ),
        // `video.videoWidth`/`.videoHeight`（実デコードパイプラインが
        // 無いため常に`0`）と`audio`/`video.seeking`（実際の非同期シーク
        // 処理が無いため常に`false`）が丸ごと未対応だった。2026-07-18
        // 発見・実装）。
        (
            "document.createElement('video').videoWidth+','+document.createElement('video').videoHeight",
            "0,0",
        ),
        ("document.createElement('video').seeking", "false"),
        ("document.createElement('audio').seeking", "false"),
        // `select.size`（欠落・不正値時の既定値`0`）と`input.size`（欠落・
        // 不正値時の既定値`20`）が丸ごと未対応だった。2026-07-18 発見・
        // 実装）。
        ("document.createElement('select').size", "0"),
        (
            "var s=document.createElement('select'); s.size=5; s.size",
            "5",
        ),
        ("document.createElement('input').size", "20"),
        (
            "var i=document.createElement('input'); i.size=10; i.size",
            "10",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('size','0'); i.size",
            "20",
        ),
        // `textarea.rows`/`.cols`（欠落・不正値時の既定値`2`/`20`）が
        // 丸ごと未対応だった。2026-07-18 発見・実装）。
        ("document.createElement('textarea').rows", "2"),
        (
            "var t=document.createElement('textarea'); t.rows=8; t.rows",
            "8",
        ),
        ("document.createElement('textarea').cols", "20"),
        (
            "var t=document.createElement('textarea'); t.cols=40; t.cols",
            "40",
        ),
        (
            "var t=document.createElement('textarea'); t.setAttribute('rows','0'); t.rows",
            "2",
        ),
        // `dialog.requestClose(returnValue?)`（`.close()`と違い、閉じる
        // 直前に取消可能な`cancel`イベントを発火する。丸ごと未対応
        // だった。2026-07-18 発見・実装）。
        (
            "var d=document.createElement('dialog'); d.open=true; d.requestClose('x'); \
             d.open+','+d.returnValue",
            "false,x",
        ),
        (
            "var d=document.createElement('dialog'); d.open=true; \
             d.addEventListener('cancel', e=>e.preventDefault()); d.requestClose(); d.open",
            "true",
        ),
        (
            "var d=document.createElement('dialog'); d.open=true; var fired=false; \
             d.addEventListener('close', ()=>fired=true); d.requestClose(); fired",
            "true",
        ),
        // `progress.position`（廃止予定だが仕様に残る読み取り専用IDL。
        // `value`未設定なら不確定状態`-1`、それ以外は`value/max`。丸ごと
        // 未対応だった。2026-07-18 発見・実装）。
        ("document.createElement('progress').position", "-1"),
        (
            "var p=document.createElement('progress'); p.max=10; p.value=5; p.position",
            "0.5",
        ),
        (
            "var p=document.createElement('progress'); p.value=1; p.position",
            "1",
        ),
        // `output.htmlFor`（`for`属性を空白区切りトークンとして扱う
        // `DOMTokenList`。`label.htmlFor`（単一文字列）とは異なる意味。
        // `relList`/`sandbox`と同じ読み取り専用トークン配列の簡略実装。
        // 丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "var o=document.createElement('output'); o.htmlFor='a b c'; \
             o.htmlFor.length+','+o.htmlFor[1]",
            "3,b",
        ),
        (
            "var o=document.createElement('output'); o.setAttribute('for','x y'); \
             Array.from(o.htmlFor).join(',')",
            "x,y",
        ),
        ("document.createElement('output').htmlFor.length", "0"),
        // `input[type=checkbox/radio].value`（`value`属性が無い場合の仕様上
        // の既定値は`""`ではなく`"on"`。フォーム送信ロジック
        // 〔`collect_form_data`〕は既に正しくこの既定値を使っていたが、
        // JSプロパティの`.value`読み出し側だけ空文字列になる不整合が
        // あった。2026-07-18 発見・実装）。
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.value",
            "on",
        ),
        (
            "var r=document.createElement('input'); r.type='radio'; r.value",
            "on",
        ),
        (
            "var c=document.createElement('input'); c.type='checkbox'; c.value='yes'; c.value",
            "yes",
        ),
        (
            "document.createElement('input').value",
            "",
        ),
        // `input[type=color].value`（`value`属性が無いか7文字の`#rrggbb`
        // 小文字16進形式でない不正値の場合の既定値は`"#000000"`。
        // `checkbox`/`radio`の`"on"`と同じバグパターンで空文字列に
        // なっていた。2026-07-18 発見・実装）。
        (
            "var c=document.createElement('input'); c.type='color'; c.value",
            "#000000",
        ),
        (
            "var c=document.createElement('input'); c.type='color'; c.value='#ff00aa'; c.value",
            "#ff00aa",
        ),
        // `input[type=color].value = v`の書き込み側sanitizationが丸ごと
        // 未対応だった。ゲッター側は「既に小文字16進形式か」しか見ておらず、
        // セッター側で大文字→小文字への正規化が行われていなかったため、
        // 仕様上は妥当な色（大文字16進）である`'#FF00AA'`を代入しても
        // 小文字化されずゲッターの検証に弾かれ`#000000`になってしまう
        // 食い違いがあった（2026-07-18 発見・修正）。
        (
            "var c=document.createElement('input'); c.type='color'; c.value='#FF00AA'; c.value",
            "#ff00aa",
        ),
        (
            // 16進形式として無効な値（色名等）は仕様どおり`#000000`へ正規化される。
            "var c=document.createElement('input'); c.type='color'; c.value='red'; c.value",
            "#000000",
        ),
        // `input[type=range].value`（`value`属性が無いか不正値の場合の
        // 既定値は`min`と`max`の中点。`min`/`max`省略時は既定`0`/`100`
        // のため無指定時は`50`。`checkbox`/`color`と同じバグパターンで
        // 空文字列になっていた。2026-07-18 発見・実装）。
        (
            "var r=document.createElement('input'); r.type='range'; r.value",
            "50",
        ),
        (
            "var r=document.createElement('input'); r.type='range'; r.min='0'; r.max='10'; r.value",
            "5",
        ),
        (
            "var r=document.createElement('input'); r.type='range'; r.value='7'; r.value",
            "7",
        ),
        (
            "var r=document.createElement('input'); r.type='range'; r.min='5'; r.max='2'; r.value",
            "5",
        ),
        // `input[type=range].value`の仕様上のvalue sanitization algorithmは
        // 数値変換できない不正値の既定値フォールバックだけでなく`min`/`max`
        // へのクランプも含むが、パース自体には成功する範囲外の値
        // （`max=10`で`value=999`等）はクランプされずそのまま漏れていた。
        (
            "var r=document.createElement('input'); r.type='range'; r.min='0'; r.max='10'; r.value='999'; r.value",
            "10",
        ),
        (
            "var r=document.createElement('input'); r.type='range'; r.min='0'; r.max='10'; r.value='-5'; r.value",
            "0",
        ),
        (
            // `setAttribute`経由（IDLセッターを介さない直接の属性書き込み）でも
            // 同じくクランプされる。
            "var r=document.createElement('input'); r.type='range'; r.min='0'; r.max='10'; \
             r.setAttribute('value','999'); r.value",
            "10",
        ),
        // `table.tHead`/`.tFoot`/`.caption`のセッター（読み出し側は既に
        // 実装済みだったが、対になる書き込み側が丸ごと未対応だった。
        // 代入すると既存の同名セクションを除去し、新しい要素を正しい
        // 位置へ挿入する。2026-07-18 発見・実装）。
        (
            "var t=document.createElement('table'); var h=document.createElement('thead'); \
             t.tHead=h; t.tHead===h",
            "true",
        ),
        (
            "var t=document.createElement('table'); var h1=document.createElement('thead'); \
             var h2=document.createElement('thead'); t.tHead=h1; t.tHead=h2; \
             (t.tHead===h2)+','+t.children.length",
            "true,1",
        ),
        (
            "var t=document.createElement('table'); var h=document.createElement('thead'); \
             t.tHead=h; t.tHead=null; t.tHead",
            "null",
        ),
        (
            "var t=document.createElement('table'); var c=document.createElement('caption'); \
             var b=document.createElement('tbody'); t.appendChild(b); t.caption=c; \
             t.firstChild===c",
            "true",
        ),
        // `select.add(element, before)`（`select.options.add`と同じ意味の
        // 便利メソッド。丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "var s=document.createElement('select'); var o=document.createElement('option'); \
             s.add(o); s.options.length+','+(s.options[0]===o)",
            "1,true",
        ),
        (
            "var s=document.createElement('select'); var o1=document.createElement('option'); \
             var o2=document.createElement('option'); s.add(o1); s.add(o2, o1); \
             s.options[0]===o2",
            "true",
        ),
        // `audio`/`video.played`（`TimeRanges`。`buffered`/`.seekable`と
        // 同じ理由で常に空。丸ごと未対応だった。2026-07-18 発見・実装）。
        ("document.createElement('video').played.length", "0"),
        ("document.createElement('audio').played.length", "0"),
        // `element.role`/`.ariaLabel`等（`ARIAMixin`。`role`/`aria-*`属性の
        // IDLプロパティ版）が丸ごと未対応だった。`aria`接頭辞後の
        // PascalCase部分を全て小文字化して`aria-`と連結する命名規則を
        // 汎用アームで一括対応。2026-07-18 発見・実装）。
        (
            "var d=document.createElement('div'); d.role='button'; d.getAttribute('role')",
            "button",
        ),
        (
            "var d=document.createElement('div'); d.setAttribute('role','tab'); d.role",
            "tab",
        ),
        (
            "var d=document.createElement('div'); d.ariaLabel='close'; d.getAttribute('aria-label')",
            "close",
        ),
        (
            "var d=document.createElement('div'); d.setAttribute('aria-hidden','true'); d.ariaHidden",
            "true",
        ),
        (
            "var d=document.createElement('div'); d.ariaValueNow='5'; d.getAttribute('aria-valuenow')",
            "5",
        ),
        (
            "var d=document.createElement('div'); d.ariaLabel='x'; d.ariaLabel=null; \
             d.getAttribute('aria-label')",
            "null",
        ),
        ("document.createElement('div').ariaLabel", "null"),
        // `element.outerText`（読み出しは`innerText`と同じだが、書き込みは
        // 自身の中身ではなく自身「そのもの」をテキストノードへ置き換える
        // 点が違う。丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "var d=document.createElement('div'); d.textContent='hi'; d.outerText",
            "hi",
        ),
        (
            "var p=document.createElement('div'); var c=document.createElement('span'); \
             c.textContent='x'; p.appendChild(c); c.outerText='y'; p.textContent",
            "y",
        ),
        (
            "var p=document.createElement('div'); var c=document.createElement('span'); \
             p.appendChild(c); c.outerText='z'; p.children.length",
            "0",
        ),
        // `element.part`（CSS Shadow Parts。`relList`/`sandbox`と同じ
        // 読み取り専用トークン配列の簡略実装。丸ごと未対応だった。
        // 2026-07-18 発見・実装）。
        (
            "var d=document.createElement('div'); d.setAttribute('part','a b'); \
             d.part.length+','+d.part[1]",
            "2,b",
        ),
        ("document.createElement('div').part.length", "0"),
        // `link.sizes`は`img`/`source.sizes`（単純なDOMString）とは異なり
        // 仕様上`DOMTokenList`。`part`/`relList`と同じ読み取り専用トークン
        // 配列の簡略実装で区別する。以前は同名の文字列反映アームに
        // 一括で落ちて型が誤っていた。2026-07-18 発見・実装）。
        (
            "var l=document.createElement('link'); l.setAttribute('sizes','16x16 32x32'); \
             l.sizes.length+','+l.sizes[1]",
            "2,32x32",
        ),
        (
            "var i=document.createElement('img'); i.sizes='(min-width: 600px) 50vw, 100vw'; i.sizes",
            "(min-width: 600px) 50vw, 100vw",
        ),
        // `input.accept`（`type="file"`が許可するファイル種別フィルタ。
        // 単純な文字列反映だが丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "var i=document.createElement('input'); i.accept='image/*'; i.getAttribute('accept')",
            "image/*",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('accept','.pdf,.doc'); i.accept",
            ".pdf,.doc",
        ),
        // `script.charset`（廃止予定だが仕様に残る単純な文字列反映。
        // ゲッターが`meta`タグ限定のままで他タグでは未対応だった。
        // 2026-07-18 発見・実装）。
        (
            "var s=document.createElement('script'); s.charset='utf-8'; s.getAttribute('charset')",
            "utf-8",
        ),
        (
            "var s=document.createElement('script'); s.setAttribute('charset','shift-jis'); s.charset",
            "shift-jis",
        ),
        // `a`/`area.protocol`/`.host`/`.hostname`/`.port`/`.pathname`/
        // `.search`/`.hash`のセッター（`URLUtils`ミックスイン。ゲッターは
        // 既に実装済みだったが対になるセッターが丸ごと未対応だった。
        // 2026-07-18 発見・実装）。
        (
            "var a=document.createElement('a'); a.href='https://x.com/p'; a.hostname='y.com'; a.href",
            "https://y.com/p",
        ),
        (
            "var a=document.createElement('a'); a.href='https://x.com/p'; a.protocol='http'; a.protocol",
            "http:",
        ),
        (
            "var a=document.createElement('a'); a.href='https://x.com/p'; a.pathname='q'; a.pathname",
            "/q",
        ),
        (
            "var a=document.createElement('a'); a.href='https://x.com/p'; a.search='x=1'; a.search",
            "?x=1",
        ),
        (
            "var a=document.createElement('a'); a.href='https://x.com/p'; a.hash='frag'; a.hash",
            "#frag",
        ),
        (
            "var a=document.createElement('a'); a.href='https://x.com:80/p'; a.host='y.com:90'; \
             a.hostname+','+a.port",
            "y.com,90",
        ),
        (
            "var a=document.createElement('a'); a.href='https://x.com/p'; a.username='u'; \
             a.password='pw'; a.href",
            "https://u:pw@x.com/p",
        ),
        // `element.willValidate`がタグを一切見ておらず、`<output>`/`<div>`
        // のような本来常に`false`であるべき非フォームコントロールでも
        // `true`を返してしまうバグだった。2026-07-18 発見・修正）。
        ("document.createElement('output').willValidate", "false"),
        ("document.createElement('div').willValidate", "false"),
        ("document.createElement('fieldset').willValidate", "false"),
        ("document.createElement('input').willValidate", "true"),
        (
            "var b=document.createElement('button'); b.disabled=true; b.willValidate",
            "false",
        ),
        // `validity_flags`（`.validity`が内部で使う共通ロジック）が
        // `willValidate`と同根の「タグを見ない」バグを持っていた。
        // `<output required>`のような本来検証対象外の要素へ`required`
        // 属性を付けても`valueMissing`が立たないことを確認。2026-07-18
        // 発見・修正）。
        (
            "var o=document.createElement('output'); o.setAttribute('required','required'); \
             o.validity.valid",
            "true",
        ),
        (
            "var d=document.createElement('div'); d.setAttribute('required','required'); \
             d.validity.valueMissing",
            "false",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('required','required'); \
             i.validity.valueMissing",
            "true",
        ),
        // `validate_field`（`element.checkValidity()`が直接呼ぶ経路）も
        // 同根の「タグを見ない」バグを持っていた。`<output required>`へ
        // `checkValidity()`を直接呼んでも常に`true`のままであることを
        // 確認。`form.checkValidity()`側は既に`input`/`textarea`/
        // `select`へ絞り込み済みのため実害が無かった経路との違いに
        // 注意。2026-07-18 発見・修正）。
        (
            "var o=document.createElement('output'); o.setAttribute('required','required'); \
             o.checkValidity()",
            "true",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('required','required'); \
             i.checkValidity()",
            "false",
        ),
        // `video.disableRemotePlayback`（`disablePictureInPicture`と同じ
        // 単純なブール属性反映だが丸ごと未対応だった。2026-07-18
        // 発見・実装）。
        (
            "document.createElement('video').disableRemotePlayback",
            "false",
        ),
        (
            "var v=document.createElement('video'); v.disableRemotePlayback=true; \
             v.getAttribute('disableremoteplayback')",
            "disableremoteplayback",
        ),
        // `link`/`script.blocking`（`part`/`relList`/`sandbox`と同じ読み
        // 取り専用トークン配列。丸ごと未対応だった。2026-07-18 発見・
        // 実装）。
        (
            "var l=document.createElement('link'); l.setAttribute('blocking','render'); \
             l.blocking.length+','+l.blocking[0]",
            "1,render",
        ),
        ("document.createElement('script').blocking.length", "0"),
        // `output.value`/`.defaultValue`（`<output>`は`value`content属性を
        // 持たず、未書込み時は`.textContent`にフォールバックする。
        // `textarea.value`と同じパターンだが丸ごと未対応だった。
        // 2026-07-18 発見・実装）。
        (
            "var o=document.createElement('output'); o.textContent='42'; o.value",
            "42",
        ),
        (
            "var o=document.createElement('output'); o.textContent='42'; o.value='7'; o.value",
            "7",
        ),
        (
            "var o=document.createElement('output'); o.textContent='42'; o.value='7'; \
             o.textContent",
            "42",
        ),
        // `video.getVideoPlaybackQuality()`（丸ごと未対応だった。実
        // デコードパイプラインが無いため全カウンタ`0`の誠実な簡略実装。
        // 2026-07-18 発見・実装）。
        (
            "var q=document.createElement('video').getVideoPlaybackQuality(); \
             q.totalVideoFrames+','+q.droppedVideoFrames+','+q.corruptedVideoFrames",
            "0,0,0",
        ),
        // `element.namespaceURI`/`.localName`/`.prefix`（丸ごと未対応
        // だった。XML名前空間を一切モデル化していないため常にHTML
        // 名前空間定数/タグ名そのもの/`null`を返す誠実な簡略実装。
        // 2026-07-18 発見・実装）。
        (
            "document.createElement('div').namespaceURI",
            "http://www.w3.org/1999/xhtml",
        ),
        ("document.createElement('SPAN').localName", "span"),
        ("document.createElement('div').prefix", "null"),
        (
            "document.createTextNode('x').namespaceURI",
            "null",
        ),
        (
            "document.createTextNode('x').localName",
            "null",
        ),
        // `HTMLScriptElement.supports(type)`（静的メソッド。丸ごと未対応
        // だった。`classic`/`module`は実サポート済みで`true`、
        // `importmap`はインポートマップ自体が未実装のため`false`）。
        (
            "HTMLScriptElement.supports('classic')+','+HTMLScriptElement.supports('module')",
            "true,true",
        ),
        (
            "document.createElement('div').ariaActiveDescendantElement",
            "null",
        ),
        (
            "(function(){var a=document.createElement('div');a.setAttribute('aria-activedescendant','nope');return a.ariaActiveDescendantElement;})()",
            "null",
        ),
        // `element.getHTML()`/`.setHTMLUnsafe()`（`innerHTML`ゲッター/
        // セッターの明示的メソッド版。丸ごと未対応だった。この処理系には
        // Trusted Types自体が無いため`innerHTML`と可視的な違いは無い
        // 簡略実装。2026-07-18 発見・実装）。
        (
            "var d=document.createElement('div'); d.innerHTML='<b>x</b>'; d.getHTML()",
            "<b>x</b>",
        ),
        (
            "var d=document.createElement('div'); d.setHTMLUnsafe('<i>y</i>'); d.innerHTML",
            "<i>y</i>",
        ),
        // `CSS.number()`/`.percent()`/`.px()`/`.em()`/`.rem()`/`.deg()`
        // （CSS Typed OMの値+単位ファクトリ関数群。丸ごと未対応だった。
        // 2026-07-18 発見・実装）。
        ("CSS.px(5).value+','+CSS.px(5).unit+','+CSS.px(5).toString()", "5,px,5px"),
        ("CSS.percent(50).toString()", "50%"),
        ("CSS.number(3).toString()", "3"),
        ("CSS.em(1.5).toString()", "1.5em"),
        ("CSS.rem(2).toString()", "2rem"),
        ("CSS.deg(90).toString()", "90deg"),
        ("HTMLScriptElement.supports('importmap')", "false"),
        ("HTMLScriptElement.supports('bogus')", "false"),
        // `link.imageSrcset`/`.imageSizes`（`rel="preload" as="image"`用の
        // レスポンシブ画像プリロードヒント。`link.as`と同じ単純な文字列
        // 反映だが丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "(function(){var l=document.createElement('link');l.imageSrcset='a.jpg 1x, b.jpg 2x';l.imageSizes='100vw';return l.imageSrcset+'|'+l.imageSizes;})()",
            "a.jpg 1x, b.jpg 2x|100vw",
        ),
        (
            "document.createElement('link').imageSrcset+'|'+document.createElement('link').imageSizes",
            "|",
        ),
        // `iframe.credentialless`（COEP credentialless。`allowFullscreen`と
        // 同じ単純なブール属性反映だが丸ごと未対応だった。2026-07-18
        // 発見・実装）。
        (
            "(function(){var f=document.createElement('iframe');var before=f.credentialless;f.credentialless=true;var after=f.credentialless;f.credentialless=false;return before+','+after+','+f.credentialless;})()",
            "false,true,false",
        ),
        // `area.coords`/`.shape`（`shape`は既知値以外・欠落時は仕様上の
        // 既定値`"rect"`にフォールバックし、レガシー別名`"circ"`/
        // `"polygon"`も正規化する。プロパティ自体が丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        (
            "var a=document.createElement('area'); a.coords='0,0,10,10'; a.coords",
            "0,0,10,10",
        ),
        ("document.createElement('area').shape", "rect"),
        (
            "var a=document.createElement('area'); a.shape='circle'; a.shape",
            "circle",
        ),
        (
            "var a=document.createElement('area'); a.setAttribute('shape','circ'); a.shape",
            "circle",
        ),
        (
            "var a=document.createElement('area'); a.setAttribute('shape','polygon'); a.shape",
            "poly",
        ),
        // `ol.type`/`.start`/`.reversed`（`type`は既知値以外・欠落時は
        // 仕様上の既定値`"1"`にフォールバックする。`start`は欠落・不正値
        // 時の既定値`1`。どちらも丸ごと未対応だった。2026-07-17 発見・
        // 実装）。
        ("document.createElement('ol').type", "1"),
        (
            "var o=document.createElement('ol'); o.type='A'; o.type",
            "A",
        ),
        (
            "var o=document.createElement('ol'); o.setAttribute('type','bogus'); o.type",
            "1",
        ),
        ("document.createElement('ol').start", "1"),
        (
            "var o=document.createElement('ol'); o.start=5; o.start",
            "5",
        ),
        (
            "document.createElement('ol').reversed",
            "false",
        ),
        (
            "var o=document.createElement('ol'); o.reversed=true; o.getAttribute('reversed')",
            "reversed",
        ),
        // `meter.low`/`.high`/`.optimum`（`min`/`max`と同じく丸ごと未対応
        // だった。既定値はそれぞれ`min`/`max`/`min`と`max`の中点。
        // 2026-07-17 発見・実装）。
        (
            "var m=document.createElement('meter'); m.min='2'; m.max='10'; m.low+','+m.high+','+m.optimum",
            "2,10,6",
        ),
        (
            "var m=document.createElement('meter'); m.max='10'; m.low='4'; m.low",
            "4",
        ),
        (
            "var m=document.createElement('meter'); m.max='10'; m.high='20'; m.high",
            "10",
        ),
        // `td`/`th.colSpan`/`.rowSpan`（欠落・不正値時の既定値`1`、
        // `colSpan`は最大`1000`、`rowSpan`は最大`65534`にクランプ。
        // どちらも丸ごと未対応だった。2026-07-17 発見・実装）。
        ("document.createElement('td').colSpan", "1"),
        (
            "var c=document.createElement('td'); c.colSpan=3; c.colSpan",
            "3",
        ),
        (
            "var c=document.createElement('td'); c.setAttribute('colspan','9999'); c.colSpan",
            "1000",
        ),
        ("document.createElement('th').rowSpan", "1"),
        (
            "var c=document.createElement('th'); c.rowSpan=0; c.rowSpan",
            "0",
        ),
        // `td`/`th.headers`（単純な文字列反映）と`th.scope`（既知値以外・
        // 欠落時は仕様上の既定値`""`にフォールバック）、`th.abbr`（単純な
        // 文字列反映）が丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "var c=document.createElement('td'); c.headers='h1 h2'; c.headers",
            "h1 h2",
        ),
        ("document.createElement('th').scope", ""),
        (
            "var t=document.createElement('th'); t.scope='col'; t.scope",
            "col",
        ),
        (
            "var t=document.createElement('th'); t.setAttribute('scope','bogus'); t.scope",
            "",
        ),
        (
            "var t=document.createElement('th'); t.abbr='Description'; t.abbr",
            "Description",
        ),
        // `col`/`colgroup.span`（欠落・不正値時の既定値`1`、最大`1000`に
        // クランプ。丸ごと未対応だった。2026-07-17 発見・実装）。
        ("document.createElement('col').span", "1"),
        (
            "var c=document.createElement('colgroup'); c.span=3; c.span",
            "3",
        ),
        (
            "var c=document.createElement('col'); c.setAttribute('span','9999'); c.span",
            "1000",
        ),
        // `object.data`（`href`/`src`/`action`と同じくURL属性を反映し、
        // 現在のページURL基準の絶対URLを返す。テキストノードの
        // `CharacterData.data`と同名で衝突するためタグ限定で扱う必要が
        // あったが、プロパティ自体が丸ごと未対応だった。2026-07-17
        // 発見・実装）。
        (
            "var o=document.createElement('object'); o.data='/x'; o.getAttribute('data')",
            "/x",
        ),
        (
            "var t=document.createTextNode('hi'); t.data",
            "hi",
        ),
        // `meta.httpEquiv`/`.content`/`.charset`（`httpEquiv`は`http-equiv`
        // 属性の camelCase IDL プロパティ版で`htmlFor`と同じマッピング
        // パターン、`content`/`.charset`は単純な属性反映。3つとも丸ごと
        // 未対応だった。2026-07-17 発見・実装）。
        (
            "var m=document.createElement('meta'); m.httpEquiv='refresh'; m.getAttribute('http-equiv')",
            "refresh",
        ),
        (
            "var m=document.createElement('meta'); m.setAttribute('http-equiv','refresh'); m.httpEquiv",
            "refresh",
        ),
        (
            "var m=document.createElement('meta'); m.content='width=device-width'; m.content",
            "width=device-width",
        ),
        (
            "var m=document.createElement('meta'); m.charset='utf-8'; m.charset",
            "utf-8",
        ),
        // `blockquote`/`q`/`ins`/`del.cite`（単純な文字列反映）と
        // `ins`/`del`/`time.dateTime`（`datetime`属性のcamelCase IDL
        // プロパティ版）が丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "var b=document.createElement('blockquote'); b.cite='https://example.com'; b.getAttribute('cite')",
            "https://example.com",
        ),
        (
            "var t=document.createElement('time'); t.dateTime='2026-07-17'; t.getAttribute('datetime')",
            "2026-07-17",
        ),
        (
            "var i=document.createElement('ins'); i.setAttribute('datetime','2026-07-17'); i.dateTime",
            "2026-07-17",
        ),
        // `video.disablePictureInPicture`/`iframe.allowFullscreen`（単純な
        // ブール属性反映だが丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "document.createElement('video').disablePictureInPicture",
            "false",
        ),
        (
            "var v=document.createElement('video'); v.disablePictureInPicture=true; v.getAttribute('disablepictureinpicture')",
            "disablepictureinpicture",
        ),
        (
            "var f=document.createElement('iframe'); f.allowFullscreen=true; f.getAttribute('allowfullscreen')",
            "allowfullscreen",
        ),
        // `canvas.width`/`.height`（欠落・不正値時の既定値`300`/`150`）と
        // `img`/`video.width`/`.height`（既定値`0`）が丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "document.createElement('canvas').width+','+document.createElement('canvas').height",
            "300,150",
        ),
        (
            "var c=document.createElement('canvas'); c.width=640; c.height=480; c.width+','+c.height",
            "640,480",
        ),
        (
            "document.createElement('img').width+','+document.createElement('img').height",
            "0,0",
        ),
        (
            "var v=document.createElement('video'); v.width=320; v.width",
            "320",
        ),
        // `embed`/`object`/`iframe.width`/`.height`（`DOMString`型の単純な
        // 文字列反映。`canvas`/`img`/`video`の`unsigned long`型とは異なり
        // 数値クランプ・既定値フォールバックが無い。丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "var e=document.createElement('embed'); e.width='50%'; e.width",
            "50%",
        ),
        (
            "var o=document.createElement('object'); o.height='300'; o.height",
            "300",
        ),
        ("document.createElement('iframe').width", ""),
        (
            "var f=document.createElement('iframe'); f.setAttribute('width','640'); f.width",
            "640",
        ),
        // `input`/`textarea.defaultValue`（`value`属性/初期テキストを
        // 反映）と`input.defaultChecked`/`option.defaultSelected`（`checked`/
        // `selected`属性の有無を反映するブール型）が丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "var i=document.createElement('input'); i.defaultValue='hi'; i.getAttribute('value')",
            "hi",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('value','preset'); i.defaultValue",
            "preset",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('value','preset'); i.value='changed'; i.defaultValue",
            "preset",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('value','preset'); i.value='changed'; i.value",
            "changed",
        ),
        (
            "document.createElement('input').defaultChecked",
            "false",
        ),
        (
            "var i=document.createElement('input'); i.defaultChecked=true; i.getAttribute('checked')",
            "checked",
        ),
        (
            "var i=document.createElement('input'); i.defaultChecked=true; i.checked=false; i.defaultChecked",
            "true",
        ),
        (
            "document.createElement('option').defaultSelected",
            "false",
        ),
        (
            "var o=document.createElement('option'); o.defaultSelected=true; o.getAttribute('selected')",
            "selected",
        ),
        // `output.type`（仕様上、属性値に関わらず常に固定文字列
        // `"output"`を返す読み取り専用IDLプロパティ。`<output>`要素
        // 自体が丸ごと未対応だった。2026-07-17 発見・実装）。
        ("document.createElement('output').type", "output"),
        (
            "var o=document.createElement('output'); o.setAttribute('type','bogus'); o.type",
            "output",
        ),
        // `iframe.srcdoc`（単純な文字列反映だが丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        (
            "var f=document.createElement('iframe'); f.srcdoc='<p>hi</p>'; f.getAttribute('srcdoc')",
            "<p>hi</p>",
        ),
        (
            "var f=document.createElement('iframe'); f.setAttribute('srcdoc','<b>x</b>'); f.srcdoc",
            "<b>x</b>",
        ),
        // `li.value`（順序リストの番号上書き用`long`型IDLプロパティ。
        // 欠落・不正値時の既定値は`0`。丸ごと未対応だった。汎用の`value`
        // アームだと数値ではなく文字列になってしまう衝突があった。
        // 2026-07-17 発見・実装）。
        ("document.createElement('li').value", "0"),
        (
            "var l=document.createElement('li'); l.value=5; l.value",
            "5",
        ),
        (
            "var l=document.createElement('li'); l.setAttribute('value','bogus'); l.value",
            "0",
        ),
        // `input.pattern`（`placeholder`と同じ単純な文字列反映だが丸ごと
        // 未対応だった。2026-07-17 発見・実装）。
        (
            "var i=document.createElement('input'); i.pattern='[0-9]+'; i.getAttribute('pattern')",
            "[0-9]+",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('pattern','[a-z]+'); i.pattern",
            "[a-z]+",
        ),
        // `input.capture`（`type="file"`のカメラ/マイク取り込みヒント。
        // 単純な文字列反映だが丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "var i=document.createElement('input'); i.capture='environment'; i.getAttribute('capture')",
            "environment",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('capture','user'); i.capture",
            "user",
        ),
        // `input.autocomplete`（単純な文字列反映）と`element.autofocus`
        // （ブール型。実際のフォーカス自動移動機構は無いため属性値の
        // 反映のみ）が丸ごと未対応だった。2026-07-18 発見・実装）。
        (
            "var i=document.createElement('input'); i.autocomplete='email'; i.getAttribute('autocomplete')",
            "email",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('autocomplete','off'); i.autocomplete",
            "off",
        ),
        (
            "document.createElement('input').autofocus",
            "false",
        ),
        (
            "var i=document.createElement('input'); i.autofocus=true; i.getAttribute('autofocus')",
            "autofocus",
        ),
        (
            "var i=document.createElement('input'); i.min='0'; i.max='10'; i.step='2'; i.min+','+i.max+','+i.step",
            "0,10,2",
        ),
        (
            "var i=document.createElement('input'); i.maxLength='5'; i.maxLength",
            "5",
        ),
        // `maxLength`/`minLength`はWebIDL上`long`（数値型）のIDL属性で、無指定時
        // の既定値は`-1`だが、以前は`maxLength`が文字列型（属性が無ければ空
        // 文字列）で返っており、`minLength`はゲッター自体が丸ごと未対応だった
        // （`min`/`max`/`step`は`DOMString`型が正しいIDL定義のため対象外）。
        (
            "typeof document.createElement('input').maxLength",
            "number",
        ),
        (
            "document.createElement('input').maxLength",
            "-1",
        ),
        (
            "var i=document.createElement('input'); i.minLength=3; typeof i.minLength + ',' + i.minLength",
            "number,3",
        ),
        (
            "document.createElement('textarea').minLength",
            "-1",
        ),
        (
            "var a=document.createElement('a'); a.target='_blank'; a.rel='noopener'; a.download='f.txt'; a.target+','+a.rel+','+a.download",
            "_blank,noopener,f.txt",
        ),
        (
            "var i=document.createElement('input'); i.placeholder='enter name'; i.placeholder",
            "enter name",
        ),
        (
            "var d=document.createElement('details'); d.open",
            "false",
        ),
        (
            "var d=document.createElement('details'); d.open=true; d.open",
            "true",
        ),
        (
            "var d=document.createElement('details'); d.setAttribute('open',''); d.open",
            "true",
        ),
        (
            "var i=document.createElement('input'); i.name='email'; i.name",
            "email",
        ),
        // `select.value`/`select.selectedIndex` が丸ごと未対応だった。`<select>` は
        // 自身に `value` 属性を持たず、子の `<option selected>` が選択状態を持つため、
        // 汎用の属性直結 getter では常に空文字列になっていた。
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.value",
            "a",
        ),
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.value='b'; s.value",
            "b",
        ),
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.value='b'; s.selectedIndex",
            "1",
        ),
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.selectedIndex=1; s.value",
            "b",
        ),
        // `option.index`（`select.selectedIndex`と対になる、`<option>`側の0始まり
        // 位置を返すIDL属性）が丸ごと未対応だった。
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.options[1].index",
            "1",
        ),
        (
            "document.createElement('option').index",
            "0",
        ),
        // `select.length`（`select.options.length`と同じ値を返すIDL属性、および
        // 末尾optionを切り捨てる／空optionで埋めるセッター）が丸ごと未対応だった。
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.length",
            "2",
        ),
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.length=1; s.options.length + ',' + s.value",
            "1,a",
        ),
        (
            "var s=document.createElement('select'); s.length=2; s.options.length",
            "2",
        ),
        // `select.remove(index)`（`HTMLSelectElement`固有のオーバーロード。
        // 指定インデックスのoptionを削除する）が、同名の`ChildNode.remove()`
        // （引数無しで自身を親から削除する）と混同され、`select.remove(1)`が
        // 常にselect自身を親ごと削除してしまうバグだった。
        (
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option><option value='b'>B</option>\"; s.remove(0); s.options.length + ',' + s.value",
            "1,b",
        ),
        (
            // 引数無しの `.remove()` は従来どおり自身を親から削除する
            // （ChildNode.remove()と同じ挙動を維持）。
            "var d=document.createElement('div'); var s=document.createElement('select'); d.appendChild(s); s.remove(); d.children.length",
            "0",
        ),
        (
            // 負のインデックスはno-op（`as usize`の飽和変換で誤って先頭が
            // 削除されるバグを防いだ確認）。
            "var s=document.createElement('select'); s.innerHTML=\"<option value='a'>A</option>\"; s.remove(-1); s.options.length",
            "1",
        ),
        // `textarea.value` も同種のバグだった（`<textarea>` の初期値は本来テキスト
        // ノードの内容で表現されるべきだが、`.value` 書込み後の読み出し往復は
        // 最低限このとおり動くことを確認する）。
        (
            "var t=document.createElement('textarea'); t.value='hi'; t.value",
            "hi",
        ),
        ("typeof console.table", "function"),
        ("typeof globalThis", "object"),
        ("typeof globalThis.document", "object"),
        // fetch（data: URL でネット非依存にフルチェーン検証: Promise→Response→text()/json()）
        ("typeof fetch", "function"),
        ("(await fetch('data:,hello')).status", "200"),
        ("(await fetch('data:,hello')).ok", "true"),
        ("await (await fetch('data:,hello world')).text()", "hello world"),
        ("await fetch('data:text/plain,abc').then(r => r.text())", "abc"),
        ("(await (await fetch('data:application/json,{\"a\":7,\"b\":[1,2]}')).json()).a", "7"),
        ("(await (await fetch('data:application/json,{\"a\":7,\"b\":[1,2]}')).json()).b.length", "2"),
        // `Response.prototype.blob()`（丸ごと未対応で `blob is not defined` だった）。
        ("(await (await fetch('data:,hello')).blob()).size", "5"),
        ("await (await (await fetch('data:,hello')).blob()).text()", "hello"),
        // `Response.prototype.arrayBuffer()` も同種の欠落だった。実バイト列付きの
        // ArrayBuffer で解決するため、そこから作った DataView で正しく読み戻せる。
        (
            "var buf = await (await fetch('data:,A')).arrayBuffer(); new DataView(buf).getUint8(0)",
            "65",
        ),
        ("await fetch('ftp://x/y').then(() => 'ok', e => 'err:' + (e.message || e))", "err:fetch: only absolute http(s) and data URLs are supported"),
        // `Response.prototype.statusText` が丸ごと未対応で常に `undefined` だった
        // （エラーログの定番パターン `console.log(response.status, response.statusText)`
        // で参照される）。
        ("(await fetch('data:,hi')).statusText", "OK"),
        // `Response.prototype.clone()`（`response.clone().json()` のように本文を
        // 2回読みたい場合に使う定番パターン）が丸ごと未対応で `clone is not a
        // function` だった。
        (
            "var r = await fetch('data:,hello'); var c = r.clone(); (await c.text()) + ',' + (await r.text())",
            "hello,hello",
        ),
        ("(await fetch('data:,x')).clone().status", "200"),
        // `Response.prototype.url`（リダイレクト後の最終 URL 確認等で使われる
        // 定番プロパティ）が丸ごと未対応で常に `undefined` だった。
        (
            "(await fetch('data:,hi')).url",
            "data:,hi",
        ),
        // `Response` コンストラクタ自体が丸ごと未対応だった（`fetch()` 内部からしか
        // 生成できず、`new Response(...)` が呼び出すと TypeError になっていた）。
        ("new Response('hi').status", "200"),
        ("await new Response('hi', {status: 201}).text()", "hi"),
        (
            "(await new Response(JSON.stringify({a:1}), {headers:{'content-type':'application/json'}}).json()).a",
            "1",
        ),
        // `Response.json(data, init)`（ES2022 static factory）。
        ("(await Response.json({a:5}).json()).a", "5"),
        ("Response.json({}).headers.get('content-type')", "application/json"),
        // `Response.error()`。
        ("Response.error().ok", "false"),
        ("Response.error().type", "error"),
        // `Response.redirect(url, status?)`。
        ("Response.redirect('https://e.com/x').status", "302"),
        ("Response.redirect('https://e.com/x', 301).headers.get('location')", "https://e.com/x"),
        (
            "(await fetch('data:,x')).clone().url",
            "data:,x",
        ),
        // `fetch(url, {signal})` が丸ごと未対応で、既に aborted な signal を渡しても
        // 常にリクエストを実行してしまっていた。
        (
            "await fetch('data:,hi', {signal: AbortSignal.abort('why')}).then(() => 'no-throw', e => 'caught:' + e)",
            "caught:why",
        ),
        (
            "await fetch('data:,hi', {signal: new AbortController().signal}).then(r => r.status)",
            "200",
        ),
        // `new Request(url, options)` が丸ごと未対応で `Request is not defined`
        // だった。`fetch(request)` という定番パターンも合わせて確認する。
        ("new Request('data:,hi').url", "data:,hi"),
        ("new Request('data:,hi', {method:'POST'}).method", "POST"),
        // `request.headers` が仕様上常に本物の `Headers` インスタンスであるべき
        // ところ、生の値をそのまま格納するだけで `.get(...)` が壊れていた。
        (
            "new Request('data:,hi', {headers:{'X-Foo':'bar'}}).headers.get('x-foo')",
            "bar",
        ),
        ("typeof new Request('data:,hi').headers.get", "function"),
        // `response.type`/`.redirected` が丸ごと未対応で常に `undefined` だった。
        ("(await fetch('data:,hi')).type", "basic"),
        ("(await fetch('data:,hi')).redirected", "false"),
        ("await fetch(new Request('data:,hello')).then(r => r.text())", "hello"),
        (
            "await fetch(new Request('data:,x'), {method:'GET'}).then(r => r.status)",
            "200",
        ),
        // `Headers`（Fetch API の get/set/has/append/delete 付き専用クラス）が
        // 丸ごと未対応だった。ヘッダ名は大小無視で正規化される。
        ("new Headers({'Content-Type':'text/plain'}).get('content-type')", "text/plain"),
        // `[[k,v], ...]` 配列形式の init（`make_headers` の `is_array` 分岐。
        // 2026-07-14、clippy `single_match` 修正時に既存テストで一度もこの
        // 分岐が通っていなかったことに気づき追加）。
        ("new Headers([['A','1'],['b','2']]).get('a')", "1"),
        ("new Headers().has('x')", "false"),
        (
            "var h=new Headers(); h.set('X-Foo','1'); h.has('x-foo')",
            "true",
        ),
        (
            "var h=new Headers(); h.append('a','1'); h.append('a','2'); h.get('a')",
            "1, 2",
        ),
        (
            "var h=new Headers({a:'1'}); h.delete('a'); h.has('a')",
            "false",
        ),
        (
            "var h=new Headers({a:'1',b:'2'}); var s=''; h.forEach(function(v,k){s+=k+'='+v+';'}); s",
            "a=1;b=2;",
        ),
        // `entries`/`keys`/`values`/`Symbol.iterator`（`for (const [k,v] of headers)`
        // という定番イディオムを含む）が丸ごと未対応だった。
        (
            "Array.from(new Headers({b:'2',a:'1'}).entries()).map(function(e){return e[0]+'='+e[1]}).join(',')",
            "a=1,b=2",
        ),
        ("Array.from(new Headers({a:'1',b:'2'}).keys()).join(',')", "a,b"),
        ("Array.from(new Headers({a:'1',b:'2'}).values()).join(',')", "1,2"),
        (
            "var s=''; for (var e of new Headers({a:'1',b:'2'})) { s += e[0]+e[1]; } s",
            "a1b2",
        ),
        // `response.headers` が丸ごと欠落しておらず、本物の `Headers`（メソッド持ち）
        // が返ること。この処理系はレスポンスヘッダを捕捉していないため中身は
        // 常に空になる。
        (
            "typeof (await fetch('data:,hi')).headers.get",
            "function",
        ),
        // `xhr.getResponseHeader(name)` が丸ごと未対応で「関数ではない」の
        // TypeError になっていた。
        (
            "var x=new XMLHttpRequest(); x.open('GET','data:,hi'); x.send(); x.getResponseHeader('x') === null",
            "true",
        ),
        // XMLHttpRequest（同期。data: でオフライン検証）
        ("typeof XMLHttpRequest", "function"),
        ("var x=new XMLHttpRequest(); x.open('GET','data:,hi'); x.send(); x.responseText", "hi"),
        ("var x=new XMLHttpRequest(); x.open('GET','data:,hi'); x.send(); x.status", "200"),
        ("var x=new XMLHttpRequest(); x.open('GET','data:,hi'); x.send(); x.readyState", "4"),
        // `xhr.statusText` がコンストラクタで空文字列初期化されたきり `send()` 完了後も
        // 一切更新されないバグだった（`Response.prototype.statusText` と同種）。
        ("var x=new XMLHttpRequest(); x.open('GET','data:,hi'); x.send(); x.statusText", "OK"),
        ("var g=''; var x=new XMLHttpRequest(); x.onload=function(){g=x.responseText}; x.open('GET','data:,YO'); x.send(); g", "YO"),
        ("var g=''; var x=new XMLHttpRequest(); x.addEventListener('load',function(){g='L'+x.status}); x.open('GET','data:,q'); x.send(); g", "L200"),
        // `xhr.removeEventListener` が丸ごと未対応で、呼び出すと「関数ではない」の
        // TypeError になっていた。
        (
            "var g=''; var x=new XMLHttpRequest(); var fn=function(){g='L'}; x.addEventListener('load',fn); x.removeEventListener('load',fn); x.open('GET','data:,q'); x.send(); g",
            "",
        ),
        (
            "typeof new XMLHttpRequest().removeEventListener",
            "function",
        ),
        ("var x=new XMLHttpRequest(); x.open('GET','data:application/json,{\"n\":5}'); x.send(); JSON.parse(x.responseText).n", "5"),
        // fetch/XHR の POST オプション配線（data: は method 非依存で本文を返す＝経路確認）
        ("await (await fetch('data:,hi', {method:'POST', body:'x'})).text()", "hi"),
        ("(await fetch('data:,ok', {method:'POST', headers:{'Content-Type':'application/json'}, body:'{}'})).status", "200"),
        ("var x=new XMLHttpRequest(); x.open('POST','data:,ok'); x.setRequestHeader('Content-Type','application/json'); x.send('{\"a\":1}'); x.responseText", "ok"),
        ("var x=new XMLHttpRequest(); x.open('POST','data:,z'); x.send(); x.status", "200"),
        // RegExp
        ("/\\d+/.test('abc123')", "true"),
        ("/^\\d+$/.test('abc')", "false"),
        ("'2026-06-15'.match(/(\\d+)-(\\d+)-(\\d+)/)[2]", "06"),
        ("'hello world'.replace(/o/g, '0')", "hell0 w0rld"),
        ("'a1b2c3'.replace(/\\d/g, m => '[' + m + ']')", "a[1]b[2]c[3]"),
        ("'one,two;three four'.split(/[,; ]/).join('|')", "one|two|three|four"),
        ("'foobarbaz'.match(/a/g).length", "2"),
        ("new RegExp('[A-Z]+').test('hello WORLD')", "true"),
        ("'Hello'.replace(/(\\w)(\\w+)/, '$2$1')", "elloH"),
        ("'price: $42'.match(/\\$(\\d+)/)[1]", "42"),
        ("/cat/i.test('CAT')", "true"),
        ("'a,b,,c'.split(/,/).length", "4"),
        // RegExp `y`（sticky）フラグ（ES2015）: lastIndex の位置でのみマッチを試みる
        // （`g` と違い前方探索しない）。dotAll/sticky ゲッタープロパティも合わせて検証。
        ("/x/y.sticky", "true"),
        ("/x/g.sticky", "false"),
        ("/./s.dotAll", "true"),
        ("/./.dotAll", "false"),
        (
            "var re=/foo/y; re.lastIndex=3; re.test('xxxfoo')",
            "true",
        ),
        (
            "var re=/foo/y; re.lastIndex=2; re.test('xxxfoo')",
            "false",
        ),
        (
            "var re=/foo/y; var a=re.exec('foofoo').index; var b=re.exec('foofoo').index; a+','+b",
            "0,3",
        ),
        // RegExp `d`（hasIndices）フラグ（ES2022）: exec() 結果に各キャプチャの
        // [start,end) 文字インデックスを持つ indices 配列を追加する。
        ("/x/d.hasIndices", "true"),
        ("/x/.hasIndices", "false"),
        (
            "var m=/(foo)(bar)/d.exec('xxfoobar'); m.indices[0].join(',')",
            "2,8",
        ),
        (
            "var m=/(foo)(bar)/d.exec('xxfoobar'); m.indices[1].join(',')+'/'+m.indices[2].join(',')",
            "2,5/5,8",
        ),
        (
            "var m=/(foo)(baz)?/d.exec('foo'); typeof m.indices[2]",
            "undefined",
        ),
        ("/x/.exec('x').indices", "undefined"),
        // setInterval: 発火確認は同一 eval 内では行えない（コールバックは
        // event_loop の次 tick で発火するため、登録直後は n=0 が正しい）。
        // 複数回発火の検証は下の「2段階評価テスト」で行う。
        // clearInterval: 登録直後にクリアすれば未発火のまま n=0。
        ("var n=0; var id=setInterval(function(){n++;}, 10); clearInterval(id); n", "0"),
        // window.innerWidth / innerHeight
        ("typeof window.innerWidth", "number"),
        ("typeof window.innerHeight", "number"),
        // XMLHttpRequest 任意メソッド（PUT/DELETE/PATCH）。data: URL は同期・無ネットワークで
        // メソッド非依存に 200+ボディを返すため、do_http_request→web_request 経路が
        // GET/POST 以外でも例外なく通ることを決定論的に検証できる。
        ("var x=new XMLHttpRequest(); x.open('PUT','data:text/plain,HELLO'); x.send('body'); x.status", "200"),
        ("var x=new XMLHttpRequest(); x.open('PUT','data:text/plain,HELLO'); x.send('body'); x.responseText", "HELLO"),
        ("var x=new XMLHttpRequest(); x.open('DELETE','data:text/plain,GONE'); x.send(); x.status", "200"),
        ("var x=new XMLHttpRequest(); x.open('DELETE','data:text/plain,GONE'); x.send(); x.responseText", "GONE"),
        ("var x=new XMLHttpRequest(); x.open('PATCH','data:text/plain,Pdata'); x.send('d'); x.responseText", "Pdata"),
        // 小文字メソッドも web_request 側で大文字正規化され通ること。
        ("var x=new XMLHttpRequest(); x.open('put','data:text/plain,low'); x.send('b'); x.responseText", "low"),
        // history.back/forward/go: ナビ要求を history._pending_nav（相対移動量）に積む。
        // 実ナビはホスト側 process_pending_nav が回収・実行するため、ここでは積算値を検証。
        ("history.back(); history._pending_nav", "-1"),
        ("history.forward(); history._pending_nav", "1"),
        ("history.go(-2); history._pending_nav", "-2"),
        ("history.back(); history.back(); history._pending_nav", "-2"),
        ("history.go(0); history._pending_nav || 0", "0"),
        // popstate リスナ登録は window の隠し配列へ蓄積される（発火はホスト主導）。
        ("window.addEventListener('popstate', function(){}); window._popstate_listeners.length", "1"),
        // scroll リスナも window の隠し配列 _scroll_listeners へ蓄積される（発火はホスト主導）。
        ("window.addEventListener('scroll', function(){}); window._scroll_listeners.length", "1"),
        ("window.addEventListener('scroll', function(){}); window.addEventListener('scroll', function(){}); window._scroll_listeners.length", "2"),
        // window.scrollY 初期値は 0（ホストが fire_scroll で更新する）。
        ("window.scrollY", "0"),
        // `window.postMessage()`（丸ごと未対応だった。フレーム分離が無いため
        // 同一 window 上の 'message' リスナへ同期配送する簡略実装）。
        (
            "var got=null; window.addEventListener('message', function(e){ got=e.data; }); \
             window.postMessage({x:1}); got.x",
            "1",
        ),
        (
            "var t=null; window.addEventListener('message', function(e){ t=e.type; }); \
             window.postMessage('hi'); t",
            "message",
        ),
        // `window.addEventListener(type, fn, {signal})`（丸ごと未対応だった。
        // `AbortController` でリスナを一括解除する定番パターン。2026-07-14
        // 発見・実装）。abort 後は発火しなくなる。
        (
            "var c=new AbortController(); var n=0; \
             window.addEventListener('message', function(){n++;}, {signal: c.signal}); \
             window.postMessage('a'); c.abort(); window.postMessage('b'); n",
            "1",
        ),
        // 登録前に既に abort 済みの signal を渡した場合は登録自体が行われない。
        (
            "var c=new AbortController(); c.abort(); var n=0; \
             window.addEventListener('message', function(){n++;}, {signal: c.signal}); \
             window.postMessage('a'); n",
            "0",
        ),
        // ---- Proxy / Reflect ----
        // get トラップ: プロパティ読み取りを横取りする。
        ("var p=new Proxy({}, {get:function(t,k){return 'G:'+k;}}); p.foo", "G:foo"),
        // get トラップ未定義なら target へフォワード。
        ("var p=new Proxy({a:42}, {}); p.a", "42"),
        // set トラップ: 書き込みを横取りして target に別キーで格納。
        ("var log=''; var p=new Proxy({}, {set:function(t,k,v){t['_'+k]=v;return true;}}); p.x=9; p._x", "9"),
        // set トラップ未定義なら target に直接書く。
        ("var p=new Proxy({}, {}); p.y=7; p.y", "7"),
        // has トラップ: in 演算子を横取り。
        ("var p=new Proxy({}, {has:function(t,k){return k==='magic';}}); ('magic' in p)", "true"),
        ("var p=new Proxy({}, {has:function(t,k){return k==='magic';}}); ('other' in p)", "false"),
        // has トラップ未定義なら target の存在判定にフォワード。
        ("var p=new Proxy({z:1}, {}); ('z' in p)", "true"),
        ("var p=new Proxy({z:1}, {}); ('w' in p)", "false"),
        // deleteProperty トラップ: `delete p.prop` を横取り。以前はここが未対応で、
        // トラップ呼び出しはおろか target へのフォワードすら行われず常に何も削除せず
        // `true` を返すだけの黙殺バグだった。
        (
            "var log=''; var p=new Proxy({a:1}, {deleteProperty:function(t,k){log+=k; delete t[k]; return true;}}); delete p.a; log + ':' + ('a' in p)",
            "a:false",
        ),
        // deleteProperty トラップ未定義なら target への delete にフォワードする。
        ("var p=new Proxy({a:1}, {}); delete p.a; ('a' in p)", "false"),
        // `Index`（`delete p['a']`）経由でも同じくフォワードされる。
        ("var p=new Proxy({a:1}, {}); delete p['a']; ('a' in p)", "false"),
        // `Object.defineProperty`/`Object.getOwnPropertyDescriptor` も Proxy 自身の
        // 意味の無い `.props` に書き込む/読み取るだけで target に一切反映・反射されない
        // バグだった。target フォワードで対応（trap 呼び出しまでは非対応）。
        (
            "var t={}; var p=new Proxy(t, {}); Object.defineProperty(p, 'x', {value:5}); t.x",
            "5",
        ),
        (
            "var p=new Proxy({x:5}, {}); Object.getOwnPropertyDescriptor(p, 'x').value",
            "5",
        ),
        // apply トラップ: 関数呼び出しを横取り。
        ("var f=function(a,b){return a+b;}; var p=new Proxy(f, {apply:function(t,thiz,args){return args[0]*args[1];}}); p(3,4)", "12"),
        // apply トラップ未定義なら target を普通に呼ぶ。
        ("var f=function(a,b){return a+b;}; var p=new Proxy(f, {}); p(3,4)", "7"),
        // construct トラップ: new を横取り。
        ("function C(){} var p=new Proxy(C, {construct:function(t,args){return {made:args[0]};}}); (new p(99)).made", "99"),
        // construct トラップ未定義なら target を new する。
        ("function C(x){this.v=x;} var p=new Proxy(C, {}); (new p(5)).v", "5"),
        // Reflect.get / set
        ("var o={a:1}; Reflect.set(o,'a',8); Reflect.get(o,'a')", "8"),
        // Reflect.has
        ("Reflect.has({k:1},'k')", "true"),
        ("Reflect.has({k:1},'x')", "false"),
        // Reflect.deleteProperty
        ("var o={a:1,b:2}; Reflect.deleteProperty(o,'a'); ('a' in o)", "false"),
        // Reflect.ownKeys
        ("Reflect.ownKeys({a:1,b:2,c:3}).length", "3"),
        // Reflect.defineProperty
        ("var o={}; Reflect.defineProperty(o,'x',{value:42}); o.x", "42"),
        // Reflect.apply
        ("Reflect.apply(function(a,b){return a-b;}, null, [10,3])", "7"),
        // Reflect.apply/construct の argumentsList は仕様上 array-like 全般
        // （実配列に限らない）を受け付けるべきだが、以前は `&mut Interp` を持たない
        // `iterable_values` を使っており、素の array-like を渡すと引数が消えていた。
        (
            "Reflect.apply(function(a,b){return a-b;}, null, {0:10,1:3,length:2})",
            "7",
        ),
        // Reflect.construct
        ("function P(x){this.x=x;} Reflect.construct(P,[77]).x", "77"),
        (
            "function P(x){this.x=x;} Reflect.construct(P,{0:77,length:1}).x",
            "77",
        ),
        // Reflect.get がプロトタイプ連鎖を辿る。
        ("var base={greet:'hi'}; var o=Object.create(base); Reflect.get(o,'greet')", "hi"),
        // Proxy + Reflect 併用: get をログしつつ target にフォワード。
        ("var p=new Proxy({n:5}, {get:function(t,k){return Reflect.get(t,k)*2;}}); p.n", "10"),
        // 配列を包む Proxy の get（数値インデックス）。
        ("var p=new Proxy([10,20,30], {get:function(t,k){return Reflect.get(t,k);}}); p[1]", "20"),
        // ネストした Proxy（二重ラップ）。
        ("var inner=new Proxy({v:1},{get:function(t,k){return 100;}}); var outer=new Proxy(inner,{}); outer.v", "100"),
        // WeakMap
        ("var wm=new WeakMap(); var k={}; wm.set(k,42); wm.get(k)", "42"),
        ("var wm=new WeakMap(); var k={}; wm.set(k,1); wm.has(k)", "true"),
        ("var wm=new WeakMap(); var k={}; wm.set(k,1); wm.delete(k); wm.has(k)", "false"),
        // WeakSet
        ("var ws=new WeakSet(); var o={}; ws.add(o); ws.has(o)", "true"),
        ("var ws=new WeakSet(); var o={}; ws.add(o); ws.delete(o); ws.has(o)", "false"),
        // `WeakMap`/`WeakSet` は仕様上オブジェクト以外のキー/値を拒否し `TypeError` を
        // 投げるべきだが、以前は型を一切検証せず静かに成功していたバグ。
        (
            "try { new WeakMap().set(1,'x'); 'no-throw' } catch(e) { 'caught' }",
            "caught",
        ),
        (
            "try { new WeakSet().add('x'); 'no-throw' } catch(e) { 'caught' }",
            "caught",
        ),
        // `new WeakMap(iterable)`/`new WeakSet(iterable)` の初期化引数が `Map` と違い
        // 完全に無視されていた（常に空になるバグ）。
        ("var k1={}; var wm=new WeakMap([[k1,1]]); wm.get(k1)", "1"),
        ("var o1={}; var ws=new WeakSet([o1]); ws.has(o1)", "true"),
        // WeakRef
        ("var o={v:7}; var wr=new WeakRef(o); wr.deref().v", "7"),
        // Symbol 関数（AtmOS では文字列近似）
        ("typeof Symbol('x')", "string"),
        ("Symbol('a') === Symbol('a')", "false"),
        ("Symbol.for('x') === Symbol.for('x')", "true"),
        // `Symbol.keyFor`（`Symbol.for` の逆引き）が丸ごと未対応だった。
        ("Symbol.keyFor(Symbol.for('mykey'))", "mykey"),
        ("typeof Symbol.keyFor(Symbol('local'))", "undefined"),
        ("typeof Symbol.iterator", "string"),
        // MutationObserver — typeof で存在確認。
        ("typeof MutationObserver", "function"),
        // MutationObserver — コンストラクタが呼べる。
        ("var mo = new MutationObserver(function(){}); typeof mo.observe", "function"),
        // MutationObserver — disconnect と takeRecords が存在する。
        ("var mo = new MutationObserver(function(){}); typeof mo.disconnect + ',' + typeof mo.takeRecords", "function,function"),
        // MutationObserver — takeRecords は初期状態で空配列。
        ("var mo = new MutationObserver(function(){}); mo.takeRecords().length", "0"),
        // MutationObserver — attributeOldValue が丸ごと未対応で oldValue が常に
        // null 固定だったバグ（以前は old_value 自体を捕捉していなかった）。
        (
            "var el=document.createElement('div'); el.setAttribute('foo','bar'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:true,attributeOldValue:true}); \
             el.setAttribute('foo','baz'); var r=mo.takeRecords(); \
             r.length+','+r[0].attributeName+','+r[0].oldValue",
            "1,foo,bar",
        ),
        // MutationObserver — attributeFilter が丸ごと未対応で、フィルタ対象外の
        // 属性変化まで常に通知されてしまっていたバグ。
        (
            "var el=document.createElement('div'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:true,attributeFilter:['foo']}); \
             el.setAttribute('bar','x'); el.setAttribute('foo','y'); \
             var r=mo.takeRecords(); r.length+','+r[0].attributeName",
            "1,foo",
        ),
        // MutationObserver — removeAttribute() が非対称に通知漏れしていたバグ
        // （setAttribute() は既に notify_attribute を呼んでいたが removeAttribute()
        // 側だけこの呼び出し自体が丸ごと欠けていた）。
        (
            "var el=document.createElement('div'); el.setAttribute('foo','bar'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:true,attributeOldValue:true}); \
             el.removeAttribute('foo'); var r=mo.takeRecords(); \
             r.length+','+r[0].attributeName+','+r[0].oldValue",
            "1,foo,bar",
        ),
        // MutationObserver — classList.add()/.remove() が「class」属性を書き換える
        // にもかかわらず notify_attribute を一切呼んでおらず通知漏れしていたバグ
        // （setAttribute('class',...)/removeAttribute() 経由の変更は通知されるのに
        // classList 経由だけ抜けていた非対称ペア）。
        (
            "var el=document.createElement('div'); el.className='a'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:true,attributeOldValue:true}); \
             el.classList.add('b'); var r=mo.takeRecords(); \
             r.length+','+r[0].attributeName+','+r[0].oldValue",
            "1,class,a",
        ),
        (
            "var el=document.createElement('div'); el.className='a b'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:true,attributeOldValue:true}); \
             el.classList.remove('b'); var r=mo.takeRecords(); \
             r.length+','+r[0].attributeName+','+r[0].oldValue",
            "1,class,a b",
        ),
        // MutationObserver — style.xxx=/.cssText= が「style」属性を書き換える
        // にもかかわらず notify_attribute を一切呼んでいなかったバグ（classList と
        // 同型の非対称ペア）。
        (
            "var el=document.createElement('div'); el.style.color='red'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:true,attributeOldValue:true}); \
             el.style.color='blue'; var r=mo.takeRecords(); \
             r.length+','+r[0].attributeName+','+r[0].oldValue",
            "1,style,color: red",
        ),
        // MutationObserver — 仕様上`attributeOldValue`/`attributeFilter`が
        // 指定され`attributes`自体が省略された場合は`attributes`を暗黙的に
        // `true`とみなすべきところ、この暗黙有効化ロジックが丸ごと無く
        // `observe(el,{attributeOldValue:true})`という定番の省略記法
        // （`attributes:true`を明示せずとも動くのが仕様）が黙って何も
        // 監視しないバグだった。2026-07-17 発見・実装。
        (
            "var el=document.createElement('div'); el.setAttribute('data-x','1'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributeOldValue:true}); \
             el.setAttribute('data-x','2'); var r=mo.takeRecords(); \
             r.length+','+r[0].type",
            "1,attributes",
        ),
        // `attributeFilter`のみ指定（`attributes`省略）でも同様に暗黙有効化される。
        (
            "var el=document.createElement('div'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributeFilter:['data-x']}); \
             el.setAttribute('data-x','1'); var r=mo.takeRecords(); \
             r.length",
            "1",
        ),
        // `characterDataOldValue`のみ指定（`characterData`省略）でも同様。
        (
            "var el=document.createElement('div'); el.textContent='hi'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{characterDataOldValue:true, subtree:true}); \
             el.textContent='bye'; var r=mo.takeRecords(); \
             r.length+','+r[0].type+','+r[0].oldValue",
            "1,characterData,hi",
        ),
        // `attributes:false`を明示している場合は暗黙有効化しない（明示指定を
        // 尊重する。`attributes_specified.is_none()`条件の裏側の確認）。
        (
            "var el=document.createElement('div'); el.setAttribute('data-x','1'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{attributes:false, attributeOldValue:true}); \
             el.setAttribute('data-x','2'); var r=mo.takeRecords(); \
             r.length",
            "0",
        ),
        // MutationObserver — el.innerHTML=... が childList の変化を一切通知して
        // いなかったバグ（appendChild/removeChild/insertBefore/replaceChild は
        // 既に notify_child_list を呼んでいたのに、最も頻繁に使われる innerHTML
        // 代入だけがこの呼び出しを欠いていた）。
        (
            "var el=document.createElement('div'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{childList:true}); \
             el.innerHTML='<span>hi</span>'; var r=mo.takeRecords(); \
             r.length+','+r[0].type+','+r[0].addedNodes.length",
            "1,childList,1",
        ),
        // MutationObserver — 子が1件も無い要素への textContent=... 代入
        // （新規テキストノードを1件追加する経路）も childList を通知していなかった。
        (
            "var el=document.createElement('div'); \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{childList:true}); \
             el.textContent='hi'; var r=mo.takeRecords(); \
             r.length+','+r[0].type+','+r[0].addedNodes.length",
            "1,childList,1",
        ),
        // MutationObserver — `characterData`オプションが丸ごと未対応だった
        // （`childList`/`attributes`は既に対応済みで`characterData`だけ抜けて
        // いた兄弟ギャップ。テキストノードが既に存在する要素への
        // `textContent`再代入は`characterData`変化として通知されるべき
        // ところ、対応する通知経路自体が存在せず`observe(el,
        // {characterData:true})`を指定してもコールバックが一切呼ばれ
        // なかった。2026-07-17 発見・実装）。
        (
            "var el=document.createElement('div'); el.textContent='hi'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{characterData:true, subtree:true}); \
             el.textContent='bye'; var r=mo.takeRecords(); \
             r.length+','+r[0].type",
            "1,characterData",
        ),
        // `characterDataOldValue:true`で変更前のテキストを取得できる。
        (
            "var el=document.createElement('div'); el.textContent='hi'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{characterData:true, characterDataOldValue:true, subtree:true}); \
             el.textContent='bye'; var r=mo.takeRecords(); \
             r[0].oldValue",
            "hi",
        ),
        // 値が実質変化していない代入（同じ文字列への再代入）は通知しない。
        (
            "var el=document.createElement('div'); el.textContent='hi'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{characterData:true, subtree:true}); \
             el.textContent='hi'; var r=mo.takeRecords(); r.length",
            "0",
        ),
        // `characterData`未指定（既定false）ならテキスト変化を通知しない
        // （`childList:true`のみ指定している場合、テキストノードの中身が
        // 変わっただけでは子ノードの追加/削除ではないため無関係）。
        (
            "var el=document.createElement('div'); el.textContent='hi'; \
             var mo=new MutationObserver(function(){}); \
             mo.observe(el,{childList:true}); \
             el.textContent='bye'; var r=mo.takeRecords(); r.length",
            "0",
        ),
        // Object.defineProperty — データ記述子。
        ("var o={}; Object.defineProperty(o,'x',{value:42,writable:true}); o.x", "42"),
        // Object.defineProperty — getter。
        ("var o={_v:7}; Object.defineProperty(o,'v',{get:function(){return this._v*2;}}); o.v", "14"),
        // Object.defineProperty — setter + getter。
        ("var o={_x:0}; Object.defineProperty(o,'x',{get:function(){return this._x;},set:function(v){this._x=v+1;}}); o.x=9; o.x", "10"),
        // Object.defineProperty — setterのみ（getterなし→undefined）。
        ("var o={_s:''}; Object.defineProperty(o,'s',{set:function(v){this._s=v;}}); o.s='hi'; o._s", "hi"),
        // `__defineGetter__`/`__defineSetter__`/`__lookupGetter__`/
        // `__lookupSetter__`（Annex B.3.1）が丸ごと未対応だった。
        ("var o={_v:7}; o.__defineGetter__('v', function(){return this._v*2;}); o.v", "14"),
        ("var o={_x:0}; o.__defineSetter__('x', function(v){this._x=v+1;}); o.x=9; o._x", "10"),
        // getter/setter を別々に定義しても互いを上書きしない。
        (
            "var o={_x:1}; o.__defineGetter__('x', function(){return this._x;}); \
             o.__defineSetter__('x', function(v){this._x=v;}); o.x=5; o.x",
            "5",
        ),
        ("var o={}; o.__defineGetter__('v', function(){return 1;}); typeof o.__lookupGetter__('v')", "function"),
        ("var o={}; typeof o.__lookupGetter__('nope')", "undefined"),
        // Object.defineProperties — 複数。
        ("var o={}; Object.defineProperties(o,{a:{value:1},b:{value:2}}); o.a+o.b", "3"),
        // getter で動的値を返す。
        ("var o={n:0}; Object.defineProperty(o,'next',{get:function(){return ++this.n;}}); o.next; o.next; o.next", "3"),
        // Object.getOwnPropertyDescriptor — データ記述子。
        ("var o={x:5}; Object.getOwnPropertyDescriptor(o,'x').value", "5"),
        // Object.getOwnPropertyDescriptor — アクセサ記述子。
        ("var o={}; Object.defineProperty(o,'v',{get:function(){return 99;}}); typeof Object.getOwnPropertyDescriptor(o,'v').get", "function"),
        // Object.getOwnPropertyDescriptor — 存在しないキー→undefined。
        ("Object.getOwnPropertyDescriptor({x:1},'y')", "undefined"),
        // Object.getOwnPropertyDescriptors — 全記述子。
        ("var o={a:1}; Object.defineProperty(o,'b',{get:function(){return 2;}}); Object.getOwnPropertyDescriptors(o).a.value + Object.getOwnPropertyDescriptors(o).b.get()", "3"),
        // getter/setter リテラル構文（ES2015。Object.defineProperty 経由でのみ可能だった
        // アクセサ定義を、オブジェクトリテラル/クラス本体で直接書けるようにする）。
        // オブジェクトリテラルの getter。
        ("var o={_v:7, get v(){return this._v*2;}}; o.v", "14"),
        // オブジェクトリテラルの getter+setter。
        ("var o={_x:0, get x(){return this._x;}, set x(v){this._x=v+1;}}; o.x=9; o.x", "10"),
        // "get"/"set" という名前そのもののプロパティ/メソッドは従来通り動作する
        // （2トークン先読みでアクセサと誤認しないこと）。
        ("var o={get: 5}; o.get", "5"),
        ("var o={get(){return 7;}}; o.get()", "7"),
        // クラスの getter。
        (
            "class Circle { constructor(r){this.r=r;} get area(){return Math.round(Math.PI*this.r*this.r);} } new Circle(2).area",
            "13",
        ),
        // クラスの getter+setter（private フィールド風の下線プレフィックス）。
        (
            "class Box { constructor(){this._w=0;} get w(){return this._w;} set w(v){this._w=v<0?0:v;} } var b=new Box(); b.w=-5; b.w",
            "0",
        ),
        // static getter。
        (
            "class Config { static get version(){return '1.0';} } Config.version",
            "1.0",
        ),
        // Array.prototype.splice — 要素削除と返値。
        ("var a=[1,2,3,4]; var r=a.splice(1,2); r.join(',')+'/'+a.join(',')", "2,3/1,4"),
        // splice — 挿入。
        ("var a=[1,4]; a.splice(1,0,2,3); a.join(',')", "1,2,3,4"),
        // lastIndexOf。
        ("[1,2,3,2,1].lastIndexOf(2)", "3"),
        // copyWithin。
        ("[1,2,3,4,5].copyWithin(0,3).join(',')", "4,5,3,4,5"),
        // copyWithin — 負のインデックス（末尾からのオフセット）。
        ("[1,2,3,4,5].copyWithin(-2,0).join(',')", "1,2,3,1,2"),
        // copyWithin — end 引数で範囲を限定。
        ("[1,2,3,4,5].copyWithin(0,3,4).join(',')", "4,2,3,4,5"),
        // toSorted — 元配列を変更しない。
        ("var a=[3,1,2]; var s=a.toSorted(); a[0]+'/'+s.join(',')", "3/1,2,3"),
        // sort — undefined は比較関数に渡さず常に末尾に送る(SortCompare の特別扱い)。
        ("[undefined,3,undefined,1,2].sort((a,b)=>a-b).join(',')", "1,2,3,,"),
        ("[undefined,3,1,2].sort().join(',')", "1,2,3,"),
        ("[undefined,3,1,2].toSorted((a,b)=>a-b).join(',')", "1,2,3,"),
        // 配列の数値変換(ToPrimitive→ToNumber)。以前は Object 全般と同じく常に NaN だった。
        ("[5]*2", "10"),
        ("[]+1", "1"),
        ("['5']-2", "3"),
        ("[1,2]*1", "NaN"),
        // `Value::to_number` にも同種の Proxy 素通しバグがあり、`Array` は
        // 特別扱いされているのに `Proxy` で包むと常に `NaN` になっていた
        // （`Array.isArray`/`to_js_string` 等は既に透過性修正済みだった）。
        ("new Proxy([5],{})*2", "10"),
        ("+new Proxy([5],{})", "5"),
        // 緩やか等価(==)で Object(配列)と Number/String を比較。以前はどの分岐にも
        // 該当せず常に false になっていた。
        ("[5]==5", "true"),
        ("[5]=='5'", "true"),
        ("''==[]", "true"),
        ("[1,2]==5", "false"),
        // Number("0x..")/("0o..")/("0b..") 整数リテラル変換。以前は NaN 固定だった。
        ("Number('0x1F')", "31"),
        ("Number('0o17')", "15"),
        ("Number('0b101')", "5"),
        ("+'0xff'", "255"),
        // String.prototype.normalize — 丸ごと欠落していた。Unicode 分解/合成テーブルが無い
        // ため恒等変換の簡略実装だが、少なくとも呼び出せて有効な form は通ることを確認。
        ("'abc'.normalize()", "abc"),
        ("'abc'.normalize('NFD')", "abc"),
        ("(function(){ try { 'x'.normalize('bogus'); return 'no-throw'; } catch(e) { return 'threw'; } })()", "threw"),
        // 西欧言語の分音符付きラテン文字に限定した部分実装の NFC/NFD 検証
        ("'e\\u0301'.normalize('NFC') === '\\u00e9'", "true"),
        ("'\\u00e9'.normalize('NFD') === 'e\\u0301'", "true"),
        ("'\\u00e9'.normalize('NFC') === '\\u00e9'", "true"),
        // オプショナルチェイニング `a?.[b]`（computed member）。以前は Index に optional
        // フラグ自体が存在せず、常に通常のプロパティアクセスとして評価され null/undefined
        // で TypeError になっていた（`a?.b` の識別子版は動いていたが `[]` 版だけ壊れていた）。
        ("var a=null; a?.['x']", "undefined"),
        ("var a=undefined; a?.[0]", "undefined"),
        ("var a=[1,2,3]; a?.[1]", "2"),
        ("var f=null; f?.['x'](1,2)", "undefined"),
        // オプショナルチェイン全体の短絡伝播。以前は直近1段しか短絡せず `a?.b.c` は
        // `a` が null/undefined のとき後続の `.c` アクセスで TypeError になっていた。
        ("var a=null; a?.b.c", "undefined"),
        ("var a=undefined; a?.b.c.d", "undefined"),
        ("var a=null; a?.b[0].c", "undefined"),
        ("var a=null; a?.b()", "undefined"),
        ("var o={b:{c:5}}; o?.b.c", "5"),
        // for...in がプロトタイプ連鎖上の継承プロパティを列挙しないバグ。以前は自身の
        // プロパティのみだった。
        ("(function(){ function Base(){} Base.prototype.x=1; function D(){this.y=2;} D.prototype=Object.create(Base.prototype); var d=new D(); var ks=[]; for(var k in d) ks.push(k); return ks.sort().join(','); })()", "constructor,x,y"),
        // 自身のプロパティがプロトタイプ側の同名キーを覆い隠す(重複しない)ことも確認。
        ("(function(){ function Base(){} Base.prototype.x=1; function D(){this.x=99;} D.prototype=Object.create(Base.prototype); var d=new D(); var ks=[]; for(var k in d) ks.push(k); return ks.sort().join(','); })()", "constructor,x"),
        // `in` 演算子・for-in が accessors(getter/setter 限定プロパティ)専用マップを
        // 見ておらず「無い」扱いになっていたバグ。
        ("'x' in {get x(){return 1;}}", "true"),
        ("(function(){ var o={get x(){return 1;}}; var ks=[]; for(var k in o) ks.push(k); return ks.join(','); })()", "x"),
        // Object.keys/values/entries/assign も同じ accessors 見落としバグがあった。
        ("Object.keys({get x(){return 1;}}).join(',')", "x"),
        ("Object.values({get x(){return 42;}}).join(',')", "42"),
        ("JSON.stringify(Object.entries({get x(){return 7;}}))", "[[\"x\",7]]"),
        ("Object.assign({}, {get x(){return 9;}}).x", "9"),
        // JSON.stringify も同じ accessors 見落としバグがあった。
        ("JSON.stringify({get x(){return 5;}})", "{\"x\":5}"),
        // オブジェクトスプレッド {...src} も同じ accessors 見落としバグがあった。
        ("({...{get x(){return 3;}}}).x", "3"),
        ("var s={get x(){return 1;}}; var o={...s, y:2}; o.x+','+o.y", "1,2"),
        // Number.prototype.toExponential/toPrecision/valueOf — 丸ごと欠落していた。
        ("(150).toExponential(2)", "1.50e+2"),
        ("(0.0012345).toExponential(3)", "1.235e-3"),
        ("(123.456).toPrecision(5)", "123.46"),
        ("(0.0001234).toPrecision(2)", "0.00012"),
        ("(123456).toPrecision(2)", "1.2e+5"),
        ("(5).valueOf()", "5"),
        // `Number.prototype.toFixed(fractionDigits)` は仕様上 `fractionDigits` が
        // 0〜100 の範囲外なら RangeError を投げる必要があるが、以前は範囲外/非有限値を
        // 黙って0にクランプするだけで上限チェックが無く、`(1).toFixed(500)` のような
        // 呼び出しが `10^500`（Infinity）経由で壊れた出力になり得た。
        ("(1).toFixed(0)", "1"),
        ("(1.5).toFixed(100).length", "102"),
        (
            "try { (1).toFixed(-1); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "try { (1).toFixed(101); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        ("(NaN).toFixed(2)", "NaN"),
        ("(Infinity).toFixed(2)", "Infinity"),
        // Array.prototype.toLocaleString / Number.prototype.toLocaleString — 丸ごと欠落。
        ("[1,2,3].toLocaleString()", "1,2,3"),
        ("[1,null,undefined,2].toLocaleString()", "1,,,2"),
        // Number.prototype.toLocaleString は `toString()` の別名でしかなく、実際のブラウザなら
        // `Intl` 非搭載でも入る3桁区切りのカンマが欠落していた（2026-07-09に修正）。
        ("(1234.5).toLocaleString()", "1,234.5"),
        ("(1234567).toLocaleString()", "1,234,567"),
        ("(123).toLocaleString()", "123"),
        ("(-1234567.89).toLocaleString()", "-1,234,567.89"),
        // `Intl` グローバルが丸ごと未対応だった。ロケール/オプション引数は無視するが、
        // `new Intl.NumberFormat().format(n)` という最頻出イディオムだけは救う最小実装。
        ("new Intl.NumberFormat().format(1234567)", "1,234,567"),
        ("new Intl.NumberFormat('en-US').format(-1234.5)", "-1,234.5"),
        ("typeof Intl.NumberFormat().format", "function"),
        ("(0).toLocaleString()", "0"),
        ("(NaN).toLocaleString()", "NaN"),
        ("(Infinity).toLocaleString()", "Infinity"),
        // Boolean プリミティブへのプロパティアクセスが一律 undefined になり、メソッド呼出
        // 自体が丸ごと欠落していたバグ（プリミティブ中 Boolean だけメソッドが皆無だった）。
        ("true.toString()", "true"),
        ("false.toString()", "false"),
        ("true.valueOf()", "true"),
        ("(false).valueOf() === false", "true"),
        // 関数の name/length が丸ごと欠落していたバグ。
        ("function foo(a,b){} foo.name", "foo"),
        ("function foo(a,b){} foo.length", "2"),
        ("function foo(a,b=1,...c){} foo.length", "1"),
        ("(function(){}).length", "0"),
        ("Math.max.length", "0"),
        // `Function.prototype.bind()` が返す関数の `.name`/`.length` が丸ごと未対応で
        // 常に `undefined` になっていた。
        // 【2026-09-26】`Function.prototype` が存在しなかった（OpenStreetMap 埋め込みで発見）。
        ("typeof Function.prototype", "object"),
        ("typeof Function.prototype.toString", "function"),
        ("function foo(){} Function.prototype.toString.call(foo).includes('foo')", "true"),
        ("function add(a,b){return a+b} Function.prototype.call.call(add, null, 2, 3)", "5"),
        ("var of = 7; of + 1", "8"),
        ("0x10000000000000000 === 18446744073709551616", "true"),
        ("function foo(a,b,c){} foo.bind(null).name", "bound foo"),
        ("function foo(a,b,c){} foo.bind(null).length", "3"),
        ("function foo(a,b,c){} foo.bind(null,1).length", "2"),
        ("function foo(a,b,c){} foo.bind(null,1,2,3,4).length", "0"),
        // 束縛済み関数の文字列化（`String(fn.bind(...))`）も専用ケースが無く
        // `[object Object]` に落ちるバグだった。
        (
            "function foo(){} String(foo.bind(null)).includes('native code')",
            "true",
        ),
        // `Object.prototype.toString.call(x)` が `this` の実際の種別を一切見ず
        // 常に `[object Object]` を返すバグだった（`lodash` 等で広く使われる
        // 型判定イディオムが配列/Map/Set/Date/RegExp/関数のいずれに対しても
        // 機能しなくなる、実用上かなり影響の大きいバグ）。
        ("Object.prototype.toString.call([1,2])", "[object Array]"),
        ("Object.prototype.toString.call({})", "[object Object]"),
        ("Object.prototype.toString.call(new Date())", "[object Date]"),
        ("Object.prototype.toString.call(/a/)", "[object RegExp]"),
        ("Object.prototype.toString.call(new Map())", "[object Map]"),
        ("Object.prototype.toString.call(new Set())", "[object Set]"),
        ("Object.prototype.toString.call(function(){})", "[object Function]"),
        ("Object.prototype.toString.call(null)", "[object Null]"),
        ("Object.prototype.toString.call(undefined)", "[object Undefined]"),
        // `Symbol.toStringTag`（クラスでカスタムタグを定義する仕組み）も一切考慮して
        // いなかった。データプロパティ/アクセサ（getter）どちらの定義方法も動くこと。
        (
            "class Foo { get [Symbol.toStringTag](){ return 'Foo'; } } Object.prototype.toString.call(new Foo())",
            "[object Foo]",
        ),
        (
            "var o={}; o['Symbol(Symbol.toStringTag)']='Bar'; Object.prototype.toString.call(o)",
            "[object Bar]",
        ),
        // NamedEvaluation（ES2015）: `const f = function(){}`/`const f = () => {}` の
        // ような無名関数式を単純な識別子へ代入すると、その識別子名を `.name` として
        // 継承する仕様が丸ごと未対応で、常に空文字列のままだった。
        ("var f = function(){}; f.name", "f"),
        ("var g = () => {}; g.name", "g"),
        // 既に名前を持つ関数式（`function foo(){}`）は変数名で上書きされない。
        ("var h = function foo(){}; h.name", "foo"),
        // object literal のプロパティ値としての無名関数式も同様にキー名を継承する。
        ("({bar: function(){}}).bar.name", "bar"),
        ("({baz: () => {}}).baz.name", "baz"),
        // メソッド短縮記法は元々キー名を持つため、この継承の影響を受けない
        // （上書きではなく「無名の場合のみ設定」であることの確認）。
        ("({qux(){}}).qux.name", "qux"),
        // structuredClone(Date/RegExp) — 実データが props に無く plain object 化に落ちて
        // 消えてしまうバグ（Map/Set と同種）。
        ("var d=new Date(2020,0,1); var c=structuredClone(d); c.getTime()===d.getTime() && c!==d", "true"),
        ("var r=/abc/gi; var c=structuredClone(r); c.source+','+c.flags+','+(c!==r)", "abc,gi,true"),
        // 分割代入の rest ({...rest}) も同じ accessors 見落としバグがあった。
        ("var o={get x(){return 1;}, y:2}; var {y, ...rest} = o; rest.x+','+rest.y", "1,undefined"),
        // hasOwnProperty/Object.hasOwn が accessors と配列インデックス/length を
        // 見落とすバグ。
        ("({get x(){return 1;}}).hasOwnProperty('x')", "true"),
        ("[1,2,3].hasOwnProperty(0)", "true"),
        ("[1,2,3].hasOwnProperty('length')", "true"),
        ("[1,2,3].hasOwnProperty(5)", "false"),
        ("Object.hasOwn({get x(){return 1;}}, 'x')", "true"),
        ("({}).toLocaleString()", "[object Object]"),
        ("[{}, {}].toLocaleString()", "[object Object],[object Object]"),
        // Object.getOwnPropertyDescriptor(s) が配列の数値インデックス/length を見落とし
        // 常に undefined になるバグ。
        ("Object.getOwnPropertyDescriptor([1,2,3], '0').value", "1"),
        ("Object.getOwnPropertyDescriptor([1,2,3], 'length').value", "3"),
        ("Object.keys(Object.getOwnPropertyDescriptors([1,2])).sort().join(',')", "0,1,length"),
        // Object.defineProperty が配列の数値インデックス/length に書き込んでも
        // 実データ(ObjKind::Array)側に反映されないバグ。
        ("var a=[1,2,3]; Object.defineProperty(a,'0',{value:99}); a[0]", "99"),
        ("var a=[1,2]; Object.defineProperty(a,'5',{value:9}); a.length+','+a[5]", "6,9"),
        ("var a=[1,2,3]; Object.defineProperty(a,'length',{value:1}); a.join(',')", "1"),
        // Array/Map/Set の Symbol.iterator が丸ごと未登録で、明示呼出し
        // (`arr[Symbol.iterator]()`)が「関数ではない」になっていたバグ。for...of は
        // 内部高速経路のため気づかれなかった。
        ("[...[1,2,3][Symbol.iterator]()].join(',')", "1,2,3"),
        ("var m=new Map([['a',1]]); [...m[Symbol.iterator]()][0].join(',')", "a,1"),
        ("[...new Set([1,2])[Symbol.iterator]()].join(',')", "1,2"),
        // entries/keys/values が本物の Iterator（`.next()`/`Symbol.iterator` 持ち）ではなく
        // 単なる配列を返しており、明示的なイテレータプロトコル駆動
        // (`const it = arr.values(); it.next()`) が「next が存在しない」で壊れていたバグ。
        ("var it=[10,20].values(); it.next().value+','+it.next().value+','+it.next().done", "10,20,true"),
        ("var it=[1,2].entries(); it.next().value.join(',')", "0,1"),
        ("var it=[1,2].keys(); it.next().value+','+it.next().value", "0,1"),
        ("var it=new Map([['a',1]]).entries(); it.next().value.join(',')", "a,1"),
        ("var it=new Set([5,6]).values(); it.next().value+','+it.next().value", "5,6"),
        ("var it=[1].values(); it[Symbol.iterator]()===it", "true"),
        // String.prototype[Symbol.iterator] が丸ごと欠落していたバグ。
        ("[...'ab'[Symbol.iterator]()].join(',')", "a,b"),
        ("var it='xy'[Symbol.iterator](); it.next().value+it.next().value+it.next().done", "xytrue"),
        // 上記の Iterator 化に伴う回帰: Array.from/new Map/new Set が新しい軽量イテレータ
        // オブジェクト（entries/keys/values の戻り値）を「iterable」として認識できず
        // 空になっていたバグ（本イテレータ導入時に発見・即修正）。
        ("Array.from([10,20].values()).join(',')", "10,20"),
        ("Array.from([1,2].entries()).map(e=>e.join(':')).join(',')", "0:1,1:2"),
        ("var m=new Map(new Map([['a',1]]).entries()); m.get('a')", "1"),
        ("var s=new Set([1,2,2,3].values()); [...s].join(',')", "1,2,3"),
        // イテレータの内部実装詳細(_items/_pos)が Object.keys/JSON.stringify/spread から
        // 見えてしまう漏れ(make_iterator 導入時に発見・即修正)。
        ("Object.keys([1,2].values()).length", "0"),
        ("JSON.stringify([1,2].values())", "{}"),
        ("Object.keys({...[1,2].values()}).length", "0"),
        // AggregateError（ES2021）が丸ごと欠落していた。Promise.any が全滅した際に
        // 最後の reject 理由しか見えず、`.errors` を持つ AggregateError も
        // 投げられていなかった。
        ("new AggregateError([1,2],'m').errors.join(',')", "1,2"),
        ("new AggregateError([],'m') instanceof Error", "true"),
        (
            "await Promise.any([Promise.reject('a'),Promise.reject('b')]).catch(e => e.name+':'+e.errors.join(','))",
            "AggregateError:a,b",
        ),
        // Date の日時文字列パース(ISO 8601)が丸ごと非対応だった（`new Date("2024-01-15")`
        // が Invalid Date になっていた）。
        ("new Date('2024-01-15').getFullYear()+'-'+(new Date('2024-01-15').getMonth()+1)+'-'+new Date('2024-01-15').getDate()", "2024-1-15"),
        ("Date.parse('2024-01-15T00:00:00Z')", "1705276800000"),
        ("Date.parse('2024-01-15T02:00:00+02:00')", "1705276800000"),
        // コロン無しタイムゾーンオフセット（`+0900` 形式。ISO 8601/ECMA-262 双方で正当）
        ("Date.parse('2024-01-15T09:00:00+0900')", "1705276800000"),
        ("Date.parse('2024-01-15T00:00:00+00')", "1705276800000"),
        ("new Date('2024-01-15T00:00:00.500Z').getTime()", "1705276800500"),
        ("isNaN(Date.parse('not a date'))", "true"),
        // RFC 2822 形式（HTTP日付ヘッダ等の定番書式）が丸ごと非対応で、ISO 8601以外の
        // 文字列は常に NaN になっていたバグ。曜日名の有無・タイムゾーンオフセット双方を
        // 確認する。
        ("Date.parse('Mon, 15 Jan 2024 00:00:00 GMT')", "1705276800000"),
        ("Date.parse('15 Jan 2024 00:00:00 GMT')", "1705276800000"),
        ("Date.parse('Mon, 15 Jan 2024 02:00:00 +0200')", "1705276800000"),
        // `Date.now`/`Date.parse` は登録済みだったが `Date.UTC` が丸ごと未対応だった。
        ("Date.UTC(2024, 0, 15) === Date.parse('2024-01-15T00:00:00Z')", "true"),
        ("new Date(Date.UTC(2024,0,15,10,30,0)).getUTCHours()", "10"),
        // 省略引数の既定値（day のみ1、他は0）。
        ("new Date(Date.UTC(2024,0)).getDate()", "1"),
        ("new Date('Mon, 15 Jan 2024 00:00:00 GMT').getFullYear()", "2024"),
        // RegExp 名前付きキャプチャグループ (?<name>...)（ES2018）が丸ごと非対応で
        // `(?<`（lookbehind と誤認され `:` フォールバックと同じ経路）を通ると壊れた
        // パース結果になり、`match.groups` は常に undefined だった。
        ("'2024-01-15'.match(/(?<year>\\d+)-(?<month>\\d+)-(?<day>\\d+)/).groups.year", "2024"),
        ("'2024-01-15'.match(/(?<year>\\d+)-(?<month>\\d+)-(?<day>\\d+)/).groups.month", "01"),
        ("/(?<a>x)(y)/.exec('xy')[2]", "y"),
        ("/(x)/.exec('x').groups", "undefined"),
        ("[...'a1 b2'.matchAll(/(?<letter>[a-z])(?<num>\\d)/g)].map(m=>m.groups.letter+m.groups.num).join(',')", "a1,b2"),
        // replace() の $<name> 置換パターン（ES2018）が丸ごと非対応だった。合わせて
        // $`（一致より前）/$'（一致より後）も未対応だった。
        ("'2024-01-15'.replace(/(?<y>\\d+)-(?<m>\\d+)-(?<d>\\d+)/, '$<d>/$<m>/$<y>')", "15/01/2024"),
        ("'abc'.replace(/b/, \"[$`|$']\")", "a[a|c]c"),
        ("'x'.replace(/(?<a>x)/, (m,a,off,str,groups)=>groups.a+'!')", "x!"),
        // RegExp の \uXXXX/\u{X...}/\xXX エスケープが丸ごと未対応で、`A` が文字コード
        // 指定ではなく `u0041`（5文字のリテラル）として誤解釈されていたバグ。
        ("/\\u0041/.test('A')", "true"),
        ("/\\u{1F600}/u.test('\\u{1F600}')", "true"),
        ("/\\x41/.test('A')", "true"),
        ("'A1'.match(/\\u0041\\d/)[0]", "A1"),
        // 文字クラス内の \uXXXX/\xXX（範囲の端点含む）も同じバグがあった。
        ("/[\\u0041-\\u005A]/.test('M')", "true"),
        ("/[\\x41-\\x5A]/.test('Z')", "true"),
        ("/[\\u0041-\\u005A]/.test('m')", "false"),
        // String.prototype.split(regexp) がキャプチャグループを結果に含めないバグ
        // （仕様上、区切りに使った正規表現のキャプチャは結果配列に挿入される）。
        ("'a1b2c'.split(/(\\d)/).join('|')", "a|1|b|2|c"),
        ("'axb'.split(/(x)|(y)/).join(',')", "a,x,,b"),
        ("'abc'.split(/b/).join(',')", "a,c"),
        // クラス/オブジェクトリテラルの async/generator メソッド短縮記法が丸ごと
        // 未認識で、`*`/`async` に遭遇するとキー解析がその場で失敗し、メンバ自体が
        // 消えるだけでなく後続メンバの解析まで壊れる重大バグだった。
        ("class C { *gen(){ yield 1; yield 2; } } [...new C().gen()].join(',')", "1,2"),
        ("await (new (class C { async f(){ return 42; } })()).f()", "42"),
        ("class C { *gen(){ yield 'a'; } method(){ return 'm'; } } var c=new C(); [...c.gen()].join(',')+c.method()", "am"),
        ("[...{ *gen(){ yield 1; yield 2; } }.gen()].join(',')", "1,2"),
        ("await { async f(){ return 'ok'; } }.f()", "ok"),
        // static + async/generator の組み合わせ、および算出メソッド名との組み合わせ。
        ("await (class C { static async f(){ return 7; } }).f()", "7"),
        ("class C { static *gen(){ yield 9; } } [...C.gen()].join(',')", "9"),
        ("class C { *[Symbol.iterator](){ yield 3; } } [...new C()].join(',')", "3"),
        ("({ async *gen(){}, method(){ return 'ok'; } }).method()", "ok"),
        // 分割代入の算出プロパティ名 `{[expr]: target}` が丸ごと未認識で、`[` に遭遇すると
        // パターン解析全体が壊れる（後続プロパティも巻き添え）バグだった。
        ("var k='x'; var {[k]: v} = {x: 42}; v", "42"),
        ("var k='a'; var {[k]: v, y} = {a: 1, y: 2}; v+','+y", "1,2"),
        ("var k='n'; function f({[k]: val}){ return val; } f({n: 7})", "7"),
        // 直前の async/generator 修飾子検出の実装ミス（"async"/"*" を常に修飾子として
        // 消費してしまい、"async" という名前の通常プロパティ/フィールド自体が壊れる
        // 新規回帰）を発見・即修正。
        ("({ async: 1, b: 2 }).async + ({ async: 1, b: 2 }).b", "3"),
        ("class C { async = 5; b = 6; } var c = new C(); c.async + c.b", "11"),
        // "static" の修飾子誤認識も同じバグ族（`static`/`async`/`*` 全てに共通の
        // 「次が `(` でなければ無条件で修飾子」という緩すぎる判定）だった。
        ("class C { static = 5; b = 6; } var c = new C(); c.static + c.b", "11"),
        ("class C { static x = 1; static method(){ return 2; } } C.x + C.method()", "3"),
        // get/set の算出プロパティ名 `get [expr](){}` がアクセサとして認識されず、
        // "get"/"set" という名前の孤立フィールド＋無関係なメソッドに分解される
        // バグだった。
        ("var k='x'; var o={ get [k](){ return 42; } }; o.x", "42"),
        ("var k='y'; var o={y:0, set [k](v){ this._y=v; } }; o.y=5; o._y", "5"),
        ("var k='z'; class C { get [k](){ return 9; } } new C().z", "9"),
        // for(let i=...) の反復ごとの束縛（per-iteration binding）が丸ごと未対応で、
        // ループ内で作ったクロージャが全て同じ最終値を捕捉してしまうバグだった
        // （`var` は対象外で仕様どおり単一束縛のまま）。
        ("var a=[]; for(let i=0;i<3;i++){ a.push(()=>i); } a.map(f=>f()).join(',')", "0,1,2"),
        ("var a=[]; for(var i=0;i<3;i++){ a.push(()=>i); } a.map(f=>f()).join(',')", "3,3,3"),
        ("var a=[]; for(let i=0;i<3;i++){ if(i===1) continue; a.push(()=>i); } a.map(f=>f()).join(',')", "0,2"),
        // for-of/for-in の let/const も同じ反復ごとの束縛が必要（var は対象外）。
        ("var a=[]; for(const x of [1,2,3]){ a.push(()=>x); } a.map(f=>f()).join(',')", "1,2,3"),
        ("var a=[]; for(var x of [1,2,3]){ a.push(()=>x); } a.map(f=>f()).join(',')", "3,3,3"),
        ("var a=[]; for(let k in {a:1,b:2}){ a.push(()=>k); } a.map(f=>f()).join(',')", "a,b"),
        // 配列プロトタイプメソッドのほぼ全てが使う共通ヘルパ this_items/this_objref が
        // Proxy を素通しできず、Proxy でラップした配列へメソッド呼出し
        // (`.map()`/`.push()` 等)すると常に空扱いになるバグだった（for...of/スプレッドは
        // 別経路で既に対応済みだったが、メソッド呼出し経由は漏れていた）。
        ("new Proxy([1,2,3],{}).map(x=>x*2).join(',')", "2,4,6"),
        ("var p=new Proxy([1,2],{}); p.push(3); p.join(',')", "1,2,3"),
        ("new Proxy([5,6,7],{}).indexOf(6)", "1"),
        // `String(proxy)`/文字列連結/テンプレートリテラル補間が使う
        // `Value::to_js_string` にも同種の Proxy 素通しバグがあり、`ObjKind::Proxy`
        // 専用ケースが無く汎用の "[object Object]" に落ちていた。
        ("String(new Proxy([1,2,3], {}))", "1,2,3"),
        ("'' + new Proxy([7,8], {})", "7,8"),
        // Map/Set の全メソッドが使う with_map/with_set にも同じ Proxy 素通しバグがあった。
        ("var p=new Proxy(new Map([['a',1]]),{}); p.get('a')", "1"),
        ("var p=new Proxy(new Set([1,2]),{}); p.add(3); [...p].join(',')", "1,2,3"),
        // WeakSet / Promise / Generator の共通ヘルパにも同じ Proxy 素通しバグがあった。
        ("var o={}; var p=new Proxy(new WeakSet([o]),{}); p.has(o)", "true"),
        ("await new Proxy(Promise.resolve(5), {}).then(x=>x*2)", "10"),
        ("function* g(){ yield 1; yield 2; } var p=new Proxy(g(),{}); [...p].join(',')", "1,2"),
        // String.fromCharCode/fromCodePoint が同じ実装を共有しており、fromCharCode の
        // サロゲートペア結合（絵文字1文字を表す ES1 以来の定番イディオム）が壊れていた。
        ("String.fromCharCode(72,105)", "Hi"),
        ("String.fromCharCode(0xD83D,0xDE00)", "\u{1F600}"),
        ("String.fromCodePoint(0x1F600)", "\u{1F600}"),
        ("String.fromCodePoint(72,105)", "Hi"),
        // Object.create(proto, propertiesObject) の第2引数が丸ごと無視されていたバグ。
        ("Object.create(null, {x:{value:5}}).x", "5"),
        ("var o=Object.create(null, {y:{value:9}, z:{value:1}}); o.y + o.z", "10"),
        // JSON.stringify の toJSON() フックが Date 専用の特別扱いのみで、任意のオブジェクトに
        // 定義できる汎用フックとして機能していなかった。
        ("JSON.stringify({toJSON(){ return 42; }})", "42"),
        ("JSON.stringify({a: {toJSON(){ return 'x'; }}})", "{\"a\":\"x\"}"),
        ("JSON.stringify([{toJSON(){ return 1; }}, 2])", "[1,2]"),
        // 数値セパレータ `_`（ES2021）が丸ごと未対応で、`1_000` の `_` の時点で数値
        // リテラルが打ち切られ、残りが別トークン（識別子）として構文解析を静かに
        // 壊すバグだった。
        ("1_000_000", "1000000"),
        ("0x1_000", "4096"),
        ("1_000.5_5", "1000.55"),
        // `0o`(8進)/`0b`(2進)リテラルがソースコード上で丸ごと未対応で、`0` だけ
        // 数値トークンとして打ち切られ `o17`/`b101` が別の識別子トークンになり
        // 構文解析が静かに壊れるバグだった（16進 `0x` は既存で対応済みだったのと非対称）。
        ("0o17", "15"),
        ("0b101", "5"),
        ("0o17 + 0b101", "20"),
        ("0b101n + 2n", "7"),
        // 文字列リテラル中の行継続（`\` の直後の改行）が仕様上「何も追加しない」はずが、
        // 改行文字そのものを値に混入させていたバグ。
        ("'abc\\\ndef'", "abcdef"),
        ("'abc\\\r\ndef'.length", "6"),
        // toReversed — 元配列を変更しない。
        ("var a=[1,2,3]; var r=a.toReversed(); a[0]+'/'+r.join(',')", "1/3,2,1"),
        // toSpliced — 元配列を変更しない。
        ("var a=[1,2,3]; var s=a.toSpliced(1,1,9); a.join(',')+'/'+s.join(',')", "1,2,3/1,9,3"),
        // toSpliced — deleteCount 省略時は末尾まで削除するが、明示的な `undefined` は
        // 仕様上 `ToIntegerOrInfinity(undefined)` = 0（省略とは異なる）扱いになる。
        ("[1,2,3].toSpliced(1).join(',')", "1"),
        ("[1,2,3].toSpliced(1, undefined).join(',')", "1,2,3"),
        // Array.prototype.concat — `Symbol.isConcatSpreadable` が丸ごと未対応で、
        // 常に `ObjKind::Array` かどうかだけで展開の有無を決めていたバグ。
        // 配列に `[Symbol.isConcatSpreadable]=false` を明示すると展開されず単一要素になる。
        (
            "var a=[1,2]; a[Symbol.isConcatSpreadable]=false; [0].concat(a).length",
            "2",
        ),
        // 非配列の array-like に `Symbol.isConcatSpreadable=true` を明示すると
        // `length`+添字プロパティから展開される。
        (
            "var o={0:'x',1:'y',length:2}; o[Symbol.isConcatSpreadable]=true; [0].concat(o).join(',')",
            "0,x,y",
        ),
        // フラグ未指定時は従来どおり配列のみ自動展開、非配列は単一要素のまま。
        ("[1].concat([2,3],4).join(',')", "1,2,3,4"),
        // `Array.prototype.join` は仕様上ジェネリックメソッド（`this` の `length` +
        // 添字プロパティだけを見る）だが、以前は `ObjKind::Array` 以外を無条件で空扱いし
        // 配列インスタンスから取り出した `join` を array-like へ `.call()` しても
        // 常に `""` になっていた（この処理系はメソッド解決を `ObjKind::Array` の
        // プロパティ取得時にのみ行う簡略実装のため、実際に呼び出し可能な関数値を
        // 得るには `Array.prototype.join` ではなく実配列インスタンスから取り出す）。
        (
            "var f=[].join; f.call({0:'a',1:'b',length:2}, '-')",
            "a-b",
        ),
        // `push`/`pop`/`shift`/`unshift` は仕様上ミューテートするメソッドの中でも
        // 特にジェネリック（`length` を介して任意の array-like を書き換える）
        // ことが要求される定番のイディオム（`Array.prototype.push.call(arguments, x)` 等）。
        (
            "var o={length:0}; var f=[].push; f.call(o,'a','b')+','+o.length+','+o[0]+','+o[1]",
            "2,2,a,b",
        ),
        (
            "var o={0:'a',1:'b',length:2}; var f=[].pop; f.call(o)+','+o.length",
            "b,1",
        ),
        (
            "var o={0:'a',1:'b',length:2}; var f=[].shift; f.call(o)+','+o.length+','+o[0]",
            "a,1,b",
        ),
        (
            "var o={0:'a',length:1}; var f=[].unshift; f.call(o,'x','y')+','+o.length+','+o[0]+','+o[1]+','+o[2]",
            "3,3,x,y,a",
        ),
        // 通常の配列に対する挙動には回帰なし。
        ("[1,2,3].join('-')", "1-2-3"),
        // `arguments.callee`（Annex B。無名関数の自己再帰呼び出しイディオム）が
        // 丸ごと未対応だった。
        (
            "var fact = function(n){ return n <= 1 ? 1 : n * arguments.callee(n - 1); }; fact(5)",
            "120",
        ),
        ("var g = function(){ return arguments.callee === g; }; g()", "true"),
        // 名前付き関数式の自己参照束縛（`(function f(){ ...f... })()` で `f` を
        // 本体内から参照できる仕様どおりの挙動）が丸ごと未対応だった。
        ("(function f(n){ return n<=1?1:n*f(n-1); })(5)", "120"),
        ("(function f(){ return typeof f; })()", "function"),
        // 外側スコープからは関数式自身の名前が見えない（仕様どおり）。
        ("(function f(){})(); typeof f", "undefined"),
        // `Array.prototype.slice` も同じジェネリックメソッド未対応バグがあった
        // （`join`/`concat` と同型。`this_items` が `ObjKind::Array` 以外を無条件で
        // 空 `Vec` 扱いしていたため array-like への適用が常に `[]` になっていた）。
        (
            "var s=[].slice; s.call({0:'a',1:'b',length:2}, 0, 1).join(',')",
            "a",
        ),
        (
            "var s=[].slice; s.call({0:'a',1:'b',2:'c',length:3}, 1).join(',')",
            "b,c",
        ),
        // 通常の配列に対する挙動には回帰なし。
        ("[1,2,3,4].slice(1,3).join(',')", "2,3"),
        // `forEach`/`map`/`filter`/`indexOf`/`includes` にも同型のジェネリックメソッド
        // 未対応バグがあった（`join`/`slice`/`concat` で修正済みの続き）。array-like
        // （`arguments`/`NodeList` 等への `.call()` の定番イディオム）への適用が
        // 「何も反復しない/常に見つからない」結果になっていた。
        (
            "var out=''; var fe=[].forEach; fe.call({0:'a',1:'b',length:2}, function(v){ out+=v }); out",
            "ab",
        ),
        (
            "var m=[].map; m.call({0:1,1:2,length:2}, function(v){ return v*2 }).join(',')",
            "2,4",
        ),
        (
            "var fl=[].filter; fl.call({0:1,1:2,2:3,length:3}, function(v){ return v>1 }).join(',')",
            "2,3",
        ),
        (
            "var io=[].indexOf; io.call({0:'a',1:'b',length:2}, 'b')",
            "1",
        ),
        (
            "var inc=[].includes; inc.call({0:'a',1:'b',length:2}, 'b')",
            "true",
        ),
        // `reduce`/`find`/`findIndex`/`some`/`every` にも同型のジェネリックメソッド
        // 未対応バグがあった（`forEach`/`map`/`filter`/`indexOf`/`includes` の続き）。
        (
            "var r=[].reduce; r.call({0:1,1:2,2:3,length:3}, function(a,v){ return a+v }, 0)",
            "6",
        ),
        (
            "var fd=[].find; fd.call({0:1,1:2,2:3,length:3}, function(v){ return v>1 })",
            "2",
        ),
        (
            "var fi=[].findIndex; fi.call({0:1,1:2,2:3,length:3}, function(v){ return v>1 })",
            "1",
        ),
        (
            "var sm=[].some; sm.call({0:1,1:2,length:2}, function(v){ return v>1 })",
            "true",
        ),
        (
            "var ev=[].every; ev.call({0:1,1:2,length:2}, function(v){ return v>0 })",
            "true",
        ),
        (
            "var at=[].at; at.call({0:1,1:2,length:2}, -1)",
            "2",
        ),
        (
            "var fl=[].findLast; fl.call({0:1,1:2,length:2}, function(v){ return v<2 })",
            "1",
        ),
        (
            "var fli=[].findLastIndex; fli.call({0:1,1:2,length:2}, function(v){ return v<2 })",
            "0",
        ),
        (
            "var fm=[].flatMap; fm.call({0:1,1:2,length:2}, function(v){ return v*2 }).join(',')",
            "2,4",
        ),
        (
            "var rr=[].reduceRight; rr.call({0:1,1:2,length:2}, function(a,v){ return a+v })",
            "3",
        ),
        (
            "var lio=[].lastIndexOf; lio.call({0:1,1:1,length:2}, 1)",
            "1",
        ),
        (
            "var fla=[].flat; fla.call({0:1,1:[2,3],length:2}).join(',')",
            "1,2,3",
        ),
        (
            "var en=[].entries; var itr=en.call({0:1,1:2,length:2}); itr.next().value.join(',')",
            "0,1",
        ),
        (
            "var ky=[].keys; var itr=ky.call({0:1,1:2,length:2}); itr.next().value+','+itr.next().value",
            "0,1",
        ),
        (
            "var vl=[].values; var itr=vl.call({0:1,1:2,length:2}); itr.next().value+','+itr.next().value",
            "1,2",
        ),
        (
            "var tls=[].toLocaleString; tls.call({0:1,1:2,length:2})",
            "1,2",
        ),
        (
            "var o={0:1,1:2,length:2}; o[Symbol.isConcatSpreadable]=true; [].concat.call(o, 3).join(',')",
            "1,2,3",
        ),
        (
            "var o={0:1,1:2,length:2}; [].concat.call(o, 3).length",
            "2",
        ),
        (
            "var ts=[].toSorted; ts.call({0:3,1:1,length:2}).join(',')",
            "1,3",
        ),
        (
            "var tr=[].toReversed; tr.call({0:1,1:2,length:2}).join(',')",
            "2,1",
        ),
        (
            "var tsp=[].toSpliced; tsp.call({0:1,1:2,length:2}, 1, 0, 9).join(',')",
            "1,9,2",
        ),
        (
            "var w=[].with; w.call({0:1,1:2,length:2}, 0, 9).join(',')",
            "9,2",
        ),
        // 通常の配列に対する挙動には回帰なし。
        ("[1,2,3].map(function(v){return v*2}).join(',')", "2,4,6"),
        // with — 元配列を変更しない。
        ("var a=[1,2,3]; var b=a.with(1,9); a[1]+'/'+b[1]", "2/9"),
        // TypeError コンストラクタ。
        ("(function(){ try { throw new TypeError('bad'); } catch(e) { return e.name+':'+e.message; } })()", "TypeError:bad"),
        // RangeError コンストラクタ。
        ("(function(){ try { throw new RangeError('oor'); } catch(e) { return e.name; } })()", "RangeError"),
        // FinalizationRegistry — register は no-op (object が取れる)。
        ("typeof new FinalizationRegistry(function(){}).register", "function"),
        // requestIdleCallback — コールバックが呼ばれ、didTimeout が false。
        ("var ok=false; requestIdleCallback(function(d){ ok = !d.didTimeout && d.timeRemaining()>0; }); ok", "true"),
        // Object.hasOwn — あり/なし。
        ("Object.hasOwn({x:1},'x')+','+Object.hasOwn({x:1},'y')", "true,false"),
        // Object.groupBy — 偶奇グループ。
        ("var g=Object.groupBy([1,2,3,4],function(n){return n%2===0?'e':'o'}); g.e.join(',')+'/'+g.o.join(',')", "2,4/1,3"),
        // Map.groupBy（ES2024）— Object.groupBy と違いキーを文字列化せず任意の値のまま使える。
        ("var m=Map.groupBy([1,2,3,4],function(n){return n%2===0?'e':'o'}); m.get('e').join(',')+'/'+m.get('o').join(',')", "2,4/1,3"),
        (
            "var kEven={}; var kOdd={}; var m=Map.groupBy([1,2,3],function(n){return n%2===0?kEven:kOdd}); m.get(kEven).join(',')+'/'+m.get(kOdd).join(',')",
            "2/1,3",
        ),
        ("Map.groupBy([1,2,3],function(n){return n}).size", "3"),
        // Object.groupBy/Map.groupBy は仕様上任意の iterable を受け付ける（配列限定ではない）。
        // 以前は実配列以外は無条件で空扱いになり Set/Map/ジェネレータが常に空グループになるバグだった。
        (
            "var g=Object.groupBy(new Set([1,2,3,4]),function(n){return n%2===0?'e':'o'}); g.e.join(',')+'/'+g.o.join(',')",
            "2,4/1,3",
        ),
        (
            "function* gen(){yield 1;yield 2;yield 3;} var g=Object.groupBy(gen(),function(n){return n%2===0?'e':'o'}); g.e.join(',')+'/'+g.o.join(',')",
            "2/1,3",
        ),
        (
            "var m=Map.groupBy(new Set([1,2,3,4]),function(n){return n%2===0?'e':'o'}); m.get('e').join(',')+'/'+m.get('o').join(',')",
            "2,4/1,3",
        ),
        // Map/Set/WeakMap/WeakSet コンストラクタ・Promise.all 系・Object.fromEntries も
        // 同じく `Interp` 不要の純関数 `iterable_values` を使っており、Generator を渡すと
        // 常に空になる同型のバグがあった（`it.iter_to_vec` に統一して解消）。
        (
            "function* gen(){yield [1,'a'];yield [2,'b'];} var m=new Map(gen()); m.get(1)+','+m.get(2)",
            "a,b",
        ),
        (
            "function* gen(){yield 1;yield 2;yield 2;} [...new Set(gen())].join(',')",
            "1,2",
        ),
        (
            "function* gen(){yield ['a',1];} Object.fromEntries(gen()).a",
            "1",
        ),
        (
            "function* gen(){yield Promise.resolve(1);yield Promise.resolve(2);} await Promise.all(gen()).then(a => a.join(','))",
            "1,2",
        ),
        // Uint8Array — 長さ指定・要素代入・length。
        ("var a=new Uint8Array(3); a[0]=10; a[1]=20; a.length+','+a[0]+','+a[1]", "3,10,20"),
        // Uint8Array — 配列/イテラブルから構築。
        ("Array.from(new Uint8Array([1,2,3])).join(',')", "1,2,3"),
        // Uint8Array.from — 静的メソッド。
        ("Uint8Array.from([4,5,6]).join(',')", "4,5,6"),
        // Uint8Array コンストラクタは Generator も受け付けるべき（仕様上どの iterable でも可）。
        (
            "function* gen(){yield 1;yield 2;yield 3;} new Uint8Array(gen()).join(',')",
            "1,2,3",
        ),
        // AggregateError も同様に Generator を errors として受け付ける。
        (
            "function* gen(){yield 'a';yield 'b';} new AggregateError(gen(), 'msg').errors.join(',')",
            "a,b",
        ),
        // Uint8Array — 値のラップ（256 は mod 256 で 0、-1 は 255、300 は 44）。
        ("var a=new Uint8Array([256,-1,300]); a.join(',')", "0,255,44"),
        // TypedArray コンストラクタに負の length を渡すと仕様上 RangeError（`ToIndex` が
        // `integer >= 0` を要求）だが、以前は `.max(0.0)` で黙って0にクランプしていた。
        (
            "try { new Uint8Array(-1); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "try { new Float64Array(-3); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // `typedArray.set(array, offset)`は仕様上`offset + array.length`が
        // 対象の長さを超えるとRangeErrorだが、以前は範囲外の書き込みを
        // 黙って無視するだけで、`ta.set([1,2,3], hugeOffset)`が例外にならず
        // 無害なno-opとして成立してしまっていた（TypedArrayコンストラクタの
        // 負lengthバグと同じ「範囲外を黙って受け流す」パターン）。
        (
            "try { new Uint8Array(3).set([1,2,3], 5); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "try { new Uint8Array(3).set([1,2], 2); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            // 境界ちょうど（offset + length === target.length）は範囲内なので例外にならない。
            "var a=new Uint8Array(3); a.set([9,9], 1); a.join(',')",
            "0,9,9",
        ),
        // Uint8Array.set — offset 付き上書き。
        ("var a=new Uint8Array(4); a.set([9,9],1); a.join(',')", "0,9,9,0"),
        // Uint8Array.set — 仕様上 array-like（非配列プレーンオブジェクト）も受け付けるべき。
        (
            "var a=new Uint8Array(3); a.set({0:5,1:6,length:2}); a.join(',')",
            "5,6,0",
        ),
        // Uint8Array.slice — 独立コピーを返す。
        ("var a=new Uint8Array([1,2,3,4,5]); var s=a.slice(1,3); s.join(',')+'/'+a.length", "2,3/5"),
        // Uint8Array.fill — 破壊的に埋めて this を返す。
        ("var a=new Uint8Array(4); a.fill(7,1,3); a.join(',')", "0,7,7,0"),
        // Uint8Array — byteLength / BYTES_PER_ELEMENT / buffer.byteLength。
        ("var a=new Uint8Array(5); a.byteLength+','+a.BYTES_PER_ELEMENT+','+a.buffer.byteLength", "5,1,5"),
        // ArrayBuffer — byteLength と、そこから Uint8Array を構築。
        ("var b=new ArrayBuffer(8); new Uint8Array(b).length+','+b.byteLength", "8,8"),
        // ArrayBuffer.prototype.resize/transfer/resizable/maxByteLength（ES2024）。
        // 以前は丸ごと未対応で、非 resizable なバッファしか作れなかった。
        (
            "var b=new ArrayBuffer(4,{maxByteLength:16}); b.resizable+','+b.maxByteLength+','+b.byteLength",
            "true,16,4",
        ),
        ("var b=new ArrayBuffer(4); b.resizable+','+b.maxByteLength", "false,4"),
        // resize は byteLength をその場で伸縮させる（新規領域はゼロ埋め）。
        (
            "var b=new ArrayBuffer(4,{maxByteLength:16}); b.resize(8); var u=new Uint8Array(b); b.byteLength+','+u.length",
            "8,8",
        ),
        // maxByteLength を超える resize は RangeError 相当の例外。
        (
            "var b=new ArrayBuffer(4,{maxByteLength:8}); try { b.resize(9); 'no throw'; } catch(e) { 'threw'; }",
            "threw",
        ),
        // 非 resizable なバッファへの resize は TypeError 相当の例外。
        (
            "var b=new ArrayBuffer(4); try { b.resize(2); 'no throw'; } catch(e) { 'threw'; }",
            "threw",
        ),
        // transfer は同じ byteLength の新バッファを返し、元のバッファを detach する（byteLength→0）。
        // 注: この処理系の ArrayBuffer/TypedArray は実メモリを共有しない独立コピー簡易実装
        // （DataView 等と同じ既存の割り切り）のため、TypedArray 経由で書いた値の引き継ぎまでは検証しない。
        (
            "var b=new ArrayBuffer(4); var b2=b.transfer(); b.byteLength+','+b2.byteLength",
            "0,4",
        ),
        // detach 後の再 transfer/resize は例外。
        (
            "var b=new ArrayBuffer(4); b.transfer(); try { b.transfer(); 'no throw'; } catch(e) { 'threw'; }",
            "threw",
        ),
        // transferToFixedLength は常に非 resizable な結果を返す。
        (
            "var b=new ArrayBuffer(4,{maxByteLength:8}); var b2=b.transferToFixedLength(); b2.resizable",
            "false",
        ),
        // `structuredClone(resizableArrayBuffer)`が`resizable`/`maxByteLength`
        // を引き継がず非resizableな複製に化けていたバグ（丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "var b=new ArrayBuffer(4,{maxByteLength:16}); var c=structuredClone(b); \
             c.resizable+','+c.maxByteLength+','+c.byteLength",
            "true,16,4",
        ),
        (
            "var b=new ArrayBuffer(4,{maxByteLength:16}); var c=structuredClone(b); \
             c.resize(8); c.byteLength",
            "8",
        ),
        // Uint8Array.prototype.toBase64/toHex + 静的 fromBase64/fromHex（ES2024/2025）。
        ("new Uint8Array([72,101,108,108,111]).toBase64()", "SGVsbG8="),
        ("Array.from(Uint8Array.fromBase64('SGVsbG8=')).join(',')", "72,101,108,108,111"),
        ("new Uint8Array([222,173,190,239]).toHex()", "deadbeef"),
        ("Array.from(Uint8Array.fromHex('deadbeef')).join(',')", "222,173,190,239"),
        // 往復（バイト列 -> base64/hex -> バイト列）が元に戻ることを確認。
        (
            "var a=new Uint8Array([1,2,3,255,0]); Array.from(Uint8Array.fromBase64(a.toBase64())).join(',')",
            "1,2,3,255,0",
        ),
        (
            "var a=new Uint8Array([1,2,3,255,0]); Array.from(Uint8Array.fromHex(a.toHex())).join(',')",
            "1,2,3,255,0",
        ),
        // fromHex: 不正な16進文字列（奇数長）は例外を投げる。
        (
            "try { Uint8Array.fromHex('abc'); 'no-throw' } catch(e) { 'caught:' + e.name }",
            "caught:SyntaxError",
        ),
        // setFromBase64/setFromHex（ES2024/2025）— 既存バッファへインプレース書き込み。
        (
            "var a=new Uint8Array(5); var r=a.setFromBase64('SGVsbG8='); Array.from(a).join(',')+'|'+r.read+'|'+r.written",
            "72,101,108,108,111|8|5",
        ),
        (
            "var a=new Uint8Array(4); var r=a.setFromHex('deadbeef'); Array.from(a).join(',')+'|'+r.read+'|'+r.written",
            "222,173,190,239|8|4",
        ),
        (
            "try { new Uint8Array(1).setFromHex('zz'); 'no-throw' } catch(e) { 'caught:' + e.name }",
            "caught:SyntaxError",
        ),
        // TextEncoder — Uint8Array を返し、UTF-8 バイト値が正しい。
        ("var e=new TextEncoder().encode('AB'); e.length+','+e[0]+','+e[1]", "2,65,66"),
        // TextEncoder→TextDecoder 往復。
        ("new TextDecoder().decode(new TextEncoder().encode('hello'))", "hello"),
        // `TextEncoder.prototype.encodeInto(source, destination)` が丸ごと
        // 未対応だった（`encode()` は既存だが、この性能向けバリアントが欠けていた）。
        (
            "var buf=new Uint8Array(5); var r=new TextEncoder().encodeInto('Hi', buf); \
             r.read+','+r.written+','+buf[0]+','+buf[1]",
            "2,2,72,105",
        ),
        // 宛先バッファが足りない場合はコードポイント境界で打ち切る（マルチバイト
        // 文字を途中で分割しない）。
        (
            "var buf=new Uint8Array(1); var r=new TextEncoder().encodeInto('AB', buf); \
             r.read+','+r.written",
            "1,1",
        ),
        // Int8Array — 符号付きラップ（200 は -56、-100 はそのまま）。
        ("var a=new Int8Array([200,-100]); a.join(',')", "-56,-100"),
        // Uint8ClampedArray — 飽和（クランプ、ラップではない）。
        ("var a=new Uint8ClampedArray([300,-50,128.6]); a.join(',')", "255,0,129"),
        // ToUint8Clamp は同点を偶数丸め（banker's rounding）する仕様
        // （Math.round の四捨五入とは異なる）。
        ("var a=new Uint8ClampedArray([0.5,1.5,2.5,3.5]); a.join(',')", "0,2,2,4"),
        // Int16Array / Uint16Array — 幅16bitのラップ。
        ("var a=new Int16Array([40000]); a[0]", "-25536"),
        // 索引代入 `ta[i]=v` はコンストラクタ/`set`/`fill` と違って型変換
        // （ラップ/クランプ）が一切効かず生の数値がそのまま入るバグだった。
        ("var a=new Int8Array(1); a[0]=200; a[0]", "-56"),
        ("var a=new Uint8ClampedArray(1); a[0]=300; a[0]", "255"),
        ("var a=new Uint8ClampedArray(1); a[0]=-50; a[0]", "0"),
        ("var a=new Int16Array(1); a[0]=40000; a[0]", "-25536"),
        ("var a=new Uint16Array([70000]); a[0]", "4464"),
        // Int32Array / Uint32Array — 幅32bitのラップ。
        ("var a=new Int32Array([4294967295]); a[0]", "-1"),
        ("var a=new Uint32Array([-1]); a[0]", "4294967295"),
        // Float32Array — 単精度への丸め込み（倍精度のままではない）。
        ("var a=new Float32Array([0.1]); a[0] !== 0.1", "true"),
        // Float16Array / DataView getFloat16 / setFloat16 (ES2025)。
        ("var a=new Float16Array([1.5]); a[0] === 1.5", "true"),
        ("var dv=new DataView(new ArrayBuffer(2)); dv.setFloat16(0, 2.5); dv.getFloat16(0)", "2.5"),
        // Float64Array — 倍精度はそのまま保持。
        ("var a=new Float64Array([0.1]); a[0] === 0.1", "true"),
        // 各 TypedArray の BYTES_PER_ELEMENT。
        ("new Int16Array(1).BYTES_PER_ELEMENT+','+new Float64Array(1).BYTES_PER_ELEMENT", "2,8"),
        // TypedArray.from（静的）と set/slice/fill の型別クロスチェック。
        ("Int32Array.from([1,2,3]).join(',')", "1,2,3"),
        ("var a=new Uint16Array(3); a.set([1,2],1); a.join(',')", "0,1,2"),
        ("var a=new Int8Array([1,2,3,4]); a.slice(1,3).join(',')", "2,3"),
        ("var a=new Uint32Array(3); a.fill(5); a.join(',')", "5,5,5"),
        // `toSorted`/`toReversed`/`toSpliced`/`with`（ES2023）が TypedArray に対しては
        // 常に普通の配列を返すバグだった（`structuredClone(TypedArray)` と同種）。
        // 型変換（ラップ）も維持されることを確認する。
        (
            "var a=new Int8Array([200,3,1]); var b=a.toSorted(); b.join(',')+','+b.BYTES_PER_ELEMENT",
            "-56,1,3,1",
        ),
        (
            "var a=new Int8Array([1,2,200]); var b=a.toReversed(); b.join(',')+','+b.BYTES_PER_ELEMENT",
            "-56,2,1,1",
        ),
        (
            "var a=new Int8Array([1,2,3]); var b=a.with(1,200); b.join(',')+','+b.BYTES_PER_ELEMENT",
            "1,-56,3,1",
        ),
        // `map`/`filter` も同じ理由で TypedArray に対しては常に普通の配列を返す
        // バグだった。callback の戻り値が有効域外でも型ごとの変換（ラップ）が働く。
        (
            "var a=new Int8Array([1,2,3]); var b=a.map(x => x + 200); b.join(',')+','+b.BYTES_PER_ELEMENT",
            "-55,-54,-53,1",
        ),
        (
            "var a=new Int8Array([1,2,3,4]); var b=a.filter(x => x % 2 === 0); b.join(',')+','+b.BYTES_PER_ELEMENT",
            "2,4,1",
        ),
        // DataView（ES2015）が丸ごと未対応で `new DataView(buf)` が
        // `DataView is not defined` になっていた。
        (
            "var dv=new DataView(new ArrayBuffer(4)); dv.setUint8(0,255); dv.getUint8(0)",
            "255",
        ),
        // デフォルトはビッグエンディアン。
        (
            "var dv=new DataView(new ArrayBuffer(4)); dv.setUint32(0,0x01020304); dv.getUint8(0)+','+dv.getUint8(3)",
            "1,4",
        ),
        // littleEndian=true を渡すとバイト順が反転する。
        (
            "var dv=new DataView(new ArrayBuffer(4)); dv.setUint32(0,0x01020304,true); dv.getUint8(0)+','+dv.getUint8(3)",
            "4,1",
        ),
        // 符号付き/符号無しの往復（16bit）。
        ("var dv=new DataView(new ArrayBuffer(2)); dv.setInt16(0,-1); dv.getUint16(0)", "65535"),
        // Float64 の往復（丸めなし）。
        ("var dv=new DataView(new ArrayBuffer(8)); dv.setFloat64(0,3.5); dv.getFloat64(0)", "3.5"),
        // 範囲外アクセスは例外。
        (
            "try { new DataView(new ArrayBuffer(1)).getUint32(0); 'no throw'; } catch(e) { 'threw'; }",
            "threw",
        ),
        // Blob（File API の基礎コンテナ）が丸ごと未対応で `new Blob([...])` が
        // `Blob is not defined` になっていた。
        ("new Blob(['hello', ' ', 'world']).size", "11"),
        ("new Blob(['abc'], {type:'text/plain'}).type", "text/plain"),
        ("await new Blob(['hello world']).text()", "hello world"),
        ("await new Blob(['hello world']).slice(0,5).text()", "hello"),
        // `Blob.arrayBuffer()` が返す ArrayBuffer は実バイト列を持ち、そこから作った
        // DataView で正しく読み戻せる（`Blob`→`ArrayBuffer`→`DataView` の実用連携）。
        (
            "var buf = await new Blob(['A']).arrayBuffer(); new DataView(buf).getUint8(0)",
            "65",
        ),
        // `Blob.prototype.bytes()`（ES2024。丸ごと未対応だった。`await blob.
        // arrayBuffer()`→`new Uint8Array(...)` の2手間を1メソッドで済ませる。
        // 2026-07-15 発見・実装）。
        // 注: `instanceof Uint8Array` では検証しない — 調査の結果、この処理系の
        // TypedArray コンストラクタ群は `.prototype` を一切持たず `instanceof` が
        // 常に `false` を返す既存の別バグと判明（`Array`/`Map` 等 TypedArray 以外の
        // 組み込み型も含め instanceof 自体の自己テストがコードベースに1件も無く、
        // 広範な既知の未検証領域）。`BYTES_PER_ELEMENT`（Uint8Array 固有の値）で
        // 型を検証し、この既存バグを新規追跡項目として TODO.md へ記録した。
        (
            "var u = await new Blob(['AB']).bytes(); u.BYTES_PER_ELEMENT",
            "1",
        ),
        ("var u = await new Blob(['AB']).bytes(); u[0]+','+u[1]", "65,66"),
        // `File`（`Blob` を継承し `name`/`lastModified` を追加する File API の
        // 基礎コンストラクタ）が丸ごと未対応で `File is not defined` になっていた。
        ("new File(['hi'], 'a.txt').name", "a.txt"),
        ("new File(['hi'], 'a.txt', {type:'text/plain'}).type", "text/plain"),
        ("new File(['hello'], 'a.txt').size", "5"),
        ("await new File(['hello'], 'a.txt').text()", "hello"),
        // `Blob` 由来のメソッド（`slice`）もそのまま継承する。
        ("await new File(['hello world'], 'a.txt').slice(0,5).text()", "hello"),
        // `lastModified` は明示指定を尊重する。
        ("new File(['x'], 'a.txt', {lastModified: 12345}).lastModified", "12345"),
        // `File.webkitRelativePath`（丸ごと未対応だった。実際のディレクトリ
        // 選択UIが無いため常に空文字列の誠実な簡略実装。2026-07-17 発見・
        // 実装）。
        ("new File(['x'], 'a.txt').webkitRelativePath", ""),
        // `structuredClone(File)`が`Blob`分岐に落ちて`name`/`lastModified`
        // が失われ、素の`Blob`へ格下げされていたバグ（丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "var c=structuredClone(new File(['hi'], 'a.txt', {lastModified: 12345})); \
             c.name + ',' + c.lastModified",
            "a.txt,12345",
        ),
        (
            "await structuredClone(new File(['hello'], 'a.txt')).text()",
            "hello",
        ),
        // 素の`Blob`（`name`無し）は引き続き`name`を持たない`Blob`のまま
        // 複製される（回帰確認）。
        ("structuredClone(new Blob(['x'])).name", "undefined"),
        // `FileReader` が丸ごと未対応だった（`blob.text()` 等の Promise 版は
        // 既に対応済みだったが、古典的なイベントベースの `readAsText`+`onload`
        // という書き方自体が丸ごと存在しなかった）。
        (
            "var r=new FileReader(); var out; r.onload=function(e){ out=e.target.result; }; \
             r.readAsText(new Blob(['hello'])); out",
            "hello",
        ),
        (
            "var r=new FileReader(); r.readAsText(new Blob(['x'])); r.readyState",
            "2",
        ),
        (
            "var r=new FileReader(); var buf; r.onload=function(e){ buf=e.target.result; }; \
             r.readAsArrayBuffer(new Blob(['A'])); new DataView(buf).getUint8(0)",
            "65",
        ),
        (
            "var r=new FileReader(); var url; r.onload=function(e){ url=e.target.result; }; \
             r.readAsDataURL(new Blob(['hi'], {type:'text/plain'})); url",
            "data:text/plain;base64,aGk=",
        ),
        // `addEventListener('load', ...)` 経由でも `onload` と同じく発火する
        // （`on<type>` 単一リスナ方式を共有しているため）。
        (
            "var r=new FileReader(); var fired=false; r.addEventListener('load', ()=>fired=true); \
             r.readAsText(new Blob(['x'])); fired",
            "true",
        ),
        // `Notification`（丸ごと未対応だった。通知 UI 自体が無いこの OS では
        // 実際の表示は行わず JS 側の契約のみ満たす簡略実装）。
        ("Notification.permission", "granted"),
        ("await Notification.requestPermission()", "granted"),
        (
            "var n = new Notification('hi', {body: 'world'}); n.title + ':' + n.body",
            "hi:world",
        ),
        ("typeof new Notification('x').close", "function"),
        // `data`/`requireInteraction`/`silent`/`dir`/`lang`（丸ごと未対応
        // だった。`title`/`body`/`icon`/`tag`は既に対応済みだったが、同じ
        // コンストラクタoptionsの残りが漏れていた。2026-07-17 発見・実装）。
        (
            "var n = new Notification('x', {data: {id: 5}, requireInteraction: true, silent: true}); \
             n.data.id + ',' + n.requireInteraction + ',' + n.silent",
            "5,true,true",
        ),
        ("new Notification('x').dir", "auto"),
        ("new Notification('x').data", "null"),
        ("typeof new Notification('x').removeEventListener", "function"),
        // Promise.withResolvers（ES2024）
        (
            "var {promise, resolve} = Promise.withResolvers(); resolve(5); await promise",
            "5",
        ),
        (
            "var {promise, reject} = Promise.withResolvers(); reject('e'); await promise.catch(e => 'caught:' + e)",
            "caught:e",
        ),
        // Promise.try（ES2025）: 同期の戻り値/例外/Promise 戻り値をすべて統一的に扱う
        ("await Promise.try(() => 42)", "42"),
        (
            "await Promise.try(() => { throw 'boom' }).catch(e => 'caught:' + e)",
            "caught:boom",
        ),
        ("await Promise.try(() => Promise.resolve('ok'))", "ok"),
        ("await Promise.try((a, b) => a + b, 1, 2)", "3"),
        // String.prototype.isWellFormed / toWellFormed（ES2024）
        ("'abc'.isWellFormed()", "true"),
        ("'abc'.toWellFormed()", "abc"),
        // using 宣言（Explicit Resource Management、ES2023→ES2026ベースライン）
        (
            "var log=''; { using r = {[Symbol.dispose]: () => log+='d'}; log+='a' } log+='b'; log",
            "adb",
        ),
        // 複数 using は宣言の逆順で dispose される（LIFO）。
        (
            "var log=''; { using a = {[Symbol.dispose]: () => log+='A'}; using b = {[Symbol.dispose]: () => log+='B'} } log",
            "BA",
        ),
        // return で早期脱出しても dispose は呼ばれる（戻り値確定後に外側の log へ副作用）。
        (
            "var log=''; function f(){ { using r = {[Symbol.dispose]: () => log+='d'}; return 'a' } } var res=f(); log+res",
            "da",
        ),
        // await using は Symbol.asyncDispose の戻り値を await する。
        (
            "async function f(){ var log=''; { await using r = {[Symbol.asyncDispose]: async () => { log+='d' }}; log+='a' } return log } await f()",
            "ad",
        ),
        // Array.fromAsync（ES2024/2025）: 同期イテラブル + 各要素の Promise を await。
        (
            "(await Array.fromAsync([Promise.resolve(1), 2, Promise.resolve(3)])).join(',')",
            "1,2,3",
        ),
        // mapFn 付き。
        ("(await Array.fromAsync([1,2,3], x => x * 10)).join(',')", "10,20,30"),
        // 複数 using の dispose がいずれも例外を投げると SuppressedError へ集約される
        // (LIFO: 後から宣言した b が先に dispose される → error=A(最後に投げた), suppressed=B)。
        (
            "var caught=null; try { { using a = {[Symbol.dispose]: () => { throw 'A' }}; using b = {[Symbol.dispose]: () => { throw 'B' }} } } catch(e) { caught = e } caught.name + ':' + caught.error + ':' + caught.suppressed",
            "SuppressedError:A:B",
        ),
        // for await...of: 同期イテラブル + 各要素の Promise を await するフォールバック。
        (
            "async function f(){ var out=''; for await (const x of [Promise.resolve(1), 2, Promise.resolve(3)]) { out += x } return out } await f()",
            "123",
        ),
        // for await...of: Symbol.asyncIterator を実装した独自オブジェクトを手動駆動。
        (
            "async function f(){ var obj={}; obj[Symbol.asyncIterator]=function(){ var i=0; return {next:function(){ i++; if (i<=3) { return Promise.resolve({value:i,done:false}); } return Promise.resolve({value:undefined,done:true}); }}; }; var out=''; for await (const x of obj){ out += x } return out } await f()",
            "123",
        ),
        // async generator インスタンスは Symbol.asyncIterator を公開すべき
        // （Generator.prototype[Symbol.asyncIterator] は自分自身を返す仕様）。
        // 以前は generator_method に asyncIterator/iterator の登録が無く、for await が
        // 常に eager-drain フォールバックへ落ちていた（値は一致するが例外伝播が違った）。
        (
            "async function* g(){ yield 1; yield 2; yield 3; } typeof g()[Symbol.asyncIterator]",
            "function",
        ),
        (
            "async function* g(){ yield 1; yield 2; yield 3; } var it=g(); it[Symbol.asyncIterator]() === it",
            "true",
        ),
        (
            "async function* g(){ yield 1; yield 2; yield 3; } async function f(){ var out=''; for await (const x of g()) { out += x } return out } await f()",
            "123",
        ),
        // 通常の（非 async）generator は Symbol.asyncIterator を公開してはいけない
        // （for await のフォールバックが正しく同期経路を通ることの確認）。
        (
            "function* g(){ yield 1; } typeof g()[Symbol.asyncIterator]",
            "undefined",
        ),
        // async generator が途中で例外を投げた場合、for await はそれを正しく伝播する
        // （eager-drain フォールバックはこれを黙って握り潰していた）。
        (
            "async function* g(){ yield 1; throw 'boom'; } async function f(){ var out=''; try { for await (const x of g()) { out += x } } catch(e) { out += ':' + e } return out } await f()",
            "1:boom",
        ),
        // 非宣言形式の for-of（x は既存変数）: 配列を反復。
        ("var x; var out=''; for (x of [1,2,3]) { out += x } out", "123"),
        // 非宣言形式は既存の外側変数へ代入する（ループ後もその値が残る）。
        ("var x=0; for (x of [1,2,3]) {} x", "3"),
        // 非宣言形式の for-in（k は既存変数）。
        ("var k; var out=''; for (k in {a:1,b:2}) { out += k } out", "ab"),
        // 非宣言形式 + 配列分割代入 for-of。
        (
            "var a,b; var out=''; for ([a,b] of [[1,2],[3,4]]) { out += a+','+b+';' } out",
            "1,2;3,4;",
        ),
        // 非宣言形式 + オブジェクト分割代入 for-of。
        (
            "var a,b; var out=''; for ({a,b} of [{a:1,b:2},{a:3,b:4}]) { out += a+','+b+';' } out",
            "1,2;3,4;",
        ),
        // 非宣言形式 + メンバー式 for-of（obj.prop）。
        ("var obj={p:0}; for (obj.p of [1,2,3]) {} obj.p", "3"),
        // 非宣言形式 + 添字式 for-of（arr[0]）。
        ("var arr=[0]; for (arr[0] of [7,8,9]) {} arr[0]", "9"),
        // New Set Methods（ES2024/2025）。仕様上第一引数は `Set` に限らず任意の
        // set-like（iterable）を受け付けるべきだが、以前は `&mut Interp` を持たない
        // `iterable_values` にフォールバックしており Generator を渡すと常に空扱いに
        // なるバグだった（`iterable_values`/`this_items` 系の横展開監査で見落とし）。
        (
            "function* g(){yield 3;yield 4;} [...new Set([1,2,3]).union(g())].sort().join(',')",
            "1,2,3,4",
        ),
        (
            "function* g(){yield 2;yield 3;} [...new Set([1,2,3]).intersection(g())].sort().join(',')",
            "2,3",
        ),
        ("[...new Set([1,2,3]).union(new Set([3,4,5]))].sort().join(',')", "1,2,3,4,5"),
        ("[...new Set([1,2,3]).intersection(new Set([2,3,4]))].sort().join(',')", "2,3"),
        ("[...new Set([1,2,3]).difference(new Set([2,3]))].join(',')", "1"),
        (
            "[...new Set([1,2,3]).symmetricDifference(new Set([2,3,4]))].sort().join(',')",
            "1,4",
        ),
        ("new Set([1,2]).isSubsetOf(new Set([1,2,3]))", "true"),
        ("new Set([1,2,3]).isSupersetOf(new Set([1,2]))", "true"),
        ("new Set([1,2]).isDisjointFrom(new Set([3,4]))", "true"),
        ("new Set([1,2]).isDisjointFrom(new Set([2,3]))", "false"),
        // Iterator helpers（ES2025）: generator に対する map/filter/take/drop/flatMap/toArray/
        // forEach/some/every/find/reduce。無限イテレータには非対応の簡略実装（要素を全展開してから処理）。
        ("function* g(){ yield 1; yield 2; yield 3; } g().map(x=>x*2).join(',')", "2,4,6"),
        (
            "function* g(){ yield 1; yield 2; yield 3; yield 4; } g().filter(x=>x%2===0).join(',')",
            "2,4",
        ),
        (
            "function* g(){ yield 1; yield 2; yield 3; yield 4; yield 5; } g().take(2).join(',')",
            "1,2",
        ),
        (
            "function* g(){ yield 1; yield 2; yield 3; yield 4; yield 5; } g().drop(3).join(',')",
            "4,5",
        ),
        (
            "function* g(){ yield 1; yield 2; } g().flatMap(x=>[x,x*10]).join(',')",
            "1,10,2,20",
        ),
        ("function* g(){ yield 1; yield 2; } g().toArray().join(',')", "1,2"),
        (
            "function* g(){ yield 1; yield 2; yield 3; } var s=0; g().forEach(x=>s+=x); s",
            "6",
        ),
        ("function* g(){ yield 1; yield 2; yield 3; } g().some(x=>x>2)", "true"),
        ("function* g(){ yield 1; yield 2; yield 3; } g().every(x=>x>0)", "true"),
        ("function* g(){ yield 1; yield 2; yield 3; } g().find(x=>x>1)", "2"),
        (
            "function* g(){ yield 1; yield 2; yield 3; } g().reduce((a,x)=>a+x,0)",
            "6",
        ),
        // Iterator.from（ES2025）: 任意のイテラブル（配列/Set/Generator）を Iterator helpers
        // 一式にアクセスできる形でラップする。map/filter 等は Array.prototype 経由、
        // take/drop/toArray は Iterator helpers 経由（Array に無いメソッドのため）。
        ("Iterator.from([1,2,3]).map(x=>x*2).join(',')", "2,4,6"),
        ("Iterator.from([1,2,3,4,5]).take(2).join(',')", "1,2"),
        ("Iterator.from([1,2,3,4,5]).drop(3).join(',')", "4,5"),
        ("Iterator.from(new Set([1,2,3])).toArray().join(',')", "1,2,3"),
        (
            "function* g(){ yield 1; yield 2; yield 3; } Iterator.from(g()).take(2).join(',')",
            "1,2",
        ),
        // Iterator.concat（ES2025 Standard）: 複数のイテラブル（配列、Set、Generator等）をシームレスに結合する。
        ("Iterator.concat([1,2], new Set([3,4]), [5]).toArray().join(',')", "1,2,3,4,5"),
        ("Iterator.concat(['a','b'], ['c']).take(2).toArray().join(',')", "a,b"),
        // `instanceof`（ES1 以来の基礎演算子）が `BinaryOp::InstanceOf => Value::Bool(false)`
        // という未実装のプレースホルダのまま放置され、常に false を返す重大バグだった。
        // OrdinaryHasInstance 相当（`r.prototype` を起点に `l` のプロトタイプ連鎖を辿る）を実装。
        ("function Foo(){} new Foo() instanceof Foo", "true"),
        ("function Foo(){} function Bar(){} new Foo() instanceof Bar", "false"),
        ("class Animal{} class Dog extends Animal{} new Dog() instanceof Animal", "true"),
        ("class Animal{} class Dog extends Animal{} new Dog() instanceof Dog", "true"),
        ("1 instanceof Object", "false"),
        // 組み込みの `Object`/`Array` コンストラクタは（他のビルトインメソッド解決と同様に
        // ObjKind による特殊扱いで実装されており）実際の `.prototype` オブジェクトを
        // 持たないため、リテラルとの `instanceof` は常に false になる簡略実装の既知の限界。
        // ユーザー定義の function/class コンストラクタ（実際に `.prototype` を持つ）が
        // 主要なユースケースであり、そちらは上のテストの通り正しく動作する。
        ("({}) instanceof Object", "false"),
        ("[] instanceof Array", "false"),
        // グローバルな `Error` コンストラクタ自体が長期間欠落しており（TypeError/RangeError/
        // SyntaxError というサブタイプだけが存在し基底の `Error` が無い状態だった）、
        // `new Error("msg")` は「Error is not defined」で ReferenceError になっていた。
        // 合わせて各サブタイプの `.prototype` を `Error.prototype` を proto に持つ形へ
        // 再構成し、`instanceof` の実装と対で `new TypeError() instanceof Error` 等が
        // 正しく true になるようにした。
        ("new Error('boom').message", "boom"),
        ("new Error('boom').name", "Error"),
        ("new Error('boom') instanceof Error", "true"),
        // `Error.prototype.stack`（丸ごと未対応だった）。実際のコールフレーム
        // 一覧は再現できないため、V8 の1行目と同じ `"name: message"` 形式の
        // 簡略実装（詳細は `builtins::build_error_stack` 参照）。
        ("new Error('boom').stack", "Error: boom"),
        ("new TypeError('x').stack", "TypeError: x"),
        ("typeof new Error().stack === 'string' && new Error().stack.length > 0", "true"),
        (
            "(function(){ try { null.foo; } catch(e) { return typeof e.stack; } })()",
            "string",
        ),
        ("new TypeError('x') instanceof Error", "true"),
        ("new TypeError('x') instanceof TypeError", "true"),
        ("new RangeError('x') instanceof TypeError", "false"),
        ("new Uint8Array(1) instanceof Uint8Array", "true"),
        ("new Int8Array(1) instanceof Int8Array", "true"),
        ("new Uint8Array(1) instanceof Int8Array", "false"),
        ("Object.getPrototypeOf(new Uint8Array(1)) === Uint8Array.prototype", "true"),
        ("Uint8Array.prototype.constructor === Uint8Array", "true"),
        (
            "try { null.x } catch(e) { e instanceof Error }",
            "true",
        ),
        // ユーザー定義のカスタムエラークラス（`class MyError extends Error`）は、`super(msg)`
        // が到達するネイティブ `Error` コンストラクタが `this`（サブクラスのインスタンス。
        // proto は MyError.prototype → Error.prototype と連鎖）へ直接 message を書き込む
        // ことに依存しており、今回の一連の修正で自然に動くようになった実用パターン。
        (
            "class MyError extends Error { constructor(m){ super(m); this.name='MyError'; } } var e = new MyError('bad'); e.message + '/' + e.name",
            "bad/MyError",
        ),
        (
            "class MyError extends Error { constructor(m){ super(m); } } new MyError('x') instanceof Error",
            "true",
        ),
        (
            "class MyError extends Error { constructor(m){ super(m); } } new MyError('x') instanceof MyError",
            "true",
        ),
        // **重要**: `Symbol.hasInstance`（ES2015。`class Foo { static
        // [Symbol.hasInstance](x){...} }` によるカスタム `instanceof` 判定）が丸ごと
        // 未対応で、常にプロトタイプ連鎖の照合に決め打ちされていた。
        (
            "class Even { static [Symbol.hasInstance](n){ return typeof n === 'number' && n % 2 === 0; } } (4 instanceof Even) + ',' + (3 instanceof Even)",
            "true,false",
        ),
        (
            "class AlwaysTrue { static [Symbol.hasInstance](x){ return true; } } ({} instanceof AlwaysTrue)",
            "true",
        ),
        // `Error.isError(value)`（ES2025）が丸ごと欠落していた。`instanceof Error` と違い
        // `Symbol.hasInstance`/`Error.prototype` の上書きに影響されず組込み proto を直接見る。
        ("Error.isError(new Error('x'))", "true"),
        ("Error.isError(new TypeError('x'))", "true"),
        (
            "class MyError extends Error { constructor(m){ super(m); } } Error.isError(new MyError('x'))",
            "true",
        ),
        ("Error.isError({message:'x'})", "false"),
        ("Error.isError(42)", "false"),
        ("Error.isError(undefined)", "false"),
        // `new Error(msg, {cause})`（ES2022）が丸ごと未対応で、`err.cause` が常に
        // `undefined` になっていた（例外を包んで再送出する定番イディオムで使われる）。
        ("new Error('wrap', {cause: 'orig'}).cause", "orig"),
        ("typeof new Error('x').cause", "undefined"),
        ("new TypeError('t', {cause: 42}).cause", "42"),
        (
            "try { throw new Error('inner') } catch(e) { new Error('outer', {cause: e}).cause.message }",
            "inner",
        ),
        // `RegExp.escape(str)`（ES2025）が丸ごと未対応だった。ユーザー入力を
        // `new RegExp(...)` へそのまま渡す前に構文文字を無害化する定番イディオム。
        ("RegExp.escape('a.b*c')", "a\\.b\\*c"),
        ("new RegExp(RegExp.escape('1+1=2')).test('1+1=2')", "true"),
        (
            "new RegExp('^' + RegExp.escape('a.b') + '$').test('aXb')",
            "false",
        ),
        // `RegExp.prototype.compile()`（レガシーだが仕様に残るメソッド。丸ごと
        // 未対応だった）。`this` を新しいオブジェクトを作らずその場で差し替える。
        ("var r=/a/; r.compile('b'); r.test('b')", "true"),
        ("var r=/a/i; r.compile('a'); r.flags", ""),
        ("var r=/a/; r.compile('a','gi'); r.flags", "gi"),
        ("var r=/a/g; r.lastIndex=3; r.compile('b'); r.lastIndex", "0"),
        ("var r=/x/; var r2=r.compile('y'); r===r2", "true"),
        // `CSS.escape(str)`（CSSOM。丸ごと未対応だった。`CSS` 名前空間自体が
        // 存在しなかった）。
        ("CSS.escape('a.b')", "a\\.b"),
        ("CSS.escape('.foo#bar')", "\\.foo\\#bar"),
        ("CSS.escape('123')", "\\31 23"),
        ("CSS.escape('-1')", "-\\31 "),
        ("CSS.escape('-')", "\\-"),
        ("CSS.escape('abc')", "abc"),
        // `CSS.supports(conditionText)`/`CSS.supports(property, value)`
        // （CSSOM。丸ごと未対応だった。`@supports` の条件式評価をそのまま
        // 再利用するため、`not`/`and`/`or` の論理結合も正しく評価される）。
        ("CSS.supports('(display: grid)')", "true"),
        ("CSS.supports('display', 'grid')", "true"),
        ("CSS.supports('not (display: grid)')", "false"),
        (
            "CSS.supports('(display: grid) and (gap: 1rem)')",
            "true",
        ),
        (
            "CSS.supports('not (display: grid) or (gap: 1rem)')",
            "true",
        ),
        // `<audio>`/`<video>` の `.play()`/`.pause()`/`.load()`/`.canPlayType()`
        // （HTMLMediaElement。丸ごと未対応だった）。
        (
            "typeof document.createElement('audio').play().then",
            "function",
        ),
        ("typeof document.createElement('video').pause()", "undefined"),
        ("typeof document.createElement('audio').load()", "undefined"),
        ("document.createElement('video').canPlayType('video/mp4')", ""),
        // ARIA 反映 IDL 属性（`.role`/`.ariaLabel`/`.ariaChecked` 等）が丸ごと
        // 未対応だった。
        ("document.createElement('div').role", "null"),
        (
            "var e=document.createElement('div'); e.role='button'; e.getAttribute('role')",
            "button",
        ),
        (
            "var e=document.createElement('div'); e.setAttribute('aria-label','x'); e.ariaLabel",
            "x",
        ),
        (
            "var e=document.createElement('div'); e.ariaExpanded='true'; \
             e.getAttribute('aria-expanded')",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.ariaLabel='x'; e.ariaLabel=null; \
             e.hasAttribute('aria-label')",
            "false",
        ),
        // 表・リスト系の残りの ARIA 反映 IDL 属性（丸ごと未対応だった。
        // 2026-07-15 発見・実装）。
        (
            "var e=document.createElement('div'); e.ariaColCount='3'; \
             e.getAttribute('aria-colcount')",
            "3",
        ),
        (
            "var e=document.createElement('div'); e.setAttribute('aria-rowindex','2'); \
             e.ariaRowIndex",
            "2",
        ),
        (
            "var e=document.createElement('div'); e.ariaSetSize='5'; e.ariaPosInSet='2'; \
             e.ariaSetSize + ',' + e.ariaPosInSet",
            "5,2",
        ),
        (
            "var e=document.createElement('div'); e.ariaLevel='1'; e.getAttribute('aria-level')",
            "1",
        ),
        // `String.prototype.repeat(count)` が仕様上必須の「負値/+Infinity で RangeError」
        // を投げず黙って空文字列に丸めていたバグ。
        ("'ab'.repeat(3)", "ababab"),
        ("'x'.repeat(0)", ""),
        (
            "try { 'x'.repeat(-1); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "try { 'x'.repeat(Infinity); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // `eval`/`Function`（ES1 の最基礎機能の2つ）が丸ごと欠落していた
        // （`eval is not a function`/`Function is not defined`）。
        ("eval('1 + 2 * 3')", "7"),
        ("eval(42)", "42"),
        ("var x = 10; eval('x = x + 5'); x", "15"),
        ("new Function('a', 'b', 'return a + b')(3, 4)", "7"),
        ("new Function('return 1 + 1')()", "2"),
        (
            "typeof new Function('a', 'return a * 2')",
            "function",
        ),
        // Iterator Helpers（ES2025）が丸ごと未対応だった。`arr.values()` 等が返す軽量
        // イテレータに `map`/`filter`/`take`/`drop`/`toArray`/`forEach`/`reduce` を追加。
        ("[1,2,3].values().map(x => x * 2).toArray().join(',')", "2,4,6"),
        ("[1,2,3,4].values().filter(x => x % 2 === 0).toArray().join(',')", "2,4"),
        ("[1,2,3,4,5].values().take(2).toArray().join(',')", "1,2"),
        ("[1,2,3,4,5].values().drop(3).toArray().join(',')", "4,5"),
        (
            "[1,2,3].values().map(x => x + 1).filter(x => x > 2).toArray().join(',')",
            "3,4",
        ),
        (
            "var s=''; [1,2,3].values().forEach(x => s += x); s",
            "123",
        ),
        ("[1,2,3,4].values().reduce((a,b) => a + b)", "10"),
        ("[1,2,3].values().reduce((a,b) => a + b, 10)", "16"),
        // `some`/`every`/`find`（同じ ES2025 Iterator Helpers 提案に含まれる残り3つ
        // が丸ごと未対応だった。`map`/`filter`/`take`/`drop`/`toArray`/`forEach`/
        // `reduce` は既に対応済み）。
        ("[1,2,3].values().some(x => x > 2)", "true"),
        ("[1,2,3].values().some(x => x > 5)", "false"),
        ("[1,2,3].values().every(x => x > 0)", "true"),
        ("[1,2,3].values().every(x => x > 1)", "false"),
        ("[1,2,3,4].values().find(x => x % 2 === 0)", "2"),
        ("typeof [1,2,3].values().find(x => x > 5)", "undefined"),
        // `flatMap`（ES2025 Iterator Helpers 提案の最後の1つが丸ごと未対応だった）。
        (
            "[1,2,3].values().flatMap(x => [x, x * 10]).toArray().join(',')",
            "1,10,2,20,3,30",
        ),
        // `Iterator.prototype.flatMap` のマッパー戻り値が配列以外の iterable（Generator 等）
        // でも展開されるべき（以前は実配列以外を無条件で空扱いする同型のバグがあった）。
        (
            "function* dup(x){ yield x; yield x*10; } [1,2].values().flatMap(x => dup(x)).toArray().join(',')",
            "1,10,2,20",
        ),
        // `Object.getPrototypeOf`/`Object.setPrototypeOf`（ES5/ES6。`Reflect` 版は既に
        // あったが、実用上はるかに一般的なこちらの静的メソッドが欠落していた）。
        (
            "function Foo(){} Object.getPrototypeOf(new Foo()) === Foo.prototype",
            "true",
        ),
        (
            "var a={}; var b={x:1}; Object.setPrototypeOf(a,b); a.x",
            "1",
        ),
        // `Object.setPrototypeOf` は循環参照を検証しないため、循環したプロトタイプ
        // 連鎖を持つオブジェクトへのプロパティ読み書き/`in`/`for...in` が無限ループ
        // （QEMU 起動ハング）になり得たバグ。
        (
            "var a={}; Object.setPrototypeOf(a,a); a.nope",
            "undefined",
        ),
        (
            "var a={}; var b={}; Object.setPrototypeOf(a,b); Object.setPrototypeOf(b,a); a.nope",
            "undefined",
        ),
        (
            "var a={}; Object.setPrototypeOf(a,a); ('nope' in a)",
            "false",
        ),
        (
            "var a={}; Object.setPrototypeOf(a,a); a.x=1; a.x",
            "1",
        ),
        (
            "var a={}; Object.setPrototypeOf(a,a); var ks=[]; for (var k in a) { ks.push(k); } ks.length",
            "0",
        ),
        // `obj.__proto__`（Annex B のレガシーアクセサ。`Object.getPrototypeOf`/
        // `setPrototypeOf` は既に対応済みだったが、実務コードで極めて広く使われる
        // こちらの糖衣構文自体が丸ごと未対応だった）。
        ("var a={}; var b={x:1}; a.__proto__ = b; a.x", "1"),
        ("var b={x:1}; var a=Object.create(b); a.__proto__ === b", "true"),
        ("({}).__proto__ === null", "true"),
        ("var a={}; a.__proto__ = null; a.__proto__", "null"),
        // オブジェクトリテラル内の `__proto__: value`（算出キーでない場合）は
        // 通常のプロパティではなく [[Prototype]] を設定する特別構文（Annex B.3.1）。
        ("var p={x:5}; var o={__proto__: p}; o.x", "5"),
        ("var p={x:5}; var o={__proto__: p}; Object.keys(o).includes('__proto__')", "false"),
        // 算出キー `{['__proto__']: v}` は通常の own プロパティのまま（特別扱いしない）。
        ("var o={['__proto__']: 5}; o.__proto__", "5"),
        // `Object.prototype.isPrototypeOf`/`propertyIsEnumerable`。
        ("function Foo(){} Foo.prototype.isPrototypeOf(new Foo())", "true"),
        ("({}).isPrototypeOf({})", "false"),
        ("({x:1}).propertyIsEnumerable('x')", "true"),
        ("({x:1}).propertyIsEnumerable('y')", "false"),
        // `Function.prototype.call`/`apply`/`bind`（ES3/ES5）が丸ごと欠落していた
        // （`Reflect.apply` はあったが、はるかに一般的なこちらのインスタンスメソッドが無かった）。
        ("function f(a,b){ return this.x+a+b; } f.call({x:10}, 1, 2)", "13"),
        ("function f(a,b){ return this.x+a+b; } f.apply({x:10}, [1,2])", "13"),
        // `Function.prototype.apply` の第2引数も `Reflect.apply` と同じく array-like
        // 全般（非配列）を受け付けるべきだが、以前は `iterable_values` を使っており
        // 素の array-like を渡すと引数が消える同型のバグだった。
        (
            "function f(a,b){ return this.x+a+b; } f.apply({x:10}, {0:1,1:2,length:2})",
            "13",
        ),
        (
            "function f(a,b){ return this.x+a+b; } var g = f.bind({x:10}, 1); g(2)",
            "13",
        ),
        (
            "function f(){ return this.x; } var g = f.bind({x:5}); g.call({x:99})",
            "5",
        ),
        // `new.target`（ES6 MetaProperty）が未実装だった。`new` 経由の呼び出しでは
        // コンストラクタ自身、通常呼び出しでは undefined になる。
        // `new Foo()` はコンストラクタが（オブジェクトではなく）真偽値を return しても
        // 仕様どおり無視され `this`（構築済みインスタンス）を返すため、`new.target` の値は
        // 外側の変数に代入して確認する。
        (
            "var r; function Foo(){ r = new.target === Foo; } new Foo(); r",
            "true",
        ),
        ("function Foo(){ return new.target === Foo; } Foo()", "false"),
        (
            "function Foo(){ return typeof new.target; } Foo()",
            "undefined",
        ),
        (
            "class Foo { constructor(){ this.isNew = new.target === Foo; } } new Foo().isNew",
            "true",
        ),
        // アロー関数は `this` と同様に `new.target` もレキシカルに周囲から継承する
        // （アロー自身は `new` できず独自のフレームを持たないため）。
        (
            "var r; function Foo(){ var f = () => { r = new.target === Foo; }; f(); } new Foo(); r",
            "true",
        ),
        // `catch` 節の分割代入パターン（ES2015）。以前は `catch_param` が単なる識別子
        // 文字列で、パターン（`{message}` 等）を受け付けられなかった。
        (
            "try { throw {message:'boom', code:42}; } catch({message, code}) { message + '/' + code; }",
            "boom/42",
        ),
        (
            "try { throw [1,2,3]; } catch([a,,c]) { a + '/' + c; }",
            "1/3",
        ),
        ("try { throw 'x'; } catch(e) { e; }", "x"),
        // クラスの算出メソッド名 `[expr](){}` が未対応だった（パーサがキーとして
        // 識別子/文字列/数値/`[`を含む未知トークンを読み飛ばすだけで、`[Symbol.iterator]`
        // のようなよくあるパターンが正しくパースできなかった）。
        (
            "class C { ['foo' + 'bar'](){ return 42; } } new C().foobar()",
            "42",
        ),
        // 上の算出メソッド名対応と組み合わせ、`for...of` がユーザー定義の
        // `[Symbol.iterator]()` を実装したカスタムイテラブル（class）を正しく駆動できる
        // ようにした（従来は Array/Set/Map/Generator/文字列以外は「オブジェクト自身の
        // プロパティ値」を無条件に列挙するだけで、Symbol.iterator 自体を一切見ていなかった）。
        (
            "class Range { constructor(n){ this.n = n; } [Symbol.iterator](){ var i=0, n=this.n; return { next(){ return i<n ? {value:i++, done:false} : {value:undefined, done:true}; } }; } } var s=''; for (const x of new Range(4)) { s += x; } s",
            "0123",
        ),
        (
            "class Range { constructor(n){ this.n = n; } [Symbol.iterator](){ var i=0, n=this.n; return { next(){ return i<n ? {value:i++, done:false} : {value:undefined, done:true}; } }; } } [...new Range(3)].join(',')",
            "0,1,2",
        ),
        // `[Symbol.iterator]` 等の偽装 Symbol キーが `Object.keys`/`values`/`entries`/
        // `for...in`/`JSON.stringify` に漏れて列挙されてしまうバグの検証
        // （`Object.assign`/スプレッド構文は仕様どおり対象のままなので混同しないこと）。
        (
            "var o={a:1}; o[Symbol.iterator]=function(){}; Object.keys(o).join(',')",
            "a",
        ),
        (
            "var o={a:1}; o[Symbol.iterator]=function(){}; Object.values(o).join(',')",
            "1",
        ),
        (
            "var o={a:1}; o[Symbol.iterator]=function(){}; JSON.stringify(o)",
            "{\"a\":1}",
        ),
        (
            "var o={a:1}; o[Symbol.iterator]=function(){}; var k=''; for (const x in o) { k+=x; } k",
            "a",
        ),
        // `Date` が丸ごと未実装だった（`performance.now()` はあったが実時刻を持たない
        // 単純カウンタで、`Date` 自体はグローバルに存在しなかった）。実時刻は NTP 同期済みの
        // カーネル壁時計（`kernel::timer::get_unix_time()`）を利用する。
        (
            "new Date(2024, 0, 15, 10, 30, 45, 500).toISOString()",
            "2024-01-15T10:30:45.500Z",
        ),
        ("new Date(0).toISOString()", "1970-01-01T00:00:00.000Z"),
        // `toDateString`/`toTimeString`/`toLocaleDateString`/`toLocaleTimeString` は
        // 以前すべて `toString`（フルISO日時文字列）にエイリアスされており、日付のみ/
        // 時刻のみを返すべきところに他方の情報が混入していた。
        (
            "new Date(2024, 0, 15, 10, 30, 45, 500).toDateString()",
            "2024-01-15",
        ),
        (
            "new Date(2024, 0, 15, 10, 30, 45, 500).toTimeString()",
            "10:30:45",
        ),
        (
            "new Date(2024, 0, 15).toLocaleDateString()",
            "2024-01-15",
        ),
        ("new Date(2024, 0, 15).toLocaleTimeString()", "00:00:00"),
        ("new Date(2024, 0, 1).getFullYear()", "2024"),
        ("new Date(2024, 5, 15).getMonth()", "5"),
        ("new Date(2024, 0, 1).getDay()", "1"), // 2024-01-01 は月曜日
        // getTimezoneOffset()（丸ごと未対応だった）。UTC を常にローカルとみなす簡略実装のため常に0。
        ("typeof new Date().getTimezoneOffset()", "number"),
        ("new Date().getTimezoneOffset()", "0"),
        // `Date.prototype.set*` が `setTime` も含めて1つも実装されておらず、getter
        // しか無い丸ごと未対応バグだった（`setFullYear`/`setDate` 等の定番書き換え
        // イディオムが軒並み `undefined is not a function` になっていた）。
        (
            "var d=new Date(2024,0,15); d.setFullYear(2025); d.getFullYear()+'-'+(d.getMonth()+1)+'-'+d.getDate()",
            "2025-1-15",
        ),
        // `getYear`/`setYear`（Annex B.2.4/B.2.5。2桁年時代の遺産）が丸ごと未対応だった。
        ("new Date(2024,0,1).getYear()", "124"),
        // `setYear(y)` は `0<=y<=99` なら `1900+y` を、それ以外は `y` をそのまま
        // フルイヤーとして使う仕様どおりの奇妙な後方互換ロジック。
        ("var d=new Date(2024,0,1); d.setYear(5); d.getFullYear()", "1905"),
        ("var d=new Date(2024,0,1); d.setYear(2030); d.getFullYear()", "2030"),
        (
            "var d=new Date(2024,0,15); d.setMonth(5); d.getMonth()",
            "5",
        ),
        (
            "var d=new Date(2024,0,15); d.setDate(d.getDate()+1); d.getDate()",
            "16",
        ),
        // setDate は月境界を仕様どおり繰り上げる。
        (
            "var d=new Date(2024,0,31); d.setDate(d.getDate()+1); (d.getMonth()+1)+'-'+d.getDate()",
            "2-1",
        ),
        (
            "var d=new Date(2024,0,15,10,20,30); d.setHours(23); d.getHours()+':'+d.getMinutes()+':'+d.getSeconds()",
            "23:20:30",
        ),
        (
            "var d=new Date(2024,0,15,10,20,30); d.setMinutes(5); d.getMinutes()",
            "5",
        ),
        (
            "var d=new Date(2024,0,15,10,20,30); d.setSeconds(59); d.getSeconds()",
            "59",
        ),
        (
            "var d=new Date(2024,0,15); d.setMilliseconds(123); d.getMilliseconds()",
            "123",
        ),
        (
            "var d=new Date(0); d.setTime(5000); d.getTime()",
            "5000",
        ),
        // set* の戻り値は仕様どおり新しい getTime() と同じ。
        (
            "var d=new Date(0); var r=d.setFullYear(2000); r === d.getTime()",
            "true",
        ),
        // `Date` は `to_number()` に `ObjKind::DateObj` 特殊扱いを追加したことで、
        // `.getTime()` を明示せずとも算術/比較演算がそのまま動く
        // （この処理系はオブジェクト全般の `valueOf`/`Symbol.toPrimitive` は汎用サポートしない
        // ため、これは `Date` だけの特殊扱い）。
        ("new Date(1000) - new Date(0)", "1000"),
        ("new Date(0) < new Date(1000)", "true"),
        ("+new Date(500)", "500"),
        ("typeof Date.now()", "number"),
        // `delete`（ES1 以来の基礎演算子）が AST/パーサ/インタプリタのどこにも存在せず、
        // 丸ごと未実装だった（`delete` トークン自体はレキサーが認識するのに、パーサが
        // どの式としても解釈しない状態）。
        ("var o = {x:1}; delete o.x; 'x' in o", "false"),
        ("var o = {x:1, y:2}; delete o.x; o.y", "2"),
        ("var k='x'; var o = {x:1}; delete o[k]; 'x' in o", "false"),
        ("var a=[1,2,3]; delete a[1]; a[1]", "undefined"),
        ("var a=[1,2,3]; delete a[1]; a.length", "3"),
        ("delete 5", "true"),
        // カンマ演算子 — 以前はパーサが先行する式を単に上書きして AST から消してしまい、
        // その式の副作用（関数呼び出し・代入等）が一切実行されない重大なバグだった。
        ("var s=''; (s+='a', s+='b', s+='c'); s", "abc"),
        ("var x=(1,2,3); x", "3"),
        (
            "var s=''; for (var i=0,j=10; i<3; i++,j--) { s += i+':'+j+' '; } s",
            "0:10 1:9 2:8 ",
        ),
        ("var a; var b; (a=1, b=a+1); a+','+b", "1,2"),
        // `generator.throw(err)`（ES2015）が丸ごと未実装だった（`next`/`return` はあったが
        // `throw` だけが欠落）。中断中の yield 位置に例外を注入する。
        (
            "function* g(){ try { yield 1; yield 2; } catch(e) { yield 'caught:'+e; } } var it=g(); it.next(); it.throw('boom').value",
            "caught:boom",
        ),
        (
            "function* g(){ yield 1; yield 2; } var it=g(); it.next(); var r; try { it.throw('x'); } catch(e) { r = 'propagated:'+e; } r",
            "propagated:x",
        ),
        // `String.prototype.codePointAt`（ES2015）/`localeCompare`（ES3）が丸ごと未実装だった。
        ("'A'.codePointAt(0)", "65"),
        ("'ABC'.codePointAt(5)", "undefined"),
        ("'a'.localeCompare('b')", "-1"),
        ("'b'.localeCompare('a')", "1"),
        ("'a'.localeCompare('a')", "0"),
        // `String.prototype.substr`（ES3 由来の Annex B 非推奨メソッド）が `slice`/
        // `substring` はあったのに欠落していた。古いコードで依然として広く使われる。
        ("'Hello World'.substr(6)", "World"),
        ("'Hello World'.substr(0, 5)", "Hello"),
        ("'Hello World'.substr(-5)", "World"),
        ("'Hello World'.substr(-5, 3)", "Wor"),
        // `static { ... }`（ES2022 静的初期化ブロック）が未実装だった。パーサはメソッド名
        // として識別子/文字列/数値/`[computed]` しか認識せず、`{` が来ると読み飛ばして
        // 続行する未実装フォールバックに落ちていた。
        (
            "class C { static x; static { C.x = 1 + 2; } } C.x",
            "3",
        ),
        (
            "class C { static x = 10; static { C.x += 5; } } C.x",
            "15",
        ),
        // 複数の static ブロックは宣言順に実行される。
        (
            "class C { static log=''; static { C.log+='a'; } static { C.log+='b'; } } C.log",
            "ab",
        ),
        // `Array.prototype.flat(depth)` が `depth` 引数を完全に無視し、常に1段しか
        // 展開しないバグだった。`.flat(Infinity)`（深いネスト解除の定番イディオム）も
        // 動作していなかった。
        ("[1,[2,3]].flat().join(',')", "1,2,3"),
        ("[1,[2,[3,[4]]]].flat(2).join(',')", "1,2,3,4"),
        ("[1,[2,[3,[4,[5]]]]].flat(Infinity).join(',')", "1,2,3,4,5"),
        // `.flat(Infinity)` は循環参照する配列（`a.push(a)`）に対しては祖先追跡
        // ガードが無いと無限再帰になり、この no_std 環境ではスタック
        // オーバーフロー（クラッシュ/ハング）に直結し得るバグだった（2026-07-13。
        // `Value::to_js_string` で修正済みの循環参照系と同種）。クラッシュ/
        // ハングせず完走することを確認する（既に祖先に現れた配列はそれ以上
        // 展開されずそのまま結果に含まれるため、要素数は打ち切り位置に依存）。
        ("var a=[1]; a.push(a); a.flat(Infinity); 'ok'", "ok"),
        // depth=0 は展開しない（トップレベルの要素数がそのまま length に残ることで確認）。
        ("[1,[2,[3]]].flat(0).length", "2"),
        // `Object.freeze()` が明示的な no-op（同一オブジェクトを返すだけ）だった。
        // `Object.isFrozen()` 自体も丸ごと欠落していた。
        ("var o={x:1}; Object.freeze(o); o.x=2; o.x", "1"),
        ("var o={x:1}; Object.freeze(o); o.y=2; 'y' in o", "false"),
        ("var o={x:1}; Object.freeze(o); delete o.x; o.x", "1"),
        ("var o={x:1}; Object.isFrozen(o)", "false"),
        ("var o={x:1}; Object.freeze(o); Object.isFrozen(o)", "true"),
        ("Object.isFrozen(5)", "true"),
        // `Object.seal`/`isSealed`/`preventExtensions`/`isExtensible` も丸ごと欠落していた。
        ("var o={x:1}; Object.seal(o); o.x=2; o.x", "2"),
        ("var o={x:1}; Object.seal(o); o.y=2; 'y' in o", "false"),
        ("var o={x:1}; Object.seal(o); delete o.x; 'x' in o", "true"),
        ("var o={x:1}; Object.isSealed(o)", "false"),
        ("var o={x:1}; Object.seal(o); Object.isSealed(o)", "true"),
        (
            "var o={x:1}; Object.preventExtensions(o); o.y=2; 'y' in o",
            "false",
        ),
        (
            "var o={x:1}; Object.preventExtensions(o); o.x=5; delete o.x; 'x' in o",
            "false",
        ),
        ("var o={x:1}; Object.isExtensible(o)", "true"),
        (
            "var o={x:1}; Object.preventExtensions(o); Object.isExtensible(o)",
            "false",
        ),
        // `Array.isArray` は仕様上 Proxy を透過して target を見る必要があるが、
        // 以前は Proxy でラップした配列が false 判定になっていた。
        ("Array.isArray(new Proxy([1,2], {}))", "true"),
        ("Array.isArray(new Proxy({}, {}))", "false"),
        // TypedArray も内部表現は ObjKind::Array を流用するため、`_ta_kind` タグを
        // 見ずに判定すると `Array.isArray(new Int8Array(...))` が仕様に反して
        // `true` になるバグだった（TypedArray は Array exotic object ではない）。
        ("Array.isArray(new Int8Array([1,2]))", "false"),
        ("Array.isArray([1,2])", "true"),
        // `Object.keys`/`values`/`entries` は Proxy を素通しできず（Proxy 自身は props を
        // 持たないため）常に空を返すバグだった。target フォワードのみの Proxy では
        // 正しく動くようにした（ownKeys トラップの呼び出しまでは非対応）。
        ("Object.keys(new Proxy({a:1,b:2}, {})).sort().join(',')", "a,b"),
        ("Object.values(new Proxy({a:1,b:2}, {})).sort().join(',')", "1,2"),
        (
            "Object.entries(new Proxy({a:1}, {})).map(e=>e[0]+':'+e[1]).join(',')",
            "a:1",
        ),
        // `JSON.stringify` も同じ Proxy 透過漏れで、Proxy を渡すと常に `{}` になっていた。
        ("JSON.stringify(new Proxy({a:1,b:2}, {}))", "{\"a\":1,\"b\":2}"),
        // `for...of`/スプレッドも同じ Proxy 透過漏れで、target フォワードのみの Proxy が
        // 配列/Set/Map を包んでいても何も反復しないバグだった（`iterate_values()` が自身の
        // `ObjKind` だけを見て Proxy を Array 等として認識できていなかった）。
        (
            "var s=''; for (const x of new Proxy([1,2,3], {})) { s += x; } s",
            "123",
        ),
        ("[...new Proxy([1,2,3], {})].join(',')", "1,2,3"),
        // `Object.assign` も同じ系統のバグを2つ抱えていた: (1) ソースが Proxy だと
        // 何もコピーされない、(2) ソースが配列だと要素が `ObjKind::Array` 側にあり
        // `props` には無いため、これも何もコピーされない。
        (
            "var t = Object.assign({}, new Proxy({a:1,b:2}, {})); t.a+','+t.b",
            "1,2",
        ),
        (
            "var t = Object.assign({}, [10,20,30]); t[0]+','+t[1]+','+t[2]",
            "10,20,30",
        ),
        // `Reflect.deleteProperty` は `delete` 演算子と同じ凍結/封印済みオブジェクト保護を
        // 適用すべきだが、以前は一切チェックせず常に削除・成功させていた（非対称だった）。
        (
            "var o={x:1}; Object.freeze(o); Reflect.deleteProperty(o,'x')",
            "false",
        ),
        ("var o={x:1}; Reflect.deleteProperty(o,'x')", "true"),
        // `Reflect.set` も同様に、以前は常に `true` を返しており、凍結済みオブジェクトへの
        // 書込みが黙殺されていても呼び出し元からは成功したように見えていた。
        (
            "var o={x:1}; Object.freeze(o); Reflect.set(o,'x',2)",
            "false",
        ),
        ("var o={x:1}; Reflect.set(o,'x',2); o.x", "2"),
        // `Array.prototype.includes` は SameValueZero で比較すべきところ `===` を使っており、
        // `[NaN].includes(NaN)` が false になるバグだった（`indexOf` は `===` のままで正しい）。
        ("[NaN].includes(NaN)", "true"),
        ("[NaN].indexOf(NaN)", "-1"),
        ("[1,2,NaN].includes(NaN)", "true"),
        ("[1,2,3].includes(2)", "true"),
        ("[1,2,3].includes(5)", "false"),
        // 高階配列メソッドの第2引数 `thisArg` が `map`/`filter`/`forEach`/`find` 系
        // すべてで無視されていた（コールバックの `this` を常に `undefined` 決め打ちしていた）。
        (
            "var ctx={mul:10}; [1,2,3].map(function(x){return x*this.mul;}, ctx).join(',')",
            "10,20,30",
        ),
        (
            "var ctx={min:2}; [1,2,3].filter(function(x){return x>this.min;}, ctx).join(',')",
            "3",
        ),
        (
            "var ctx={sum:0}; [1,2,3].forEach(function(x){this.sum+=x;}, ctx); ctx.sum",
            "6",
        ),
        (
            "var ctx={target:2}; [1,2,3].find(function(x){return x===this.target;}, ctx)",
            "2",
        ),
        (
            "var ctx={target:5}; [1,2,3].some(function(x){return x===this.target;}, ctx)",
            "false",
        ),
        (
            "var ctx={min:0}; [1,2,3].every(function(x){return x>this.min;}, ctx)",
            "true",
        ),
        // 同じ `thisArg` 無視バグが `Map.prototype.forEach`/`Set.prototype.forEach`/
        // `Array.from` の第3引数にもあった。
        (
            "var ctx={sum:0}; var m=new Map([['a',1],['b',2]]); m.forEach(function(v){this.sum+=v;}, ctx); ctx.sum",
            "3",
        ),
        (
            "var ctx={sum:0}; var s=new Set([1,2,3]); s.forEach(function(v){this.sum+=v;}, ctx); ctx.sum",
            "6",
        ),
        (
            "var ctx={mul:2}; Array.from([1,2,3], function(x){return x*this.mul;}, ctx).join(',')",
            "2,4,6",
        ),
        // `JSON.stringify` の第3引数 `space`（インデント整形。デバッグ出力の定番
        // イディオム `JSON.stringify(obj, null, 2)`）が完全に無視されていた。
        (
            "JSON.stringify({a:1,b:2}, null, 2)",
            "{\n  \"a\": 1,\n  \"b\": 2\n}",
        ),
        ("JSON.stringify([1,2], null, 2)", "[\n  1,\n  2\n]"),
        ("JSON.stringify({}, null, 2)", "{}"),
        ("JSON.stringify([], null, 2)", "[]"),
        ("JSON.stringify({a:1}, null, '\\t')", "{\n\t\"a\": 1\n}"),
        // space 省略時は従来どおりコンパクト出力のまま。
        ("JSON.stringify({a:1,b:2})", "{\"a\":1,\"b\":2}"),
        // `JSON.stringify` は BigInt を直列化できず本来 TypeError を投げるべきだが、
        // 以前は静かに省略していた（`undefined`/関数と同じ扱いになっていたバグ）。
        (
            "try { JSON.stringify(10n); 'no-throw' } catch(e) { 'caught:' + e.name }",
            "caught:Error",
        ),
        (
            "try { JSON.stringify({a:10n}); 'no-throw' } catch(e) { 'caught' }",
            "caught",
        ),
        // `replacer` 引数（キーの絞り込み用配列 / 値差し替え関数）も同様に丸ごと未対応だった。
        ("JSON.stringify({a:1,b:2,c:3}, ['a','c'])", "{\"a\":1,\"c\":3}"),
        (
            "JSON.stringify({a:1,b:2}, function(k,v){ return typeof v === 'number' ? v*10 : v; })",
            "{\"a\":10,\"b\":20}",
        ),
        // replacer 配列はオブジェクトのキー絞り込みのみに適用され、配列要素自体は
        // 絞り込まれない（仕様どおり）。
        ("JSON.stringify([1,2,3], ['a'])", "[1,2,3]"),
        // `JSON.parse` の第2引数 `reviver`（キーをボトムアップで巡る変換関数）も
        // 同様に丸ごと未対応だった。
        (
            "JSON.parse('{\"a\":1,\"b\":2}', function(k,v){ return typeof v === 'number' ? v*10 : v; }).a",
            "10",
        ),
        (
            "var r = JSON.parse('{\"a\":1,\"b\":2}', function(k,v){ return k==='b' ? undefined : v; }); 'b' in r",
            "false",
        ),
        (
            "JSON.parse('[1,2,3]', function(k,v){ return typeof v === 'number' ? v+1 : v; }).join(',')",
            "2,3,4",
        ),
        ("JSON.parse('{\"a\":1}').a", "1"),
        // `String.prototype.replaceAll` が RegExp パターン（`g` フラグ必須）・関数
        // リプレーサのどちらも未対応だった（RegExp を渡すと文字列表現 "/pat/flags" として
        // 扱われ無変換になっていた）。
        ("'aaa'.replaceAll(/a/g, 'b')", "bbb"),
        (
            "try { 'aaa'.replaceAll(/a/, 'b'); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "'a1b2'.replaceAll(/[0-9]/g, function(m){ return '['+m+']'; })",
            "a[1]b[2]",
        ),
        ("'aXaXa'.replaceAll('X', function(){ return '-'; })", "a-a-a"),
        ("'abc'.replaceAll('x', 'y')", "abc"),
        // 同一の `var` 文の中で、前の宣言子を後の初期化子が参照できるか。
        // jQuery 1.8.2 の先頭が
        // `var ...,h=[],p="1.8.2",d=h.concat,...,w=p.trim,...` という形で、
        // ここが順に評価されないと `p` が undefined になり
        // 「Cannot read properties of undefined (reading 'trim')」で落ちる。
        ("var a1 = 1, b1 = a1 + 1; b1", "2"),
        ("var s1 = 'xy', t1 = s1.length; t1", "2"),
        ("var h1 = [], p1 = '1.8.2', w1 = p1.trim; typeof w1", "function"),
        ("var q1 = [], r1 = q1.push; typeof r1", "function"),
        // `String.prototype` が丸ごと無く、プロトタイプから直接読む形が
        // undefined になっていた。jQuery 1.8.2 の `o=String.prototype.trim`
        // で本体が実行時に落ちていた。
        ("typeof String.prototype", "object"),
        ("typeof String.prototype.trim", "function"),
        ("typeof String.prototype.slice", "function"),
        ("String.prototype.trim.call('  x  ')", "x"),
        ("String.prototype.toUpperCase.call('ab')", "AB"),
        // 実体からの解決は従来どおり。
        ("'  y '.trim()", "y"),
        // 素のオブジェクト／配列／関数から、プロトタイプ経由で
        // メソッドを**値として**読めるか。jQuery は
        // `core_toString = class2type.toString`（`class2type = {}`）のように
        // 読んでから `.call(...)` する。読めないと
        // 「Cannot read properties of undefined (reading 'call')」になる。
        ("typeof ({}).toString", "function"),
        ("typeof ({}).hasOwnProperty", "function"),
        ("typeof [].slice", "function"),
        ("typeof [].concat", "function"),
        ("typeof (function(){}).call", "function"),
        ("typeof (function(){}).apply", "function"),
        ("({}).toString.call([])", "[object Array]"),
        // `Array.prototype` はオブジェクトとしては在ったがメソッドが空だった。
        // jQuery 1.8.2 の
        // `j=Array.prototype.push,k=Array.prototype.slice,l=Array.prototype.indexOf`
        // で undefined になり、続く `k.call(...)` で落ちていた。
        ("typeof Array.prototype.push", "function"),
        ("typeof Array.prototype.slice", "function"),
        ("typeof Array.prototype.indexOf", "function"),
        ("Array.prototype.slice.call([1,2,3], 1).join(',')", "2,3"),
        ("Array.prototype.indexOf.call([4,5,6], 5)", "1"),
        // `Object.prototype` 側も jQuery が読む 2 つを確かめる。
        ("typeof Object.prototype.toString", "function"),
        ("typeof Object.prototype.hasOwnProperty", "function"),
        // jQuery 1.8.2 の機能検出は、**切り離された**要素へ innerHTML を入れ、
        // そこから要素を取り出して `style` を触る。この一連が通らないと
        // 「Cannot read properties of undefined (reading 'style')」になる。
        ("var d = document.createElement('div'); typeof d", "object"),
        ("var d2 = document.createElement('div'); typeof d2.style", "object"),
        (
            "var d3 = document.createElement('div'); d3.innerHTML = \"<a href='/a'>a</a>\";              d3.getElementsByTagName('a').length",
            "1",
        ),
        (
            "var d4 = document.createElement('div'); d4.innerHTML = \"<a href='/a'>a</a>\";              typeof d4.getElementsByTagName('a')[0]",
            "object",
        ),
        (
            "var d5 = document.createElement('div'); d5.innerHTML = \"<a href='/a'>a</a>\";              typeof d5.getElementsByTagName('a')[0].style",
            "object",
        ),
        (
            "var d6 = document.createElement('div');              d6.innerHTML = '<table></table><a href=\"/a\">a</a>';              d6.getElementsByTagName('*').length > 0",
            "true",
        ),
        (
            "var d7 = document.createElement('div'); d7.style.cssText = 'top:1px';              typeof d7.style.cssText",
            "string",
        ),
        (
            "var d8 = document.createElement('div'); d8.setAttribute('className','t');              d8.getAttribute('className')",
            "t",
        ),
        // jQuery 1.8.2 の機能検出が実際に入れる HTML。先頭の空白 2 つ・
        // 自己閉じの `<link/>`・`<table></table>` が `<a>` の前に来る。
        // ここで `<a>` が取れないと `d.style` で落ちる。
        // どの要素が原因かを分けて確かめる。
        (
            "var e1 = document.createElement('div'); e1.innerHTML = '<link/><a href=\"/a\">a</a>';              e1.getElementsByTagName('a').length",
            "1",
        ),
        (
            "var e2 = document.createElement('div');              e2.innerHTML = '<table></table><a href=\"/a\">a</a>';              e2.getElementsByTagName('a').length",
            "1",
        ),
        (
            "var e3 = document.createElement('div'); e3.innerHTML = '  <a href=\"/a\">a</a>';              e3.getElementsByTagName('a').length",
            "1",
        ),
        (
            "var e4 = document.createElement('div');              e4.innerHTML = '<input type=\"checkbox\"/><a href=\"/a\">a</a>';              e4.getElementsByTagName('a').length",
            "1",
        ),
        // jQuery が入れる文字列そのもの。
        (
            "var e5 = document.createElement('div');              e5.innerHTML = '  <link/><table></table><a href=\"/a\">a</a><input type=\"checkbox\"/>';              e5.getElementsByTagName('a').length",
            "1",
        ),
        (
            "var e6 = document.createElement('div');              e6.innerHTML = '  <link/><table></table><a href=\"/a\">a</a><input type=\"checkbox\"/>';              e6.getElementsByTagName('*').length > 0",
            "true",
        ),
        // jQuery は IIFE の中で `e = a.document`（`a = window`）として
        // **`window.document` 経由**で触る。グローバルの `document` を
        // 直接使う経路とは別なので、そちらも確かめる。
        ("typeof window.document", "object"),
        // グローバルにあるのに `window.` 経由で読めない漏れ。
        // jQuery 1.8.2 は `a.navigator.userAgent`（`a` は window）と書く。
        ("typeof window.navigator", "object"),
        ("typeof window.navigator.userAgent", "string"),
        ("window.navigator === navigator", "true"),
        ("typeof window.location", "object"),
        ("typeof window.JSON", "object"),
        ("typeof window.Math", "object"),
        ("typeof window.XMLHttpRequest", "function"),
        // `window.x = ...` の後に素の `x` で読めること。
        // jQuery 1.8.2 は最後に `a.jQuery = a.$ = p`（`a` は window）で
        // 自分を公開するので、これが無いと **jQuery が完走しても
        // `$ is not defined`** になる。
        ("window.myGlobal1 = 42; myGlobal1", "42"),
        ("window.myFn1 = function(){ return 'z'; }; myFn1()", "z"),
        ("window.mySelf1 = window; typeof mySelf1.document", "object"),
        // スコープの変数が優先される（window 側で影を作らない）。
        ("window.shadow1 = 'w'; var shadow1 = 'v'; shadow1", "v"),
        // `Object.prototype.toString` はプリミティブの種別を返す。
        // 全部 `[object Object]` だと、jQuery の `jQuery.extend(true, ...)` が
        // 文字列を「素のオブジェクト」と誤判定して `{}` に置き換える
        // （実際に `s.type`（"GET"）が壊れ `$.getJSON` が落ちていた）。
        ("Object.prototype.toString.call('x')", "[object String]"),
        ("Object.prototype.toString.call(1)", "[object Number]"),
        ("Object.prototype.toString.call(true)", "[object Boolean]"),
        ("Object.prototype.toString.call(null)", "[object Null]"),
        ("Object.prototype.toString.call(undefined)", "[object Undefined]"),
        ("Object.prototype.toString.call({})", "[object Object]"),
        ("Object.prototype.toString.call([])", "[object Array]"),
        ("Object.prototype.toString.call(function(){})", "[object Function]"),
        ("window.document === document", "true"),
        ("typeof window.document.createElement", "function"),
        (
            "var w1 = window.document.createElement('div'); typeof w1.style",
            "object",
        ),
        (
            "var w2 = window.document.createElement('div');              w2.innerHTML = '  <link/><table></table><a href=\"/a\">a</a><input type=\"checkbox\"/>';              typeof w2.getElementsByTagName('a')[0]",
            "object",
        ),
        // 関数の引数として渡した window から辿る形（jQuery の IIFE と同じ）。
        (
            "(function(a){ var e = a.document, n = e.createElement('div');              n.setAttribute('className','t');              n.innerHTML = '  <link/><table></table><a href=\"/a\">a</a><input type=\"checkbox\"/>';              var d = n.getElementsByTagName('a')[0]; return typeof d; })(window)",
            "object",
        ),
        // `replaceAll`/`matchAll` が独自の `[Symbol.replace]`/`[Symbol.matchAll]` へ
        // 委譲していなかった（`replace`/`match`/`search`/`split` は委譲済みだった）。
        // 【順序】`g` フラグの検査が**先**、委譲はその後。逆にすると
        // 非 g の RegExp が委譲側へ流れて TypeError が出なくなる。
        (
            "var o = {}; o[Symbol.replace] = function(s, r){ return 'X' + s + r; };              'ab'.replaceAll(o, 'Z')",
            "XabZ",
        ),
        (
            "var o = {}; o[Symbol.matchAll] = function(s){ return ['m:' + s]; };              'ab'.matchAll(o)[0]",
            "m:ab",
        ),
        // 委譲を足しても、非 g の RegExp は従来どおり TypeError のまま。
        (
            "try { 'aaa'.matchAll(/a/); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // `String.prototype.split` の第2引数 `limit` が完全に無視されていた。
        ("'a,b,c,d'.split(',', 2).join('|')", "a|b"),
        ("'a,b,c'.split(',', 0).length", "0"),
        ("'a1b2c3'.split(/[0-9]/, 2).join('|')", "a|b"),
        ("'a,b,c'.split(',').join('|')", "a|b|c"),
        // `matchAll` は `g` フラグ必須（無ければ TypeError）だが、以前は無条件に
        // 全件マッチを返していた。
        (
            "try { 'aa'.matchAll(/a/); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        (
            "[...'a1b2'.matchAll(/[0-9]/g)].map(m=>m[0]).join(',')",
            "1,2",
        ),
        // `structuredClone` は循環参照（自己参照）を扱えず無限再帰（この no_std 環境では
        // クラッシュ/ハングになり得る）に陥るバグだった。
        (
            "var a={x:1}; a.self=a; var c=structuredClone(a); c.self===c",
            "true",
        ),
        ("var a={x:1}; a.self=a; var c=structuredClone(a); c.x", "1"),
        // 同一オブジェクトへの複数参照は複製後も共有構造として保たれる（仕様どおり）。
        (
            "var shared={v:1}; var o={a:shared,b:shared}; var c=structuredClone(o); c.a===c.b",
            "true",
        ),
        // `JSON.stringify` にも同じ「循環参照で無限再帰」バグがあった。仕様どおり
        // TypeError を投げるようにした（同一オブジェクトへの非循環な複数参照＝
        // 構造共有は問題なく直列化できることも確認）。
        (
            "try { var a={}; a.self=a; JSON.stringify(a); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // 深いネスト（30段超）でもスタックオーバーフローせずTypeErrorをスローするかの保護テスト
        (
            "var cur={}; for(var i=0;i<40;i++){ cur={child:cur}; } try { JSON.stringify(cur); 'no-throw' } catch(e) { 'depth-exceeded' }",
            "depth-exceeded",
        ),
        (
            "var shared={v:1}; JSON.stringify({a:shared,b:shared})",
            "{\"a\":{\"v\":1},\"b\":{\"v\":1}}",
        ),
        // `console.log` の表示整形（`display_value`）にも同じ「循環参照で無限再帰」
        // バグがあった。`console.log(a)`（`a.self=a`）は特に日常的にありうる操作のため、
        // 一番踏みやすいケースだった（クラッシュ/ハングせず完走することを確認）。
        (
            "var a={}; a.self=a; console.log(a); 'ok'",
            "ok",
        ),
        (
            "var a=[1,2]; a.push(a); console.log(a); 'ok'",
            "ok",
        ),
        // `console.log` の表示整形（`display_value_inner`）が `Proxy` を
        // `Array`/`Plain` 以外への素通しフォールバックに落としており、
        // `[ 1, 2, 3 ]` のような角括弧付き表示にならず素の `"1,2,3"` に
        // なっていた（`Value::to_js_string` の Proxy 素通しバグ修正と同時に
        // 発見。target へ委譲して同じ表示ロジックへ再帰するよう修正）。
        (
            "console.log(new Proxy([1,2,3], {})); 'ok'",
            "ok",
        ),
        // `Value::to_js_string`（`Array.prototype.join`/`toString`・テンプレート
        // リテラル補間・暗黙の文字列連結が共通で使う変換）にも同じ「循環参照で
        // 無限再帰」バグが残っていた（`structuredClone`/`JSON.stringify`/
        // `console.log` は既に修正済みだったが、この経路だけ未点検だった）。
        // `a.push(a); a.join()` はクラッシュ/ハングせず完走し、循環要素は
        // 仕様どおり空文字列として扱われることを確認する。
        ("var a=[1]; a.push(a); a.join()", "1,1,"),
        ("var a=[1]; a.push(a); String(a); 'ok'", "ok"),
        ("var a=[1]; a.push(a); `${a}`; 'ok'", "ok"),
        // `Number.prototype.toString(radix)` が `radix` 引数を完全に無視し常に10進表示
        // だった（`n.toString(16)` 等の定番イディオムが動かなかった）。
        ("(255).toString(16)", "ff"),
        ("(8).toString(2)", "1000"),
        ("(255).toString()", "255"),
        ("(-255).toString(16)", "-ff"),
        ("(0).toString(2)", "0"),
        (
            "try { (1).toString(1); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // `parseInt` が `radix` 未指定時に `0x` 接頭辞を自動検出せず、明示的に
        // `radix=16` を渡しても `0x` を読み飛ばさないバグだった。
        ("parseInt('0xFF')", "255"),
        ("parseInt('0xFF', 16)", "255"),
        ("parseInt('FF', 16)", "255"),
        ("parseInt('10')", "10"),
        ("parseInt('-0x10')", "-16"),
        ("parseInt('10', 2)", "2"),
        // `Number.parseFloat`/`Number.parseInt`（ES2015）は仕様上グローバル
        // `parseFloat`/`parseInt` と同一の関数オブジェクトでなければならないが、
        // 以前は別々に構築されており `===` が `false` になっていた。
        ("Number.parseFloat === parseFloat", "true"),
        ("Number.parseInt === parseInt", "true"),
        ("Number.parseFloat.name", "parseFloat"),
        ("Number.parseInt.name", "parseInt"),
        // `JSON.stringify` は `Date` の `toJSON`（ISO 文字列）相当を特殊扱いする。
        // 以前は Date インスタンスが（`toJSON` を汎用的にチェックしないため）
        // プロパティなしの `{}` として直列化されてしまっていた。
        (
            "JSON.stringify(new Date(0))",
            "\"1970-01-01T00:00:00.000Z\"",
        ),
        (
            "JSON.stringify({d: new Date(0)})",
            "{\"d\":\"1970-01-01T00:00:00.000Z\"}",
        ),
        // 文字列化（テンプレートリテラル補間・暗黙の文字列連結）でも `[object Object]` ではなく
        // ISO 形式が出るようにした（`Value::to_js_string()` に `ObjKind::DateObj` 分岐を追加）。
        ("'' + new Date(0)", "1970-01-01T00:00:00.000Z"),
        ("`date=${new Date(0)}`", "date=1970-01-01T00:00:00.000Z"),
        // Object.defineProperty / Property attributes (writable, configurable, enumerable)
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); o.x = 2; o.x",
            "1",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); delete o.x",
            "false",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); Object.keys(o).length",
            "0",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); var keys=[]; for(var k in o){ keys.push(k); } keys.length",
            "0",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); JSON.stringify(o)",
            "{}",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); ({...o}).x",
            "undefined",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); Object.assign({}, o).x",
            "undefined",
        ),
        (
            "var o={}; Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false, enumerable: false}); Reflect.deleteProperty(o, 'x')",
            "false",
        ),
        // `DataView.prototype.getBigInt64`/`.getBigUint64`/`.setBigInt64`/
        // `.setBigUint64`（ES2020）が丸ごと未対応だった。64bit整数はNumberの
        // 安全整数範囲(2^53)を超えうるためBigIntで往復する必要がある。
        // 2026-07-18 発見・実装）。
        (
            "var b=new ArrayBuffer(8); var v=new DataView(b); v.setBigInt64(0, 123456789012345n); v.getBigInt64(0).toString()",
            "123456789012345",
        ),
        (
            "var b=new ArrayBuffer(8); var v=new DataView(b); v.setBigInt64(0, -1n); v.getBigInt64(0).toString()",
            "-1",
        ),
        (
            "var b=new ArrayBuffer(8); var v=new DataView(b); v.setBigUint64(0, -1n); v.getBigUint64(0).toString()",
            "18446744073709551615",
        ),
        (
            "var b=new ArrayBuffer(8); var v=new DataView(b); v.setBigInt64(0, 1n, true); v.getBigInt64(0, true).toString()",
            "1",
        ),
        // `JSON.rawJSON`/`JSON.isRawJSON`（ES2025）が丸ごと未対応だった。
        // Numberの精度で表現できない巨大な整数をJSON文字列へ精度損失無しで
        // 埋め込むための機能。2026-07-18 発見・実装）。
        (
            "JSON.stringify({n: JSON.rawJSON('123456789012345678901234567890')})",
            "{\"n\":123456789012345678901234567890}",
        ),
        ("JSON.isRawJSON(JSON.rawJSON('42'))", "true"),
        ("JSON.isRawJSON({rawJSON: '42'})", "false"),
        ("JSON.isRawJSON(42)", "false"),
        (
            "(function(){ try { JSON.rawJSON(' 1'); return 'no-throw'; } catch(e) { return e instanceof Error; } })()",
            "true",
        ),
        (
            "(function(){ try { JSON.rawJSON('not json'); return 'no-throw'; } catch(e) { return e instanceof Error; } })()",
            "true",
        ),
        // `button.command`/`.commandForElement`（Invoker Commands API）が
        // 丸ごと未対応だった。`popoverTargetAction`/`.popoverTargetElement`と
        // 全く同じ反映・idref解決パターンで実装（クリック時の実際の
        // `CommandEvent`発火/組込み動作は本サイクルでは未対応。
        // 2026-07-18 発見・実装）。
        (
            "var b=document.createElement('button'); b.command='show-modal'; b.command",
            "show-modal",
        ),
        (
            "document.createElement('button').commandForElement",
            "null",
        ),
        // `commandForElement`セッターの往復（`b.commandForElement = 要素`→
        // `commandfor`属性へidを反映）。この方向はDOMツリーへの接続を
        // 要さない（`popoverTargetElement`と同じ、対象要素のidを直接
        // 読むだけの実装）ため、`document.getElementById`のアタッチ要件
        // （共有テストフィクスチャ`wrap`が本テストスイート内の別テストで
        // 未接続化され得る既知の不安定要素）に依存しない自己完結した形に
        // している。逆方向（属性→要素解決）は`popoverTargetElement`と
        // 全く同じ`get_element_by_id`経路を再利用しているため別途検証済み。
        (
            "var t=document.createElement('div'); t.setAttribute('id','cfe-target'); var b=document.createElement('button'); b.commandForElement=t; b.getAttribute('commandfor')",
            "cfe-target",
        ),
        // プレーンオブジェクトのプロパティ列挙順序（ECMA-262
        // `OrdinaryOwnPropertyKeys`）が丸ごと未対応だった（`Obj.props`が
        // `BTreeMap`のため常に文字列の辞書式順序になっていた、
        // architecture-level の既知ギャップ）。`BTreeMap`→`IndexMap`移行
        // （挿入順保持。2026-07-18完了）に続けて、`Object.keys`/`.values`/
        // `.entries`へ「正整数キー→数値昇順」「残り→挿入順」の2段階
        // 並べ替え（`spec_key_order`）を配線し、仕様どおりの列挙順序を
        // 完成させた。2026-07-21 に `for...in`/`JSON.stringify`/スプレッド構文/
        // `Object.assign` 等すべての列挙箇所への同ロジック横展開を完了。
        (
            "Object.keys({y:1,x:2,a:3}).join(',')",
            "y,x,a",
        ),
        (
            "var o={}; delete o.x; o.b=1; o.a=2; o.c=3; delete o.a; o.a=4; Object.keys(o).join(',')",
            "b,c,a",
        ),
        (
            "Object.keys({2:'b',1:'a',10:'c'}).join(',')",
            "1,2,10",
        ),
        (
            "Object.keys({10:'c',y:1,2:'b',x:2}).join(',')",
            "2,10,y,x",
        ),
        (
            "Object.values({10:'c',y:1,2:'b',x:2}).join(',')",
            "b,c,1,2",
        ),
        (
            "var res=[]; for(var k in {10:'c',y:1,2:'b',x:2}){ res.push(k); } res.join(',')",
            "2,10,y,x",
        ),
        (
            "JSON.stringify({10:'c',y:1,2:'b',x:2})",
            "{\"2\":\"b\",\"10\":\"c\",\"y\":1,\"x\":2}",
        ),
        (
            "Object.keys({...{10:'c',y:1,2:'b',x:2}}).join(',')",
            "2,10,y,x",
        ),
        (
            "Object.keys(Object.assign({}, {10:'c',y:1,2:'b',x:2})).join(',')",
            "2,10,y,x",
        ),
        (
            "Object.entries({2:'b',y:1,1:'a'}).map(e=>e.join(':')).join(',')",
            "1:a,2:b,y:1",
        ),
        // `01`（先頭ゼロ）は仕様上「配列インデックス」ではなく通常の文字列
        // キー扱いのため数値昇順の対象外（挿入順のまま）。
        (
            "Object.keys({'01':'x', 1:'y'}).join(',')",
            "1,01",
        ),
        // ECMAScript Internationalization API (Intl)
        (
            "typeof Intl",
            "object",
        ),
        (
            "Intl.getCanonicalLocales('ja-JP').join(',')",
            "ja-JP",
        ),
        // `ja-JP`も`en-US`と同じ3桁カンマ区切り書式を使う言語のため`"123,456"`が
        // 正しい期待値（この処理系はロケール別の書式データベースを持たず全て
        // 同じ簡略書式を使うため、ロケール文字列自体は解析結果に影響しない）。
        // 元は書式化ロジック実装前の無加工出力`"123456"`をそのまま期待値に
        // していた誤り（2026-07-18 発見・修正）。
        (
            "new Intl.NumberFormat('ja-JP').format(123456)",
            "123,456",
        ),
        (
            "new Intl.DateTimeFormat('ja-JP').resolvedOptions().locale",
            "ja-JP",
        ),
        (
            "new Intl.Collator().compare('a', 'b')",
            "-1",
        ),
        (
            "new Intl.PluralRules().select(1)",
            "one",
        ),
        (
            "new Intl.RelativeTimeFormat().format(-1, 'day')",
            "1 days ago",
        ),
        (
            "new Intl.ListFormat().format(['a', 'b'])",
            "a, b",
        ),
        (
            "new Intl.DisplayNames(['en'], {type: 'language'}).of('ja')",
            "ja",
        ),
        // RegExp u/v flags & Unicode property escapes
        (
            "new RegExp('a', 'u').unicode",
            "true",
        ),
        (
            "new RegExp('a', 'v').unicodeSets",
            "true",
        ),
        (
            "/\\p{Letter}/u.test('A')",
            "true",
        ),
        (
            "/\\p{Number}/u.test('9')",
            "true",
        ),
        // Generator.prototype.return(v) & try...finally
        (
            "var finRan = false; function* g() { try { yield 1; } finally { finRan = true; } } var it = g(); it.next(); it.return(42); finRan",
            "true",
        ),
        // `Object.create(null)`/`Object.groupBy()`/`Object.setPrototypeOf(obj,null)`が
        // 実際には`Object.prototype`のメソッド（`hasOwnProperty`/`toString`等）を
        // 引き続き持ってしまうバグ（`proto: None`だけでは「明示的にnull
        // プロトタイプ」なのか「単に通常オブジェクトでチェーンが尽きた」のか
        // 区別できず、`get_property`の共通メソッドフォールバックが無条件に
        // 適用されていた）。`null_proto`フラグを新設して修正（2026-07-18
        // 発見・実装）。
        (
            "typeof Object.create(null).hasOwnProperty",
            "undefined",
        ),
        (
            "typeof Object.create(null).toString",
            "undefined",
        ),
        (
            "Object.getPrototypeOf(Object.create(null))",
            "null",
        ),
        // 通常のオブジェクトリテラルは引き続き`Object.prototype`のメソッドを
        // 継承する（`null_proto`の導入で既存の通常オブジェクトの挙動を
        // 壊していないことの回帰確認）。
        (
            "typeof {}.hasOwnProperty",
            "function",
        ),
        (
            "typeof Object.groupBy([1,2,3], x=>x%2).hasOwnProperty",
            "undefined",
        ),
        (
            "var o={}; Object.setPrototypeOf(o, null); typeof o.toString",
            "undefined",
        ),
        // `setPrototypeOf`で実オブジェクトへ戻せば`null_proto`が解除され、
        // 継承したメソッドが再び見えることの確認。
        (
            "var o={}; Object.setPrototypeOf(o, null); Object.setPrototypeOf(o, Object.prototype); typeof o.hasOwnProperty",
            "function",
        ),
        // `crypto.subtle.digest('SHA-256', data)`が丸ごと未対応だった
        // （`Float16Array`/`oklch()`と同格の「1ビットの誤りが静かに間違った
        // 結果を生み続けるリスク」と判断し従来は着手見送りだったが、SHA-256は
        // NIST/RFC公開の既知の正解値で完全一致検証できる純粋なビット演算
        // アルゴリズムのため浮動小数点近似とは性質が異なり、リスク評価を
        // 見直し実装した。以下はFIPS 180-4/一般に広く知られる既知の正解値
        // （Known Answer Test）。2026-07-18 発見・実装）。
        (
            "await crypto.subtle.digest('SHA-256', new TextEncoder().encode('')).then(buf => Array.from(new Uint8Array(buf)).map(b=>b.toString(16).padStart(2,'0')).join(''))",
            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
        ),
        (
            "await crypto.subtle.digest('SHA-256', new TextEncoder().encode('abc')).then(buf => Array.from(new Uint8Array(buf)).map(b=>b.toString(16).padStart(2,'0')).join(''))",
            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
        ),
        (
            "await crypto.subtle.digest('SHA-256', new TextEncoder().encode('The quick brown fox jumps over the lazy dog')).then(buf => Array.from(new Uint8Array(buf)).map(b=>b.toString(16).padStart(2,'0')).join(''))",
            "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592",
        ),
        // `algorithm`引数を`{name: "SHA-256"}`形式（実ブラウザでも有効な
        // もう一方の呼び出し形式）で渡しても同じ結果になることの確認。
        (
            "await crypto.subtle.digest({name: 'SHA-256'}, new TextEncoder().encode('abc')).then(buf => Array.from(new Uint8Array(buf)).map(b=>b.toString(16).padStart(2,'0')).join(''))",
            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
        ),
        // 未対応アルゴリズム名は仕様どおりPromiseのreject（例外）で通知される。
        (
            "await crypto.subtle.digest('SHA-1', new TextEncoder().encode('x')).then(() => 'resolved', () => 'rejected')",
            "rejected",
        ),
        // `TextDecoder.decode(arrayBuffer)`（TypedArrayビューではなく生の
        // `ArrayBuffer`を直接渡す、仕様上有効な呼び出し形式）が常に空文字列を
        // 返すバグだった（`crypto.subtle.digest`実装の検証中に発見した
        // `new Uint8Array(arrayBuffer)`のゼロ埋めバグと同系統の「生の
        // ArrayBufferから実データを読む経路」の欠落）。2026-07-18 発見・実装。
        (
            "new TextDecoder().decode(new TextEncoder().encode('hello').buffer)",
            "hello",
        ),
        (
            "new TextDecoder().decode(new Uint8Array([65,116,109,79,83]).buffer)",
            "AtmOS",
        ),
        // `DataView` を `TextDecoder.decode` や `crypto.subtle.digest` や
        // `new Uint8Array(dataView)` に渡した際、`_dv_bytes` が参照されず
        // 全ゼロ埋めになるバグを修正（2026-07-21 発見・実装）。
        (
            "new TextDecoder().decode(new DataView(new TextEncoder().encode('AtmOS').buffer))",
            "AtmOS",
        ),
        (
            "await crypto.subtle.digest('SHA-256', new DataView(new TextEncoder().encode('abc').buffer)).then(buf => Array.from(new Uint8Array(buf)).map(b=>b.toString(16).padStart(2,'0')).join(''))",
            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
        ),
        (
            "new Uint8Array(new DataView(new Uint8Array([65,66,67]).buffer)).join('')",
            "656667",
        ),
        // `String.prototype.normalize()` 日本語ひらがな・カタカナの濁点・半濁点の分解（NFD）・合成（NFC）
        (
            "'が'.normalize('NFD') === 'か\\u3099'",
            "true",
        ),
        (
            "'か\\u3099'.normalize('NFC')",
            "が",
        ),
        (
            "'パ'.normalize('NFD') === 'ハ\\u309A'",
            "true",
        ),
        (
            "'ハ\\u309A'.normalize('NFC')",
            "パ",
        ),
        // `structuredClone` 極端な深いネストの保護（DataCloneError 例外の返却）。
        // 元は閾値1000・ネスト1100段でテストしていたが、これ自体が
        // ブート時点の64KB初期コアスタックを枯渇させ、QEMU起動が丸ごと
        // 無応答になる重大な回帰を引き起こしていた（実測で深さ80段でも
        // 無応答、50段は安全と確認）。`deep_clone_value`の閾値を30へ
        // 引き下げ、ネスト段数も安全に確認できた範囲内の40へ縮小する
        // （2026-07-18 発見・修正）。
        (
            "var a = []; var cur = a; for (var i = 0; i < 40; i++) { var n = []; cur.push(n); cur = n; } try { structuredClone(a); 'ok'; } catch (e) { e.name; }",
            "DataCloneError",
        ),
        // `structuredClone` フラットな大配列（要素数>30のオブジェクト配列）が
        // 累積オブジェクト数（seen.len()）ではなく再帰深さ（depth）で判定され
        // 正しく複製されることの検証（seen.len() ガード時代の過剰エラーバグ防止）。
        (
            "var a = []; for (var i = 0; i < 50; i++) { a.push({v: i}); } var c = structuredClone(a); c.length === 50 && c[49].v === 49",
            "true",
        ),
        // `JSON.parse`（`os_lib::json::parse`のRust側相互再帰パーサ）にも
        // `structuredClone`と同種のRustネイティブ再帰スタックオーバーフロー
        // リスクがあったため、同じ閾値30の深さガードを新設（2026-07-21）。
        // 20階層のネストは閾値内で安全にパースできる。
        (
            "(function(){ var s = '['.repeat(20) + '0' + ']'.repeat(20); try { JSON.parse(s); return 'ok'; } catch (e) { return 'error'; } })()",
            "ok",
        ),
        // GlobalEventHandlers (onchange / onclick 等) の属性・プロパティ統合テスト
        (
            "var d=document.createElement('div'); var r='none'; d.onchange=function(){r='ok';}; d.dispatchEvent(new Event('change')); r",
            "ok",
        ),
        // outerHTML セッターのテスト
        (
            "var p=document.createElement('div'); p.innerHTML='<span id=x>old</span>'; var s=p.children[0]; s.outerHTML='<b id=y>new</b>'; p.children[0].tagName+','+p.children[0].id",
            "B,y",
        ),
    ];
    let mut passed = 0;
    let mut total = cases.len();
    for (src, expect) in cases {
        let mut rt = JsRuntime::new();
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
        }
    }

    // setInterval / clearInterval の2段階評価テスト
    {
        total += 1;
        let mut rt = JsRuntime::new();
        let _ = rt.eval("var n=0; var id=setInterval(function(){n++;}, 10);");
        match rt.eval("n > 0") {
            Ok(v) if v.to_js_string() == "true" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `setInterval` => n > 0 is `{}` (want true)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `setInterval` => {}", e),
        }
    }
    {
        total += 1;
        let mut rt = JsRuntime::new();
        let _ = rt.eval("var n=0; var id=setInterval(function(){n++;}, 10); clearInterval(id);");
        match rt.eval("n") {
            Ok(v) if v.to_js_string() == "0" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `clearInterval` => n is `{}` (want 0)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `clearInterval` => {}", e),
        }
    }
    // `setInterval`の発火回数上限（以前は8回。実サイト www.sugi-lab.net の
    // 統計カウンターアニメーション`increment=target/100`が最終値の8%程度で
    // 頭打ちになり正しい数値へ到達できないバグだった。2026-07-22発見・修正で
    // 200回へ引き上げ）の回帰防止テスト。target=50, increment=0.5として、
    // 100回の発火で正確にtargetへ到達し`clearInterval`されることを検証する
    // （8回上限のままなら`n`は50に到達せず4のまま止まる）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        let _ = rt.eval(
            "var n=0; var target=50; var inc=target/100; \
             var id=setInterval(function(){ \
                 n+=inc; \
                 if (n>=target) { n=target; clearInterval(id); } \
             }, 1);",
        );
        match rt.eval("n") {
            Ok(v) if v.to_js_string() == "50" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: setInterval 統計カウンター模擬 => n is `{}` (want 50)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  setInterval 統計カウンター模擬 => {}", e),
        }
    }
    // `AbortSignal.timeout(ms)`（ES2022）の2段階評価テスト（setTimeout 経由で
    // マクロタスクキューが解ける必要があるため setInterval と同じ2段階構成）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        let _ = rt.eval(
            "var fired=false; var s=AbortSignal.timeout(0); s.addEventListener('abort', function(){fired=true;});",
        );
        // `s.reason.name`（丸ごと未対応だった。以前は既定の `AbortError` の
        // ままで仕様上の `TimeoutError`ではなかったバグ。2026-07-16 発見・
        // 実装）も合わせて検証する。
        match rt.eval("fired + ',' + s.reason.name") {
            Ok(v) if v.to_js_string() == "true,TimeoutError" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `AbortSignal.timeout` => `{}` (want `true,TimeoutError`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `AbortSignal.timeout` => {}", e),
        }
    }

    // DOM 連携（Phase 3）。小さな DOM を構築してから評価する。
    let dom_html = "<div id='out'>0</div><p class='msg'>hi</p><button id='b' class='x'>go</button>";
    let dom_cases: &[(&str, &str)] = &[
        ("document.getElementById('out').textContent", "0"),
        ("var e=document.getElementById('out'); e.textContent='42'; e.textContent", "42"),
        ("document.getElementById('out').tagName", "DIV"),
        ("document.querySelector('.msg').textContent", "hi"),
        ("document.querySelectorAll('div').length", "1"),
        ("document.getElementById('b').classList.contains('x')", "true"),
        ("var e=document.getElementById('b'); e.classList.add('y'); e.classList.contains('y')", "true"),
        ("var e=document.getElementById('b'); e.classList.toggle('x'); e.classList.contains('x')", "false"),
        ("var e=document.getElementById('out'); e.style.color='red'; e.style.color", "red"),
        ("document.getElementById('missing') === null", "true"),
        ("document.getElementById('b').getAttribute('id')", "b"),
        // `document.children`/`.childElementCount`（`ParentNode`ミックスイン
        // の`Document`側配線漏れ。丸ごと未対応だった。bare `cases`配列では
        // `<html>`未構築のため、実際にHTMLフィクスチャがあるこちらで検証。
        // 2026-07-17 発見・実装）。
        ("document.children.length", "1"),
        ("document.children[0] === document.documentElement", "true"),
        ("document.childElementCount", "1"),
        // addEventListener + クリック発火（ブリッジ経由でディスパッチ）
        ("var n=0; document.getElementById('b').addEventListener('click', () => n++); n", "0"),
        // 動的ノード（createElement / appendChild / innerHTML / remove）
        ("document.createElement('DIV').tagName", "DIV"),
        ("var d=document.createElement('div'); d.textContent='hi'; d.textContent", "hi"),
        // textContent/innerHTML は WebIDL 上 nullable (DOMString?) につき null/undefined 代入は空文字列になる
        ("var d=document.createElement('div'); d.textContent='hi'; d.textContent=null; d.textContent===''", "true"),
        ("var d=document.createElement('div'); d.innerHTML='<b>x</b>'; d.innerHTML=undefined; d.innerHTML===''", "true"),
        ("var c=document.getElementById('out'); var s=document.createElement('span'); s.textContent='X'; c.appendChild(s); c.textContent", "0X"),
        ("var c=document.getElementById('out'); c.innerHTML='<b>Y</b>'; c.textContent", "Y"),
        ("var c=document.getElementById('out'); var i=document.createElement('i'); c.appendChild(i); document.querySelector('i') === null", "false"),
        ("var c=document.getElementById('out'); c.innerHTML='<span class=z>1</span><span class=z>2</span>'; document.querySelectorAll('.z').length", "2"),
        ("var c=document.getElementById('out'); var t=document.createTextNode('TT'); c.appendChild(t); c.textContent", "0TT"),
        ("var c=document.getElementById('out'); c.appendChild(document.createElement('em')); document.querySelector('em').remove(); document.querySelector('em') === null", "true"),
        // `ariaActiveDescendantElement`（ARIA Element Reflection。
        // `aria-activedescendant`のidref文字列ではなく実際のElement参照を
        // 返す/設定する。`popoverTargetElement`と同じidref解決パターン。
        // 丸ごと未対応だった。既にDOMツリーに接続されたフィクスチャ要素
        // （`get_element_by_id`は接続済みノードしか見ない）が必要なため、
        // bare `cases`配列ではなくこちらのfixture付き配列で検証。
        // 2026-07-18 発見・実装）。
        (
            "var a=document.createElement('div'); var b=document.getElementById('out'); a.ariaActiveDescendantElement=b; a.getAttribute('aria-activedescendant')+'|'+(a.ariaActiveDescendantElement===b)",
            "out|true",
        ),
        // `ariaLabelledByElements`/`ariaDescribedByElements`等（ARIA Element
        // Reflection、複数形）が丸ごと未対応だった。空白区切りidref属性を
        // 実際のElement参照の配列として読み書きする。単数形の
        // `ariaActiveDescendantElement`と同じ理由で接続済みfixture要素が
        // 必要。2026-07-18 発見・実装）。
        (
            "var a=document.createElement('div'); var b1=document.getElementById('out'); var b2=document.getElementById('b'); a.ariaLabelledByElements=[b1,b2]; a.getAttribute('aria-labelledby')+'|'+a.ariaLabelledByElements.length+'|'+(a.ariaLabelledByElements[0]===b1)+'|'+(a.ariaLabelledByElements[1]===b2)",
            "out b|2|true|true",
        ),
        (
            "document.createElement('div').ariaDescribedByElements.length",
            "0",
        ),
        // `parent.moveBefore(movedNode, referenceNode)`（丸ごと未対応
        // だった。この処理系には保持すべき「生きた状態」自体が無いため、
        // `insertBefore`と同じdetach+挿入の簡略実装で仕様どおり動作する。
        // 2026-07-18 発見・実装）。
        (
            "var p1=document.createElement('div'); var p2=document.createElement('div'); var m=document.createElement('span'); p1.appendChild(m); var r=document.createElement('b'); p2.appendChild(r); p2.moveBefore(m, r); m.parentNode===p2 && p2.firstChild===m && p1.children.length",
            "0",
        ),
        (
            "var p=document.createElement('div'); var a=document.createElement('i'); var b=document.createElement('b'); p.appendChild(a); p.appendChild(b); p.moveBefore(b, a); p.firstChild===b",
            "true",
        ),
        (
            "var p1=document.createElement('div'); var p2=document.createElement('div'); var m=document.createElement('span'); var other=document.createElement('b'); p1.appendChild(m); p2.appendChild(other); try { p1.moveBefore(m, other); 'no-throw'; } catch(e) { e.name; }",
            "NotFoundError",
        ),
    ];
    total += dom_cases.len();
    for (src, expect) in dom_cases {
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(dom_html));
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
        }
    }

    // 要素 DOM API（hasAttribute/removeAttribute/matches/closest/element querySelector/ナビ）。
    let dom2_html = "<div id='wrap' class='container'><p id='t' class='a b' data-k='v'>x</p><span id='s'>y</span></div>";
    let dom2_cases: &[(&str, &str)] = &[
        ("document.getElementById('t').hasAttribute('class')", "true"),
        ("document.getElementById('t').hasAttribute('nope')", "false"),
        ("document.getElementById('t').getAttribute('data-k')", "v"),
        ("var e=document.getElementById('t'); e.removeAttribute('class'); e.hasAttribute('class')", "false"),
        ("document.getElementById('t').matches('.a')", "true"),
        ("document.getElementById('t').matches('.z')", "false"),
        ("document.getElementById('t').matches('p')", "true"),
        ("document.getElementById('t').closest('.container').id", "wrap"),
        ("document.getElementById('t').closest('#wrap').id", "wrap"),
        ("document.getElementById('t').closest('p').id", "t"),
        ("document.getElementById('t').closest('.nope') === null", "true"),
        ("document.getElementById('wrap').querySelector('.a').id", "t"),
        ("document.getElementById('wrap').querySelector('span').id", "s"),
        ("document.getElementById('wrap').querySelectorAll('*').length", "2"),
        // コンパウンドセレクタ（タグ+クラス、以前は文字列全体をタグ名として比較しており
        // 常に false になっていた）。
        ("document.getElementById('t').matches('p.a')", "true"),
        ("document.getElementById('t').matches('p.z')", "false"),
        ("document.getElementById('t').matches('p.a.b')", "true"),
        // 属性セレクタ（以前は丸ごと未対応で常に false になっていた）。
        ("document.getElementById('t').matches('[data-k]')", "true"),
        ("document.getElementById('t').matches('[data-k=v]')", "true"),
        ("document.getElementById('t').matches('[data-k=x]')", "false"),
        ("document.getElementById('t').matches('[data-k^=v]')", "true"),
        // 結合子（子孫/子、以前は丸ごと未対応で常に false になっていた）。
        ("document.getElementById('t').matches('#wrap p')", "true"),
        ("document.getElementById('t').matches('#wrap > p')", "true"),
        ("document.getElementById('t').matches('#wrap > span')", "false"),
        // 一般兄弟結合子（`p ~ span`）。
        ("document.getElementById('s').matches('p ~ span')", "true"),
        ("document.getElementById('s').matches('span ~ span')", "false"),
        // querySelector(All) でも同じコンパウンド/属性セレクタが機能する。
        ("document.getElementById('wrap').querySelector('p.a').id", "t"),
        ("document.getElementById('wrap').querySelectorAll('[data-k]').length", "1"),
        // `:not()` 疑似クラス。
        ("document.getElementById('t').matches(':not(span)')", "true"),
        ("document.getElementById('t').matches(':not(p)')", "false"),
        ("document.getElementById('t').matches('p:not(.z)')", "true"),
        ("document.getElementById('t').matches('p:not(.a)')", "false"),
        ("document.getElementById('wrap').querySelectorAll(':not(span)').length", "1"),
        // `:scope` 疑似クラス（Selectors Level 4。丸ごと未対応だった）。
        // `element.querySelector(All)`/`matches`/`closest` における `:scope` は
        // 呼び出し元の要素自身を指す。
        ("document.getElementById('wrap').querySelectorAll(':scope > p').length", "1"),
        ("document.getElementById('wrap').querySelectorAll(':scope > p')[0].id", "t"),
        ("document.getElementById('wrap').querySelector(':scope > span').id", "s"),
        ("document.getElementById('wrap').querySelectorAll(':scope > .nope').length", "0"),
        ("document.getElementById('t').matches(':scope')", "true"),
        ("document.getElementById('t').closest(':scope').id", "t"),
        // 位置系疑似クラス（`:first-child`/`:last-child`/`:only-child`/`:nth-child()`）。
        ("document.getElementById('t').matches(':first-child')", "true"),
        ("document.getElementById('t').matches(':last-child')", "false"),
        ("document.getElementById('s').matches(':last-child')", "true"),
        ("document.getElementById('t').matches(':only-child')", "false"),
        ("document.getElementById('t').matches(':nth-child(1)')", "true"),
        ("document.getElementById('s').matches(':nth-child(2)')", "true"),
        ("document.getElementById('t').matches(':nth-child(odd)')", "true"),
        ("document.getElementById('s').matches(':nth-child(odd)')", "false"),
        ("document.getElementById('s').matches(':nth-child(2n)')", "true"),
        // `:nth-last-child()`（末尾から数える版。丸ごと未対応だった）。
        // #t/#s は2要素中1番目/2番目 → 末尾からは2番目/1番目。
        ("document.getElementById('s').matches(':nth-last-child(1)')", "true"),
        ("document.getElementById('t').matches(':nth-last-child(1)')", "false"),
        ("document.getElementById('t').matches(':nth-last-child(2)')", "true"),
        ("document.getElementById('s').matches(':nth-last-child(odd)')", "true"),
        // `:first-of-type`/`:last-of-type`/`:only-of-type`/`:nth-of-type()`（タグ名が
        // 同じ兄弟のみを数える点以外は `:nth-child()` 系と同じ規則）。各テストケースは
        // `document.getElementById` の「同一 id が複数あれば最初のものを返す」挙動と
        // 衝突しないよう、テストごとに固有の id を使う（以前は全ケースで同じ
        // p1/s1/p2/p3 を使い回しており、2回目以降は常に最初に追加した要素を
        // 参照してしまっていた）。
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot1a'>a</p><span id='ot1b'>b</span><p id='ot1c'>c</p><p id='ot1d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot1a').matches(':first-of-type')",
            "true",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot2a'>a</p><span id='ot2b'>b</span><p id='ot2c'>c</p><p id='ot2d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot2d').matches(':last-of-type')",
            "true",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot3a'>a</p><span id='ot3b'>b</span><p id='ot3c'>c</p><p id='ot3d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot3c').matches(':last-of-type')",
            "false",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot4a'>a</p><span id='ot4b'>b</span><p id='ot4c'>c</p><p id='ot4d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot4b').matches(':only-of-type')",
            "true",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot5a'>a</p><span id='ot5b'>b</span><p id='ot5c'>c</p><p id='ot5d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot5a').matches(':only-of-type')",
            "false",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot6a'>a</p><span id='ot6b'>b</span><p id='ot6c'>c</p><p id='ot6d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot6c').matches(':nth-of-type(2)')",
            "true",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot7a'>a</p><span id='ot7b'>b</span><p id='ot7c'>c</p><p id='ot7d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot7a').matches(':nth-of-type(2)')",
            "false",
        ),
        // `:nth-last-of-type()`（末尾から数える版。丸ごと未対応だった）。
        // p 要素は a/c/d の3つ → 末尾からは d=1番目, c=2番目, a=3番目。
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot8a'>a</p><span id='ot8b'>b</span><p id='ot8c'>c</p><p id='ot8d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot8d').matches(':nth-last-of-type(1)')",
            "true",
        ),
        (
            "var w=document.createElement('div'); w.innerHTML=\"<p id='ot9a'>a</p><span id='ot9b'>b</span><p id='ot9c'>c</p><p id='ot9d'>d</p>\"; document.getElementById('wrap').appendChild(w); document.getElementById('ot9a').matches(':nth-last-of-type(3)')",
            "true",
        ),
        // `:is()`/`:where()`（コンパウンドセレクタのリストのみ対応。結合子を含む
        // 複雑なセレクタは非対応）。
        ("document.getElementById('t').matches(':is(.z, .a)')", "true"),
        ("document.getElementById('t').matches(':is(.z, .y)')", "false"),
        ("document.getElementById('t').matches(':where(span, p.a)')", "true"),
        ("document.getElementById('s').matches(':is(span)')", "true"),
        ("document.getElementById('t').parentElement.id", "wrap"),
        ("document.getElementById('wrap').children.length", "2"),
        ("document.getElementById('wrap').childElementCount", "2"),
        // `node.hasChildNodes()`（丸ごと未対応だった。2026-07-15 発見・実装）。
        ("document.getElementById('wrap').hasChildNodes()", "true"),
        ("document.createElement('div').hasChildNodes()", "false"),
        // `document.createElementNS(ns, tag)`（丸ごと未対応だった。SVG 要素を
        // 動的生成する標準的な定番パターン。2026-07-15 発見・実装）。
        // `*AttributeNS` と同じく名前空間自体はモデル化せず非 NS 版へ委譲する
        // 簡略実装のため、生成される要素は通常の `createElement` と同じ。
        (
            "document.createElementNS('http://www.w3.org/2000/svg', 'circle').tagName",
            "CIRCLE",
        ),
        (
            "var e=document.createElementNS('http://www.w3.org/2000/svg', 'rect'); \
             e.setAttribute('width', '10'); e.getAttribute('width')",
            "10",
        ),
        ("document.getElementById('wrap').firstElementChild.id", "t"),
        ("document.getElementById('wrap').lastElementChild.id", "s"),
        ("document.getElementById('t').nextElementSibling.id", "s"),
        ("document.getElementById('s').previousElementSibling.id", "t"),
        ("document.getElementById('wrap').getAttributeNames().join(',')", "id,class"),
        // `element.attributes`（DOM 標準の `NamedNodeMap`。丸ごと未対応だった。
        // `{name,value}` オブジェクトの配列という簡略表現）。
        ("document.getElementById('wrap').attributes.length", "2"),
        ("document.getElementById('wrap').attributes[0].name", "id"),
        ("document.getElementById('wrap').attributes[0].value", "wrap"),
        // `getAttributeNode`/`setAttributeNode`/`removeAttributeNode`
        // （丸ごと未対応だった。2026-07-14 発見・実装）。
        ("document.getElementById('wrap').getAttributeNode('id').value", "wrap"),
        ("document.getElementById('wrap').getAttributeNode('missing')", "null"),
        (
            "var e=document.getElementById('wrap'); \
             e.setAttributeNode({name:'data-x', value:'1'}); e.getAttribute('data-x')",
            "1",
        ),
        (
            "var e=document.getElementById('wrap'); var a=e.getAttributeNode('id'); \
             e.removeAttributeNode(a); e.hasAttribute('id')",
            "false",
        ),
        // `document.createAttribute(name)`（丸ごと未対応だった。`Attr` ノードを
        // 新規に作ってから `setAttributeNode()` で取り付ける定番パターン。
        // 2026-07-15 発見・実装）。仕様どおり名前は小文字化される。
        ("document.createAttribute('DATA-X').name", "data-x"),
        ("document.createAttribute('data-x').value", ""),
        ("document.createAttribute('data-x').ownerElement", "null"),
        (
            "var e=document.getElementById('wrap'); var a=document.createAttribute('data-y'); \
             a.value='42'; e.setAttributeNode(a); e.getAttribute('data-y')",
            "42",
        ),
        // Fullscreen API（`element.requestFullscreen()`/`document.exitFullscreen()`/
        // `document.fullscreenElement`。丸ごと未対応だった。実際の画面占有切替は
        // 行わず状態のみ追跡する簡略実装）。
        ("document.fullscreenElement", "null"),
        ("document.fullscreenEnabled", "true"),
        (
            "var e=document.getElementById('wrap'); e.requestFullscreen(); document.fullscreenElement===e",
            "true",
        ),
        (
            "var e=document.getElementById('wrap'); e.requestFullscreen(); document.exitFullscreen(); document.fullscreenElement",
            "null",
        ),
        // Pointer Lock API（`element.requestPointerLock()`/`document.exitPointerLock()`/
        // `document.pointerLockElement`。丸ごと未対応だった。Fullscreen API と
        // 同じ「状態のみ追跡する」簡略実装）。
        ("document.pointerLockElement", "null"),
        (
            "var e=document.getElementById('wrap'); e.requestPointerLock(); document.pointerLockElement===e",
            "true",
        ),
        (
            "var e=document.getElementById('wrap'); e.requestPointerLock(); document.exitPointerLock(); document.pointerLockElement",
            "null",
        ),
        // Picture-in-Picture API（`element.requestPictureInPicture()`/
        // `document.exitPictureInPicture()`/`document.pictureInPictureElement`。
        // 丸ごと未対応だった。Fullscreen/Pointer Lock API と同じ
        // 「状態のみ追跡する」簡略実装）。
        ("document.pictureInPictureElement", "null"),
        ("document.pictureInPictureEnabled", "true"),
        (
            "var e=document.getElementById('wrap'); e.requestPictureInPicture(); \
             document.pictureInPictureElement===e",
            "true",
        ),
        (
            "var e=document.getElementById('wrap'); e.requestPictureInPicture(); \
             document.exitPictureInPicture(); document.pictureInPictureElement",
            "null",
        ),
        // `document.createTreeWalker(root)`（丸ごと未対応だった。DOM 部分木を
        // 走査する定番パターン。`wrap` の子は `#t`(p)/`#s`(span) の2要素）。
        (
            "document.createTreeWalker(document.getElementById('wrap')).currentNode.id",
            "wrap",
        ),
        (
            "var tw=document.createTreeWalker(document.getElementById('wrap')); \
             tw.firstChild(); tw.currentNode.id",
            "t",
        ),
        (
            "var tw=document.createTreeWalker(document.getElementById('wrap')); \
             tw.firstChild(); tw.nextSibling(); tw.currentNode.id",
            "s",
        ),
        (
            "var tw=document.createTreeWalker(document.getElementById('wrap')); \
             tw.firstChild(); tw.nextSibling(); tw.parentNode(); tw.currentNode.id",
            "wrap",
        ),
        (
            "var tw=document.createTreeWalker(document.getElementById('wrap')); \
             tw.nextNode(); tw.currentNode.id",
            "t",
        ),
        (
            "var tw=document.createTreeWalker(document.getElementById('wrap')); \
             var r=tw.parentNode(); r === null && tw.currentNode.id === 'wrap'",
            "true",
        ),
        // `document.createNodeIterator(root)`（丸ごと未対応だった。`TreeWalker` とは
        // 異なる「参照ノード＋前後どちら側を指しているか」のポインタモデル）。
        (
            "document.createNodeIterator(document.getElementById('wrap')).nextNode().id",
            "wrap",
        ),
        (
            "var ni=document.createNodeIterator(document.getElementById('wrap')); \
             ni.nextNode(); ni.nextNode().id",
            "t",
        ),
        // `#t` の中身はテキストノード "x" のため pre-order 3件目はそのテキスト
        // ノード（`nodeValue` で判定。`#s` に到達するのは5件目）。
        (
            "var ni=document.createNodeIterator(document.getElementById('wrap')); \
             ni.nextNode(); ni.nextNode(); ni.nextNode().nodeValue",
            "x",
        ),
        (
            "var ni=document.createNodeIterator(document.getElementById('wrap')); \
             ni.nextNode(); ni.nextNode(); ni.nextNode(); ni.nextNode().id",
            "s",
        ),
        (
            "var ni=document.createNodeIterator(document.getElementById('wrap')); \
             ni.nextNode(); ni.nextNode(); ni.nextNode(); ni.nextNode(); ni.nextNode(); \
             ni.nextNode() === null",
            "true",
        ),
        (
            "var ni=document.createNodeIterator(document.getElementById('wrap')); \
             ni.nextNode(); ni.nextNode(); ni.previousNode().id",
            "t",
        ),
        (
            "var ni=document.createNodeIterator(document.getElementById('wrap')); \
             ni.nextNode(); ni.nextNode(); ni.previousNode(); ni.previousNode().id",
            "wrap",
        ),
        // `element.contentEditable`/`.isContentEditable`/`document.designMode`
        // （丸ごと未対応だった。属性値の反映のみを行う簡略実装）。
        ("document.getElementById('wrap').contentEditable", "inherit"),
        ("document.getElementById('wrap').isContentEditable", "false"),
        (
            "var e=document.getElementById('wrap'); e.contentEditable='true'; \
             e.contentEditable + ',' + e.isContentEditable",
            "true,true",
        ),
        (
            "var e=document.getElementById('wrap'); e.contentEditable='plaintext-only'; \
             e.contentEditable + ',' + e.isContentEditable",
            "plaintext-only,true",
        ),
        (
            "var e=document.getElementById('wrap'); e.contentEditable='bogus'; e.contentEditable",
            "inherit",
        ),
        ("document.designMode", "off"),
        // `element.spellcheck`/`.inputMode`/`.enterKeyHint`（`spellcheck`/
        // `inputmode`/`enterkeyhint` グローバル属性の JS プロパティ版。丸ごと
        // 未対応だった。属性値の反映のみを行う簡略実装。2026-07-15 発見・実装）。
        ("document.getElementById('wrap').spellcheck", "true"),
        (
            "var e=document.getElementById('wrap'); e.spellcheck=false; e.spellcheck",
            "false",
        ),
        ("document.getElementById('wrap').inputMode", ""),
        (
            "var e=document.getElementById('wrap'); e.inputMode='numeric'; e.inputMode",
            "numeric",
        ),
        (
            "var e=document.getElementById('wrap'); e.enterKeyHint='search'; e.enterKeyHint",
            "search",
        ),
        // `element.autocapitalize`/`.popover`（`autocapitalize`/`popover`
        // グローバル属性の JS プロパティ版。丸ごと未対応だった。2026-07-15
        // 発見・実装。`popover` は `showPopover()`等のメソッド自体は前サイクル
        // 実装済みだが、属性読み書き用の IDL プロパティが欠けていた）。
        (
            "var e=document.getElementById('wrap'); e.autocapitalize='words'; e.autocapitalize",
            "words",
        ),
        ("document.createElement('div').popover", "null"),
        (
            "var e=document.createElement('div'); e.popover='manual'; e.popover",
            "manual",
        ),
        (
            "var e=document.createElement('div'); e.popover='auto'; e.popover=null; e.popover",
            "null",
        ),
        // `button.popoverTargetElement`/`.popoverTargetAction`（丸ごと未対応
        // だった。`popovertarget` idref 属性を実際の要素へ解決する IDL 属性。
        // 2026-07-15 発見・実装）。
        (
            "var b=document.createElement('button'); b.setAttribute('popovertarget','wrap'); \
             b.popoverTargetElement === document.getElementById('wrap')",
            "true",
        ),
        ("document.createElement('button').popoverTargetElement", "null"),
        (
            "var b=document.createElement('button'); b.popoverTargetElement = document.getElementById('wrap'); \
             b.getAttribute('popovertarget')",
            "wrap",
        ),
        (
            "var b=document.createElement('button'); b.popoverTargetAction='hide'; b.popoverTargetAction",
            "hide",
        ),
        // `input.list`（`list` idref 属性から実際の `<datalist>` 要素を解決する
        // IDL 属性。丸ごと未対応だった。2026-07-15 発見・実装）。
        ("document.createElement('input').list", "null"),
        (
            "var i=document.createElement('input'); i.setAttribute('list','missing'); i.list",
            "null",
        ),
        (
            "var dl=document.createElement('datalist'); dl.id='opts'; \
             document.getElementById('wrap').appendChild(dl); \
             var i=document.createElement('input'); i.setAttribute('list','opts'); \
             i.list === dl",
            "true",
        ),
        (
            "var d=document.createElement('div'); d.id='notdl'; \
             document.getElementById('wrap').appendChild(d); \
             var i=document.createElement('input'); i.setAttribute('list','notdl'); i.list",
            "null",
        ),
        // `a`/`area`/`link.relList`（`rel` 属性のトークン配列版。丸ごと未対応
        // だった。読み取り専用の簡略実装。2026-07-15 発見・実装）。
        ("document.createElement('a').relList.length", "0"),
        (
            "var a=document.createElement('a'); a.rel='noopener noreferrer'; \
             a.relList.join(',')",
            "noopener,noreferrer",
        ),
        (
            "var a=document.createElement('a'); a.rel='noopener noreferrer'; \
             a.relList.includes('noreferrer')",
            "true",
        ),
        // `.referrerPolicy`/`.loading`/`.decoding`/`.allow`/`.sandbox`（丸ごと
        // 未対応だった。属性値の反映のみを行う簡略実装。2026-07-15 発見・実装）。
        (
            "var a=document.createElement('a'); a.referrerPolicy='no-referrer'; \
             a.referrerPolicy",
            "no-referrer",
        ),
        (
            "var i=document.createElement('img'); i.loading='lazy'; i.loading",
            "lazy",
        ),
        (
            "var i=document.createElement('img'); i.decoding='async'; i.decoding",
            "async",
        ),
        (
            "var f=document.createElement('iframe'); f.allow='camera'; f.allow",
            "camera",
        ),
        ("document.createElement('iframe').sandbox.length", "0"),
        (
            "var f=document.createElement('iframe'); \
             f.setAttribute('sandbox','allow-scripts allow-forms'); \
             f.sandbox.join(',')",
            "allow-scripts,allow-forms",
        ),
        // `.crossOrigin`/`.fetchPriority`/`.integrity`/`script.async`/`.defer`/
        // `.noModule`（丸ごと未対応だった。属性値の反映のみを行う簡略実装。
        // 2026-07-15 発見・実装）。
        ("document.createElement('img').crossOrigin", "null"),
        (
            "var i=document.createElement('img'); i.crossOrigin='anonymous'; i.crossOrigin",
            "anonymous",
        ),
        ("document.createElement('img').fetchPriority", "auto"),
        (
            "var i=document.createElement('img'); i.fetchPriority='high'; i.fetchPriority",
            "high",
        ),
        (
            "var s=document.createElement('script'); s.integrity='sha256-x'; s.integrity",
            "sha256-x",
        ),
        (
            "var s=document.createElement('script'); s.async=true; s.async + ',' + \
             s.hasAttribute('async')",
            "true,true",
        ),
        (
            "var s=document.createElement('script'); s.defer=true; s.defer=false; s.defer",
            "false",
        ),
        (
            "var s=document.createElement('script'); s.noModule=true; s.noModule",
            "true",
        ),
        // `.srcset`/`.sizes`/`.media`/`img.useMap`/`.isMap`/`.currentSrc`
        // （丸ごと未対応だった。属性値の反映のみを行う簡略実装。2026-07-15
        // 発見・実装）。
        (
            "var i=document.createElement('img'); i.srcset='a.jpg 1x, b.jpg 2x'; i.srcset",
            "a.jpg 1x, b.jpg 2x",
        ),
        (
            "var i=document.createElement('img'); i.sizes='(max-width:600px) 480px'; i.sizes",
            "(max-width:600px) 480px",
        ),
        (
            "var l=document.createElement('link'); l.media='print'; l.media",
            "print",
        ),
        (
            "var i=document.createElement('img'); i.useMap='#m'; i.useMap",
            "#m",
        ),
        ("document.createElement('img').isMap", "false"),
        (
            "var i=document.createElement('img'); i.isMap=true; i.hasAttribute('ismap')",
            "true",
        ),
        (
            "var i=document.createElement('img'); i.src='a.jpg'; i.currentSrc",
            "a.jpg",
        ),
        // `img.complete`/`.naturalWidth`/`.naturalHeight`/`.decode()`が丸ごと
        // 未対応だった（2026-07-17 発見・実装。実デコード寸法を追跡する
        // 経路が無いため`naturalWidth`/`.naturalHeight`は常に`0`を返す
        // 誠実な簡略実装。`complete`は`src`の有無のみで判定）。
        ("document.createElement('img').complete", "false"),
        (
            "var i=document.createElement('img'); i.src='a.jpg'; i.complete",
            "true",
        ),
        (
            "var i=document.createElement('img'); i.src='a.jpg'; i.naturalWidth + ',' + i.naturalHeight",
            "0,0",
        ),
        (
            "var i=document.createElement('img'); i.src='a.jpg'; \
             await i.decode().then(() => 'ok')",
            "ok",
        ),
        (
            "var i=document.createElement('img'); \
             await i.decode().catch(e => e.name)",
            "EncodingError",
        ),
        // `audio`/`video.autoplay`/`.controls`/`.loop`/`.muted`/`.playsInline`/
        // `.preload`/`.poster`/`a.ping`/`.hreflang`（丸ごと未対応だった。属性値の
        // 反映のみを行う簡略実装。2026-07-15 発見・実装）。
        ("document.createElement('video').autoplay", "false"),
        (
            "var v=document.createElement('video'); v.autoplay=true; v.autoplay + \
             ',' + v.hasAttribute('autoplay')",
            "true,true",
        ),
        (
            "var v=document.createElement('video'); v.controls=true; v.controls=false; \
             v.controls",
            "false",
        ),
        (
            "var v=document.createElement('video'); v.loop=true; v.loop",
            "true",
        ),
        (
            "var v=document.createElement('video'); v.muted=true; v.muted",
            "true",
        ),
        (
            "var v=document.createElement('video'); v.playsInline=true; \
             v.hasAttribute('playsinline')",
            "true",
        ),
        (
            "var v=document.createElement('video'); v.preload='auto'; v.preload",
            "auto",
        ),
        (
            "var v=document.createElement('video'); v.poster='p.jpg'; v.poster",
            "p.jpg",
        ),
        (
            "var a=document.createElement('a'); a.ping='https://x'; a.ping",
            "https://x",
        ),
        (
            "var a=document.createElement('a'); a.hreflang='en'; a.hreflang",
            "en",
        ),
        // `audio`/`video.paused`/`.currentTime`/`.duration`/`.volume`/
        // `.playbackRate`（丸ごと未対応だった。`.play()`/`.pause()`と同じ
        // 状態追跡のみの簡略実装。2026-07-15 発見・実装）。
        ("document.createElement('video').paused", "true"),
        (
            "var v=document.createElement('video'); await v.play(); v.paused",
            "false",
        ),
        (
            "var v=document.createElement('video'); await v.play(); v.pause(); v.paused",
            "true",
        ),
        (
            "var v=document.createElement('video'); v.currentTime=12.5; v.currentTime",
            "12.5",
        ),
        (
            "var v=document.createElement('video'); Number.isNaN(v.duration)",
            "true",
        ),
        ("document.createElement('video').volume", "1"),
        (
            "var v=document.createElement('video'); v.volume=0.5; v.volume",
            "0.5",
        ),
        (
            "var v=document.createElement('video'); v.volume=5; v.volume",
            "1",
        ),
        (
            "var v=document.createElement('video'); v.playbackRate=2; v.playbackRate",
            "2",
        ),
        // `.play()`/`.pause()` の `play`/`playing`/`pause` イベント発火（丸ごと
        // 未対応だった。既に同じ状態なら発火しない冪等性も含む。2026-07-15
        // 発見・実装）。
        (
            "var v=document.createElement('video'); var log=[]; \
             v.addEventListener('play', ()=>log.push('play')); \
             v.addEventListener('playing', ()=>log.push('playing')); \
             await v.play(); log.join(',')",
            "play,playing",
        ),
        (
            "var v=document.createElement('video'); var n=0; \
             v.addEventListener('pause', ()=>n++); \
             await v.play(); v.pause(); v.pause(); n",
            "1",
        ),
        (
            "var v=document.createElement('video'); var n=0; \
             v.addEventListener('play', ()=>n++); \
             await v.play(); await v.play(); n",
            "1",
        ),
        // `.currentTime`/`.volume`/`.muted`/`.playbackRate` 代入時の
        // `seeked`/`volumechange`/`ratechange` イベント発火（丸ごと未対応
        // だった。2026-07-15 発見・実装）。
        (
            "var v=document.createElement('video'); var f=false; \
             v.addEventListener('seeked', ()=>f=true); v.currentTime=5; f",
            "true",
        ),
        (
            "var v=document.createElement('video'); var f=false; \
             v.addEventListener('volumechange', ()=>f=true); v.volume=0.3; f",
            "true",
        ),
        (
            "var v=document.createElement('video'); var f=false; \
             v.addEventListener('volumechange', ()=>f=true); v.muted=true; f",
            "true",
        ),
        (
            "var v=document.createElement('video'); var f=false; \
             v.addEventListener('ratechange', ()=>f=true); v.playbackRate=1.5; f",
            "true",
        ),
        // `.readyState`/`.networkState`/`.error`（丸ごと未対応だった。実際の
        // ネットワーク層/デコーダが無いため誠実に「何もロードしていない」
        // 状態を返す簡略実装。2026-07-15 発見・実装）。
        ("document.createElement('video').readyState", "0"),
        ("document.createElement('video').networkState", "0"),
        (
            "var v=document.createElement('video'); v.src='a.mp4'; v.networkState",
            "3",
        ),
        ("document.createElement('video').error", "null"),
        // `.buffered`/`.seekable`（`TimeRanges`。丸ごと未対応だった。実際には
        // メディアを一切ロードしないため常に空。範囲外アクセスは仕様どおり
        // 例外を投げる誠実な簡略実装）。`.defaultPlaybackRate` は単純な数値
        // 状態の保持のみ（`.playbackRate`とは独立）。2026-07-15 発見・実装。
        ("document.createElement('video').buffered.length", "0"),
        ("document.createElement('video').seekable.length", "0"),
        (
            "try { document.createElement('video').buffered.start(0); 'no-throw' } \
             catch(e) { 'threw' }",
            "threw",
        ),
        ("document.createElement('video').defaultPlaybackRate", "1"),
        (
            "var v=document.createElement('video'); v.defaultPlaybackRate=1.5; \
             v.defaultPlaybackRate + ',' + v.playbackRate",
            "1.5,1",
        ),
        // `element.getAnimations()`/`document.getAnimations()`（丸ごと未対応
        // だった。`.animate()` の戻り値を一切保持していないため常に空配列を
        // 返す誠実な簡略実装。2026-07-15 発見・実装）。
        (
            "document.createElement('div').getAnimations().length",
            "0",
        ),
        (
            "var e=document.createElement('div'); e.animate([], 100); \
             e.getAnimations().length",
            "0",
        ),
        ("document.getAnimations().length", "0"),
        // `Animation.reverse()`/`.finish()`/`.playbackRate`（丸ごと未対応
        // だった。`play`/`pause`/`cancel`と同じno-opの簡略方針。
        // 2026-07-17 発見・実装）。
        (
            "var a=document.createElement('div').animate([],100); \
             typeof a.reverse + ',' + typeof a.finish + ',' + a.playbackRate",
            "function,function,1",
        ),
        (
            "var a=document.createElement('div').animate([],100); a.reverse(); a.finish(); a.playbackRate=2; a.playbackRate",
            "2",
        ),
        // `script`/`style.nonce`（丸ごと未対応だった。属性値の反映のみを行う
        // 簡略実装。2026-07-15 発見・実装）。
        (
            "var s=document.createElement('script'); s.nonce='abc123'; s.nonce",
            "abc123",
        ),
        // `Selection`（`document.getSelection()`）の残りのメソッド群/
        // プロパティが丸ごと未対応だった。テキスト選択機構自体が無いため
        // 「常に何も選択していない」誠実な簡略実装。2026-07-15 発見・実装。
        (
            "var s=document.getSelection(); s.collapse(document.body, 0); \
             s.anchorNode + ',' + s.type",
            "null,None",
        ),
        (
            "var s=document.getSelection(); s.containsNode(document.body)",
            "false",
        ),
        // `Selection.removeRange(range)`が`addRange`/`removeAllRanges`の隣で
        // 漏れていた兄弟ギャップ（丸ごと未対応だった。2026-07-17 発見・
        // 実装）。
        (
            "typeof document.getSelection().removeRange",
            "function",
        ),
        (
            "document.getSelection().removeRange(document.createRange())",
            "undefined",
        ),
        (
            "try { document.getSelection().getRangeAt(0); 'no-throw' } \
             catch(e) { 'threw' }",
            "threw",
        ),
        // `Range`（`document.createRange()`）の残りのメソッド群/プロパティが
        // 丸ごと未対応だった。`Selection` と同方針の誠実な簡略実装。
        // 2026-07-15 発見・実装。
        (
            "var r=document.createRange(); r.setStart(document.body, 0); \
             r.collapsed + ',' + r.toString()",
            "true,",
        ),
        (
            "var r=document.createRange(); var r2=r.cloneRange(); \
             r2.collapsed",
            "true",
        ),
        (
            "document.createRange().isPointInRange(document.body, 0)",
            "false",
        ),
        (
            "document.designMode='on'; document.designMode",
            "on",
        ),
        // `element.hasAttributes()`（丸ごと未対応だった。単一属性の有無を見る
        // `hasAttribute(name)` は既に対応済みだったが、こちらが漏れていた）。
        ("document.getElementById('wrap').hasAttributes()", "true"),
        ("document.createElement('div').hasAttributes()", "false"),
        // `node.isSameNode(other)`/`node.isEqualNode(other)` が丸ごと未対応だった。
        ("var e=document.getElementById('wrap'); e.isSameNode(e)", "true"),
        (
            "document.getElementById('wrap').isSameNode(document.getElementById('t'))",
            "false",
        ),
        (
            "var a=document.createElement('div'); a.id='x'; var b=document.createElement('div'); b.id='x'; a.isEqualNode(b)",
            "true",
        ),
        (
            "var a=document.createElement('div'); a.id='x'; var b=document.createElement('div'); b.id='y'; a.isEqualNode(b)",
            "false",
        ),
        // `node.normalize()` が丸ごと未対応だった。連続する隣接テキストノードを
        // 1つに連結し、空のテキストノードを取り除く。
        (
            "var d=document.createElement('div'); d.appendChild(document.createTextNode('a')); d.appendChild(document.createTextNode('b')); d.normalize(); d.childNodes.length",
            "1",
        ),
        (
            "var d=document.createElement('div'); d.appendChild(document.createTextNode('a')); d.appendChild(document.createTextNode('b')); d.normalize(); d.textContent",
            "ab",
        ),
        (
            "var d=document.createElement('div'); d.appendChild(document.createTextNode('')); d.normalize(); d.childNodes.length",
            "0",
        ),
        // `document.createDocumentFragment()` が丸ごと未対応だった。挿入すると
        // フラグメント自身ではなく中身の子要素群がそのまま移動する（実 DOM の挙動）。
        ("typeof document.createDocumentFragment", "function"),
        (
            "var f=document.createDocumentFragment(); f.appendChild(document.createElement('span')); f.appendChild(document.createElement('em')); var d=document.createElement('div'); d.appendChild(f); d.children.length+','+d.children[0].tagName+','+d.children[1].tagName",
            "2,SPAN,EM",
        ),
        // フラグメント自身は挿入後に空になる（中身だけが移動したことの確認）。
        (
            "var f=document.createDocumentFragment(); f.appendChild(document.createElement('span')); var d=document.createElement('div'); d.appendChild(f); f.childNodes.length",
            "0",
        ),
        // getElementsByClassName / getElementsByTagName
        ("document.getElementsByTagName('p').length", "1"),
        ("document.getElementsByClassName('a')[0].id", "t"),
        ("document.getElementsByTagName('span')[0].id", "s"),
        // 要素インスタンス版の getElementsByClassName/getElementsByTagName
        // （`document` 版は対応済みだったがこちらが丸ごと未対応だった）。
        (
            "document.getElementById('wrap').getElementsByClassName('a')[0].id",
            "t",
        ),
        (
            "document.getElementById('wrap').getElementsByTagName('span')[0].id",
            "s",
        ),
        (
            "document.getElementById('s').getElementsByClassName('a').length",
            "0",
        ),
        // getElementsByTagNameNS / getAttributeNodeNS（丸ごと未対応だった）。
        ("document.getElementsByTagNameNS('*', 'span')[0].id", "s"),
        (
            "document.getElementById('wrap').getElementsByTagNameNS(null, 'span')[0].id",
            "s",
        ),
        (
            "document.getElementById('wrap').getAttributeNodeNS(null, 'id').value",
            "wrap",
        ),
        (
            "document.getElementById('wrap').getAttributeNodeNS('http://www.w3.org/1999/xhtml', 'missing') === null",
            "true",
        ),
        // `document.getElementsByName(name)`（丸ごと未対応だった。ラジオボタン
        // グループ等、同じ `name` 属性を持つ要素群をまとめて取得する定番
        // パターン。2026-07-15 発見・実装）。
        (
            "var a=document.createElement('input'); a.setAttribute('name','q'); \
             var b=document.createElement('input'); b.setAttribute('name','q'); \
             var wrap=document.getElementById('wrap'); \
             wrap.appendChild(a); wrap.appendChild(b); \
             document.getElementsByName('q').length",
            "2",
        ),
        ("document.getElementsByName('no-such-name').length", "0"),
        // append / prepend / before / after / replaceWith
        ("var w=document.getElementById('wrap'); var n=document.createElement('b'); n.id='ap'; w.append(n); w.lastElementChild.id", "ap"),
        ("var w=document.getElementById('wrap'); var n=document.createElement('b'); n.id='pp'; w.prepend(n); w.firstElementChild.id", "pp"),
        ("var n=document.createElement('b'); n.id='bf'; document.getElementById('t').before(n); document.getElementById('t').previousElementSibling.id", "bf"),
        ("var n=document.createElement('b'); n.id='af'; document.getElementById('t').after(n); document.getElementById('t').nextElementSibling.id", "af"),
        ("var n=document.createElement('b'); n.id='rw'; document.getElementById('s').replaceWith(n); document.getElementById('wrap').lastElementChild.id", "rw"),
        ("var w=document.getElementById('wrap'); w.append('TXT'); w.textContent.indexOf('TXT') >= 0", "true"),
        // `element.replaceChildren(...nodes)`（`innerHTML=''; append(...)` の1行版）
        // が丸ごと未対応だった。既存の子は全て消え、渡した内容だけが残る。
        (
            "var w=document.getElementById('wrap'); var n=document.createElement('b'); n.id='rc'; w.replaceChildren(n); w.children.length + ',' + w.firstElementChild.id",
            "1,rc",
        ),
        (
            "var w=document.getElementById('wrap'); w.replaceChildren(); w.children.length",
            "0",
        ),
        // `element.scrollTo(x,y)`/`.scrollBy(x,y)`（オブジェクト引数 `{top}` 形式も
        // 含む）が丸ごと未対応だった。既存の `element.scrollTop` setter へ委譲する。
        (
            "var w=document.getElementById('wrap'); w.scrollTo(0, 50); w.scrollTop",
            "50",
        ),
        (
            "var w=document.getElementById('wrap'); w.scrollTo({top: 30}); w.scrollTop",
            "30",
        ),
        (
            "var w=document.getElementById('wrap'); w.scrollTop=10; w.scrollBy(0, 5); w.scrollTop",
            "15",
        ),
        // classList 追加（length / value / item / toString）
        ("document.getElementById('t').classList.length", "2"),
        ("document.getElementById('t').classList.value", "a b"),
        ("document.getElementById('t').classList.item(0)", "a"),
        ("document.getElementById('t').classList.toString()", "a b"),
        // insertAdjacentHTML / insertAdjacentElement / toggleAttribute
        ("var w=document.getElementById('wrap'); w.insertAdjacentHTML('beforeend','<i id=iah>z</i>'); document.getElementById('iah').tagName", "I"),
        // position 引数は仕様上 ASCII 大文字小文字を無視すべきだが、以前は完全一致
        // のみで `"beforeEnd"` 等を渡すと静かに no-op になっていた。
        ("var w=document.getElementById('wrap'); w.insertAdjacentHTML('beforeEnd','<b id=iahc>z</b>'); document.getElementById('iahc').tagName", "B"),
        ("var t=document.getElementById('t'); t.insertAdjacentHTML('afterend','<u id=iae>q</u>'); t.nextElementSibling.id", "iae"),
        ("var t=document.getElementById('t'); var n=document.createElement('b'); n.id='iel'; t.insertAdjacentElement('beforebegin', n); t.previousElementSibling.id", "iel"),
        ("var t=document.getElementById('t'); t.toggleAttribute('hidden'); t.hasAttribute('hidden')", "true"),
        ("var t=document.getElementById('t'); t.toggleAttribute('hidden'); t.toggleAttribute('hidden'); t.hasAttribute('hidden')", "false"),
        ("var t=document.getElementById('t'); t.toggleAttribute('hidden', true); t.hasAttribute('hidden')", "true"),
        ("var t=document.getElementById('t'); t.toggleAttribute('hidden', true); t.toggleAttribute('hidden', false); t.hasAttribute('hidden')", "false"),
        // <dialog> の show()/showModal()/close()（以前は丸ごと未対応だった）。
        ("var d=document.createElement('dialog'); d.open", "false"),
        ("var d=document.createElement('dialog'); d.show(); d.open", "true"),
        ("var d=document.createElement('dialog'); d.showModal(); d.open", "true"),
        // `.show()`と`.showModal()`が同一実装を共有しておりCSS `:modal`用の
        // 区別が一切無かった（2026-07-18 発見・実装）。`_modal`は
        // `showModal()`のみが書き込む内部専用属性で、`.show()`では
        // 付かず、`.close()`/`.requestClose()`でどちらも除去される。
        ("var d=document.createElement('dialog'); d.show(); d.hasAttribute('_modal')", "false"),
        ("var d=document.createElement('dialog'); d.showModal(); d.hasAttribute('_modal')", "true"),
        ("var d=document.createElement('dialog'); d.showModal(); d.close(); d.hasAttribute('_modal')", "false"),
        ("var d=document.createElement('dialog'); d.show(); d.close(); d.open", "false"),
        ("var d=document.createElement('dialog'); d.show(); d.close('ok'); d.returnValue", "ok"),
        (
            "var d=document.createElement('dialog'); var closed=false; d.addEventListener('close', function(){ closed=true; }); d.show(); d.close(); closed",
            "true",
        ),
        ("var d=document.createElement('dialog'); d.open=true; d.hasAttribute('open')", "true"),
        // Popover API `showPopover()`/`hidePopover()`/`togglePopover(force?)`
        // （丸ごと未対応だった。`<dialog>` の `open` 属性と同じ内部専用属性の
        // 付け外しのみの簡略実装。2026-07-15 発見・実装）。
        ("var e=document.createElement('div'); e.togglePopover()", "true"),
        (
            "var e=document.createElement('div'); e.togglePopover(); e.togglePopover()",
            "false",
        ),
        (
            "var e=document.createElement('div'); e.togglePopover(true); e.togglePopover(true)",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.showPopover(); e.togglePopover()",
            "false",
        ),
        // Popover API が状態変化を`toggle`イベントとして発火していな
        // かった（`<dialog>.close()`は既に`"close"`イベントを発火して
        // いたのに同じ役目のPopover側だけ漏れていた。丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "var e=document.createElement('div'); var n=0; \
             e.addEventListener('toggle', () => n++); e.showPopover(); e.hidePopover(); n",
            "2",
        ),
        (
            "var e=document.createElement('div'); var n=0; \
             e.addEventListener('toggle', () => n++); e.togglePopover(); n",
            "1",
        ),
        // `toggle`イベントの`oldState`/`newState`（仕様上の`ToggleEvent`の
        // 主要プロパティ。丸ごと未対応だった。2026-07-17 発見・実装）。
        (
            "var e=document.createElement('div'); var s=''; \
             e.addEventListener('toggle', ev => s=ev.oldState+'>'+ev.newState); \
             e.showPopover(); s",
            "closed>open",
        ),
        (
            "var e=document.createElement('div'); var s=''; \
             e.addEventListener('toggle', ev => s=ev.oldState+'>'+ev.newState); \
             e.showPopover(); e.hidePopover(); s",
            "open>closed",
        ),
        // `beforetoggle`（状態変更「前」に発火する取消可能なイベント。
        // `preventDefault()`で開閉を中止できる。丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        (
            "var e=document.createElement('div'); var n=0; \
             e.addEventListener('beforetoggle', () => n++); e.showPopover(); n",
            "1",
        ),
        (
            "var e=document.createElement('div'); var toggled=false; \
             e.addEventListener('beforetoggle', ev => ev.preventDefault()); \
             e.addEventListener('toggle', () => toggled=true); \
             e.showPopover(); toggled",
            "false",
        ),
        (
            "var e=document.createElement('div'); \
             e.addEventListener('beforetoggle', ev => ev.preventDefault()); \
             e.showPopover(); e.togglePopover()",
            "false",
        ),
        // `inert` グローバル真偽属性（丸ごと未対応だった）。
        ("var t=document.createElement('div'); t.inert", "false"),
        ("var t=document.createElement('div'); t.setAttribute('inert',''); t.inert", "true"),
        ("var t=document.createElement('div'); t.inert=true; t.hasAttribute('inert')", "true"),
        ("var t=document.createElement('div'); t.inert=true; t.inert=false; t.hasAttribute('inert')", "false"),
        // <template>.content（丸ごと未対応だった）。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; tpl.content.children.length",
            "1",
        ),
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; tpl.content.firstChild.textContent",
            "hi",
        ),
        // 初回アクセスで子がフラグメント側へ移り、template 自身は空になる。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; var f=tpl.content; tpl.children.length",
            "0",
        ),
        // 2回目以降のアクセスでも同じフラグメントを返す（子を再度奪わない）。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; var f1=tpl.content; var f2=tpl.content; f1===f2",
            "true",
        ),
        // DocumentFragment を appendChild すると中身だけが移動する（実 DOM と同じ挙動）。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; var host=document.createElement('div'); host.appendChild(tpl.content); host.children.length",
            "1",
        ),
        // `document.importNode(externalNode, deep)`/`document.adoptNode(node)`
        // （丸ごと未対応だった。`<template>` の中身を取り込む定番パターン。
        // 2026-07-15 発見・実装）。`importNode` はコピーなので元の `.content`
        // には影響しない。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; \
             var imported=document.importNode(tpl.content, true); \
             var host=document.createElement('div'); host.appendChild(imported); \
             host.children.length + ',' + tpl.content.children.length",
            "1,1",
        ),
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; \
             document.importNode(tpl.content, true).firstChild.textContent",
            "hi",
        ),
        (
            "var host1=document.createElement('div'); var host2=document.createElement('div'); \
             var child=document.createElement('span'); host1.appendChild(child); \
             document.adoptNode(child); host2.appendChild(child); \
             host1.children.length + ',' + host2.children.length",
            "0,1",
        ),
        // cloneNode(): .content に一度アクセス済みの <template> を複製すると、
        // クローン先の .content が元の（同じ）フラグメントを指したまま共有されて
        // しまうバグだった（複製後にクローン側の中身を変更しても元に影響しない、
        // という cloneNode の基本契約が破られていた）。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; var f=tpl.content; \
             var clone=tpl.cloneNode(true); clone.content===tpl.content",
            "false",
        ),
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='<p>hi</p>'; var f=tpl.content; \
             var clone=tpl.cloneNode(true); clone.content.children.length+','+tpl.content.children.length",
            "1,1",
        ),
        // outerHTML/getAttributeNames() が `_content_frag`（`.content` アクセス済み
        // <template> が内部で持つ housekeeping 属性）等の `_` 始まり内部専用属性を
        // そのまま漏らしていたバグ。
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='hi'; var f=tpl.content; tpl.outerHTML",
            "<template></template>",
        ),
        (
            "var tpl=document.createElement('template'); tpl.innerHTML='hi'; var f=tpl.content; \
             tpl.getAttributeNames().join(',')",
            "",
        ),
        // <progress>/<meter> の .value/.max/.min（丸ごと未対応だった。既定値は
        // 仕様どおり value=0/max=1/meter.min=0）。
        ("document.createElement('progress').value", "0"),
        ("document.createElement('progress').max", "1"),
        ("var p=document.createElement('progress'); p.setAttribute('value','30'); p.setAttribute('max','50'); p.value+'/'+p.max", "30/50"),
        ("var p=document.createElement('progress'); p.value=40; p.getAttribute('value')", "40"),
        ("document.createElement('meter').min", "0"),
        ("var m=document.createElement('meter'); m.setAttribute('value','5'); typeof m.value", "number"),
        // `input.valueAsNumber`（HTML5。丸ごと未対応だった）。
        ("var i=document.createElement('input'); i.type='number'; i.value='42'; i.valueAsNumber", "42"),
        ("var i=document.createElement('input'); i.type='text'; i.value='42'; isNaN(i.valueAsNumber)", "true"),
        ("var i=document.createElement('input'); i.type='number'; i.valueAsNumber=7; i.value", "7"),
        ("var i=document.createElement('input'); i.type='number'; i.value='5'; i.valueAsNumber=NaN; i.value", ""),
        // `input.valueAsDate`（HTML5。`type="date"`/`"month"` の丸ごと未対応だった。
        // `week`/その他の type は仕様どおり `null`）。
        (
            "var i=document.createElement('input'); i.type='date'; i.value='2024-03-15'; \
             i.valueAsDate.getUTCFullYear()+'-'+(i.valueAsDate.getUTCMonth()+1)+'-'+i.valueAsDate.getUTCDate()",
            "2024-3-15",
        ),
        ("var i=document.createElement('input'); i.type='text'; i.value='2024-03-15'; i.valueAsDate", "null"),
        (
            "var i=document.createElement('input'); i.type='date'; i.valueAsDate=new Date(Date.UTC(2024,2,15)); i.value",
            "2024-03-15",
        ),
        (
            "var i=document.createElement('input'); i.type='month'; i.valueAsDate=new Date(Date.UTC(2024,2,15)); i.value",
            "2024-03",
        ),
        (
            "var i=document.createElement('input'); i.type='date'; i.value='x'; i.valueAsDate=null; i.value",
            "",
        ),
        // `input[type=date/month/datetime-local].value`は仕様上、属性値が
        // 正しい形式でなければ空文字列を返すべきだが、`color`/`range`と同じ
        // バグパターンで不正な生文字列がそのまま漏れていた。
        (
            "var i=document.createElement('input'); i.type='date'; \
             i.setAttribute('value','not-a-date'); i.value",
            "",
        ),
        (
            "var i=document.createElement('input'); i.type='date'; \
             i.setAttribute('value','2026-07-18'); i.value",
            "2026-07-18",
        ),
        (
            "var i=document.createElement('input'); i.type='month'; \
             i.setAttribute('value','garbage'); i.value",
            "",
        ),
        (
            "var i=document.createElement('input'); i.type='datetime-local'; \
             i.setAttribute('value','2026-07-18T14:30'); i.value",
            "2026-07-18T14:30",
        ),
        // getAttributeNS/setAttributeNS/hasAttributeNS/removeAttributeNS（丸ごと
        // 未対応だった。名前空間は無視し非NS版と同じ属性ストアへ委譲する簡略実装）。
        ("var e=document.createElement('div'); e.setAttributeNS(null,'data-k','v'); e.getAttribute('data-k')", "v"),
        ("var e=document.createElement('div'); e.setAttribute('data-k','v'); e.getAttributeNS(null,'data-k')", "v"),
        ("var e=document.createElement('div'); e.setAttributeNS(null,'data-k','v'); e.hasAttributeNS(null,'data-k')", "true"),
        (
            "var e=document.createElement('div'); e.setAttributeNS(null,'data-k','v'); e.removeAttributeNS(null,'data-k'); e.hasAttribute('data-k')",
            "false",
        ),
        // node.getRootNode()（丸ごと未対応だった）。
        (
            "var p=document.createElement('div'); var c=document.createElement('span'); p.appendChild(c); c.getRootNode()===p",
            "true",
        ),
        // 接続済みツリーでは異なる要素同士でも同じルートを返す。
        (
            "document.getElementById('t').getRootNode()===document.getElementById('wrap').getRootNode()",
            "true",
        ),
        // 親の無い単独ノードは自分自身を返す。
        ("var e=document.createElement('div'); e.getRootNode()===e", "true"),
        // lookupNamespaceURI/lookupPrefix/isDefaultNamespace（丸ごと未対応
        // だった。2026-07-16 発見・実装。この処理系は XML 名前空間を一切
        // モデル化していないため常に「名前空間なし」を返す簡略実装）。
        ("var e=document.createElement('div'); e.lookupNamespaceURI('svg')", "null"),
        ("var e=document.createElement('div'); e.lookupPrefix('http://www.w3.org/2000/svg')", "null"),
        ("var e=document.createElement('div'); e.isDefaultNamespace(null)", "true"),
        ("var e=document.createElement('div'); e.isDefaultNamespace('http://www.w3.org/2000/svg')", "false"),
        // ノード読みプロパティ（nodeType / nodeName / hidden）
        ("document.getElementById('t').nodeType", "1"),
        ("document.getElementById('t').nodeName", "P"),
        ("document.getElementById('t').hidden", "false"),
        ("var e=document.getElementById('t'); e.toggleAttribute('hidden'); e.hidden", "true"),
        // dataset（data-* ↔ camelCase）  ※ getBoundingClientRect は別ブロックで rect を注入して検証

        ("document.getElementById('t').dataset.k", "v"),
        ("var e=document.getElementById('t'); e.dataset.userId='42'; e.getAttribute('data-user-id')", "42"),
        ("var e=document.getElementById('t'); e.setAttribute('data-foo-bar','9'); e.dataset.fooBar", "9"),
        ("document.getElementById('t').dataset.missing === undefined", "true"),
        // `delete element.dataset.foo` は `dataset:` プロキシが `.props` を持たず実データが
        // DOM ノード属性側にあるため、何も起きない黙殺バグだった。
        (
            "var e=document.getElementById('t'); e.dataset.temp='x'; delete e.dataset.temp; e.dataset.temp === undefined",
            "true",
        ),
        (
            "var e=document.getElementById('t'); e.dataset.userId='42'; delete e.dataset.userId; e.hasAttribute('data-user-id')",
            "false",
        ),
        // `delete element.style.color` も同じ種類の黙殺バグだった。
        (
            "var e=document.getElementById('t'); e.style.color='red'; delete e.style.color; e.style.color",
            "",
        ),
        // insertBefore: 新ノードを s の前へ → wrap の子順が t, new, s
        ("var w=document.getElementById('wrap'); var n=document.createElement('b'); n.id='n'; w.insertBefore(n, document.getElementById('s')); w.children[1].id", "n"),
        ("var w=document.getElementById('wrap'); var n=document.createElement('b'); w.insertBefore(n, null); w.lastElementChild.tagName", "B"),
        // replaceChild: s を新ノードに置換
        ("var w=document.getElementById('wrap'); var n=document.createElement('i'); n.id='ni'; w.replaceChild(n, document.getElementById('s')); w.lastElementChild.id", "ni"),
        ("var w=document.getElementById('wrap'); var n=document.createElement('i'); var old=w.replaceChild(n, document.getElementById('s')); old.id", "s"),
        // `insertBefore`/`replaceChild`/`removeChild`は仕様上、参照ノードが
        // `this`の子でない場合`NotFoundError`を投げるべきだが、以前は検証が
        // 無く黙って末尾へ追加/何もせず成功したかのように振る舞っていた
        // （Table DOM/CharacterData/TypedArrayと同じ「不正な参照・範囲の
        // 黙殺」バグ族）。
        (
            "var w=document.getElementById('wrap'); var outsider=document.createElement('div'); \
             var n=document.createElement('b'); \
             try { w.insertBefore(n, outsider); 'no-throw' } catch(e) { e.name }",
            "NotFoundError",
        ),
        (
            "var w=document.getElementById('wrap'); var outsider=document.createElement('div'); \
             var n=document.createElement('b'); \
             try { w.replaceChild(n, outsider); 'no-throw' } catch(e) { e.name }",
            "NotFoundError",
        ),
        (
            "var w=document.getElementById('wrap'); var outsider=document.createElement('div'); \
             try { w.removeChild(outsider); 'no-throw' } catch(e) { e.name }",
            "NotFoundError",
        ),
        // cloneNode(deep): テキストごと複製
        ("document.getElementById('t').cloneNode(true).textContent", "x"),
        ("var c=document.getElementById('t').cloneNode(false); c.tagName + ':' + c.children.length", "P:0"),
        ("document.getElementById('t').cloneNode(true).parentElement === null", "true"),
        // classList.replace
        ("var e=document.getElementById('t'); e.classList.replace('a','z'); e.classList.contains('z') + ',' + e.classList.contains('a')", "true,false"),
        ("document.getElementById('t').classList.replace('nope','z')", "false"),
        // classList.toggle(name, force) — 第2引数 force が以前は完全に無視されていた。
        (
            "var e=document.getElementById('t'); e.classList.toggle('force-on', true); e.classList.contains('force-on')",
            "true",
        ),
        (
            "var e=document.getElementById('t'); e.classList.add('force-off'); e.classList.toggle('force-off', false); e.classList.contains('force-off')",
            "false",
        ),
        // classList.add/remove の複数引数（可変長引数）対応、classList.supports、webkitMatchesSelector、execCommand
        (
            "var e=document.createElement('div'); e.classList.add('c1', 'c2', 'c3'); e.className",
            "c1 c2 c3",
        ),
        (
            "var e=document.createElement('div'); e.classList.add('c1', 'c2', 'c3'); e.classList.remove('c1', 'c3'); e.className",
            "c2",
        ),
        (
            "var e=document.createElement('div'); e.classList.supports('foo')",
            "false",
        ),
        // 元は`document.body.appendChild`/`.remove()`を経由していたが、この
        // 自己テスト実行環境（`JsRuntime::new()`直後）には既定でパース済みの
        // `<html>`/`<body>`が一切存在しない（`document.body`は常に`null`）
        // ため、その`null`への`.appendChild`呼び出しが例外を投げていた
        // （2026-07-18 発見・修正）。`#id`セレクタの`matches()`判定は
        // ツリーへの接続を要さない（自身の`id`属性のみ見る）ため、
        // 接続操作自体が不要と判明し削除。
        (
            "var e=document.createElement('div'); e.id='wm'; e.webkitMatchesSelector('#wm')",
            "true",
        ),
        (
            "document.execCommand('copy')",
            "true",
        ),
        // `classList` の `Symbol.iterator`/`forEach` が丸ごと未対応で、`for...of`/
        // スプレッド/`forEach` のいずれも常に何も反復しない黙殺バグだった。
        (
            "var e=document.createElement('div'); e.className='a b c'; var out=[]; for (const c of e.classList) out.push(c); out.join(',')",
            "a,b,c",
        ),
        (
            "var e=document.createElement('div'); e.className='x y'; [...e.classList].join(',')",
            "x,y",
        ),
        (
            "var e=document.createElement('div'); e.className='p q'; var out=''; e.classList.forEach(function(c,i){out+=i+':'+c+' '}); out.trim()",
            "0:p 1:q",
        ),
        // `classList.entries()`/`.keys()`/`.values()`（丸ごと未対応だった。`forEach`
        // と for-of だけが配線され、明示イテレータ取得メソッド3種は未配線だった。
        // 2026-07-15 発見・実装）。
        (
            "var e=document.createElement('div'); e.className='r s'; var out=[]; for (const [i,c] of e.classList.entries()) out.push(i+':'+c); out.join(',')",
            "0:r,1:s",
        ),
        (
            "var e=document.createElement('div'); e.className='r s'; [...e.classList.keys()].join(',')",
            "0,1",
        ),
        (
            "var e=document.createElement('div'); e.className='r s'; [...e.classList.values()].join(',')",
            "r,s",
        ),
        // `Array.prototype.with(index, value)`（ES2023）— 範囲外 index は仕様上 RangeError
        // だが、以前は黙って無視して元と同じ配列を返していた。
        ("[1,2,3].with(1, 'x').join(',')", "1,x,3"),
        ("[1,2,3].with(-1, 'x').join(',')", "1,2,x"),
        (
            "try { [1,2,3].with(5, 'x'); 'no-throw' } catch(e) { 'threw' }",
            "threw",
        ),
        // `element.style.setProperty`/`getPropertyValue`/`removeProperty` が丸ごと
        // 欠落していた（直接のプロパティ代入 `el.style.color='red'` はあったが、
        // メソッド経由のインラインスタイル読み書きが無く、特に CSS カスタムプロパティ
        // `--foo` はこの経路でしか設定できないため影響が大きかった）。
        (
            "var e=document.getElementById('t'); e.style.setProperty('color','red'); e.style.color",
            "red",
        ),
        (
            "var e=document.getElementById('t'); e.style.setProperty('--my-var','10px'); e.style.getPropertyValue('--my-var')",
            "10px",
        ),
        (
            "var e=document.getElementById('t'); e.style.setProperty('color','blue'); e.style.removeProperty('color'); e.style.color",
            "",
        ),
        // `style.getPropertyPriority(name)`/`setProperty(name, value, priority)` の
        // 第3引数（丸ごと未対応・無視されていた。2026-07-16 発見・実装）。
        (
            "var e=document.getElementById('t'); e.style.setProperty('color','red','important'); e.style.getPropertyPriority('color')",
            "important",
        ),
        // `!important` 付きで設定した値を `getPropertyValue`/直接プロパティ双方から
        // 読んでも、優先度マーカーを含まない値本体のみが返るべき（仕様どおり）。
        (
            "var e=document.getElementById('t'); e.style.setProperty('color','red','important'); e.style.color",
            "red",
        ),
        (
            "var e=document.getElementById('t'); e.style.setProperty('color','red'); e.style.getPropertyPriority('color')",
            "",
        ),
        // `style.length`/`.item(index)`（丸ごと未対応だった。反復イディオム
        // `for (let i=0;i<style.length;i++) style.item(i)`。2026-07-17
        // 発見・実装）。
        (
            "var e=document.getElementById('t'); e.style.cssText='color: red; font-size: 12px'; e.style.length",
            "2",
        ),
        (
            "var e=document.getElementById('t'); e.style.cssText='color: red; font-size: 12px'; \
             e.style.item(0)+','+e.style.item(1)",
            "color,font-size",
        ),
        ("document.getElementById('t').style.length", "0"),
        // `style.cssFloat`（`float`プロパティのレガシー別名。丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        (
            "var e=document.getElementById('t'); e.style.cssFloat='left'; e.style.float",
            "left",
        ),
        (
            "var e=document.getElementById('t'); e.style.float='right'; e.style.cssFloat",
            "right",
        ),
        // `element.style.cssText`（全プロパティを1つの文字列で読み書きする定番パターン）が
        // 丸ごと未対応で、通常のプロパティ名として扱われ常に空文字列になっていた。
        (
            "var e=document.getElementById('t'); e.style.cssText='color: red; font-size: 12px'; e.style.color+','+e.style.fontSize",
            "red,12px",
        ),
        (
            "var e=document.getElementById('t'); e.style.color='blue'; e.style.fontSize='10px'; e.style.cssText",
            "color: blue; font-size: 10px",
        ),
        // innerHTML/outerHTML が丸ごと未対応（innerHTML は textContent と同じ実装を
        // 共有しておりマークアップ自体が失われていた）だったバグ。
        (
            "var e=document.getElementById('t'); e.innerHTML='<b>bold</b>text'; e.innerHTML",
            "<b>bold</b>text",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hi'; e.outerHTML",
            "<p id=\"t\" class=\"a b\" data-k=\"v\">hi</p>",
        ),
        // nodeType/nodeName がテキストノードでも常に ELEMENT_NODE(1)/空文字列固定
        // だったバグ。childNodes/firstChild/lastChild/nextSibling/previousSibling
        // （テキストノードも含む Node レベル走査 API）も丸ごと未対応だった。
        (
            "var e=document.getElementById('t'); e.innerHTML='a<b>x</b>'; e.childNodes.length+','+e.firstChild.nodeType+','+e.lastChild.nodeType",
            "2,3,1",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='a<b>x</b>'; e.firstChild.nextSibling.nodeName",
            "B",
        ),
        // `node.nodeValue`（テキストノードは自身のテキスト、要素ノードは仕様どおり
        // `null`）が丸ごと未対応だった。代入は要素ノードでは no-op。
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.nodeValue",
            "hello",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.nodeValue === null",
            "true",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.nodeValue='bye'; e.textContent",
            "bye",
        ),
        // `CharacterData.data`/`.length`/`.appendData`/`.deleteData`/
        // `.insertData`/`.replaceData`/`.substringData`（丸ごと未対応
        // だった。`nodeValue`は対応済みだったが単体アクセサ`data`と
        // 編集用メソッド群は漏れていた。2026-07-16 発見・実装）。
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.data",
            "hello",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.length",
            "5",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.data='world'; e.textContent",
            "world",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.appendData(' world'); e.textContent",
            "hello world",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; e.firstChild.deleteData(5,6); e.textContent",
            "hello",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.insertData(5,' world'); e.textContent",
            "hello world",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; e.firstChild.replaceData(6,5,'there'); e.textContent",
            "hello there",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; e.firstChild.substringData(6,5)",
            "world",
        ),
        // `deleteData`/`insertData`/`replaceData`/`substringData`/`splitText`は
        // 仕様上`offset`が`length`を超えると`IndexSizeError`を投げるべきだが、
        // 以前は`offset`を黙って`length`へクランプしてしまい、範囲外呼び出しが
        // 常に無害なno-op/末尾追記として成立していた（Table DOMの
        // `insertRow`等と同じ「範囲外インデックスの黙殺」バグ族）。
        (
            "var e=document.getElementById('t'); e.innerHTML='hi'; \
             try { e.firstChild.deleteData(99,1); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hi'; \
             try { e.firstChild.insertData(99,'x'); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hi'; \
             try { e.firstChild.replaceData(99,1,'x'); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hi'; \
             try { e.firstChild.substringData(99,1); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hi'; \
             try { e.firstChild.splitText(99); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            // offset===lengthはちょうど境界で範囲内（末尾扱い）なので例外にならない。
            "var e=document.getElementById('t'); e.innerHTML='hi'; \
             e.firstChild.insertData(2,'!'); e.textContent",
            "hi!",
        ),
        // `Text.splitText(offset)`（丸ごと未対応だった。2026-07-16 発見・
        // 実装。テキストノードを分割し、後半を新しい兄弟ノードとして
        // 挿入する）。
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; \
             var t1=e.firstChild; var t2=t1.splitText(5); t1.data+'|'+t2.data",
            "hello| world",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; \
             var t1=e.firstChild; t1.splitText(5); e.childNodes.length",
            "2",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; \
             var t1=e.firstChild; var t2=t1.splitText(5); t2.nextSibling===null && t2.previousSibling===t1",
            "true",
        ),
        // `Text.wholeText`（丸ごと未対応だった。`splitText`と対をなす読み
        // 取りプロパティ。2026-07-16 発見・実装。連続するテキストノード
        // 兄弟の`data`を全て連結して返す）。
        (
            "var e=document.getElementById('t'); e.innerHTML='hello world'; \
             var t1=e.firstChild; var t2=t1.splitText(5); t1.wholeText+'|'+t2.wholeText",
            "hello world|hello world",
        ),
        (
            "var e=document.getElementById('t'); e.innerHTML='hello'; e.firstChild.wholeText",
            "hello",
        ),
        // HTML5 Table DOM（`table.insertRow`/`.deleteRow`/`.rows`、
        // `tr.insertCell`/`.deleteCell`/`.cells`、`.rowIndex`/`.cellIndex`）が
        // 丸ごと未対応だった（2026-07-17 発見・実装）。
        (
            "var t=document.createElement('table'); \
             t.insertRow(); t.insertRow(); t.rows.length",
            "2",
        ),
        (
            "var t=document.createElement('table'); var r=t.insertRow(); r.insertCell(); r.insertCell(); \
             r.cells.length",
            "2",
        ),
        (
            "var t=document.createElement('table'); \
             var r0=t.insertRow(); var r1=t.insertRow(); var rmid=t.insertRow(1); \
             rmid===t.rows[1]",
            "true",
        ),
        (
            "var t=document.createElement('table'); t.insertRow(); t.insertRow(); t.deleteRow(0); \
             t.rows.length",
            "1",
        ),
        (
            "var t=document.createElement('table'); var r=t.insertRow(); \
             r.insertCell(); var mid=r.insertCell(); r.insertCell(); \
             mid===r.cells[1]",
            "true",
        ),
        (
            "var t=document.createElement('table'); var r=t.insertRow(); r.insertCell(); r.insertCell(); \
             r.deleteCell(0); r.cells.length",
            "1",
        ),
        (
            "var t=document.createElement('table'); t.insertRow(); var r=t.insertRow(); r.rowIndex",
            "1",
        ),
        (
            "var t=document.createElement('table'); var r=t.insertRow(); r.insertCell(); var c=r.insertCell(); c.cellIndex",
            "1",
        ),
        // `insertRow`/`deleteRow`/`insertCell`/`deleteCell`は仕様上、範囲外の
        // インデックス（`-1`未満、または`insertRow`/`insertCell`なら
        // `length`超過、`deleteRow`/`deleteCell`なら`length`以上）で
        // `IndexSizeError`を投げるべきだが、以前は範囲外の値をすべて
        // 「末尾へ追加」/「末尾を削除」として黙って受け入れてしまっていた。
        (
            "var t=document.createElement('table'); t.insertRow(); \
             try { t.insertRow(5); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var t=document.createElement('table'); t.insertRow(); \
             try { t.deleteRow(5); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var t=document.createElement('table'); var r=t.insertRow(); r.insertCell(); \
             try { r.insertCell(5); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            "var t=document.createElement('table'); var r=t.insertRow(); r.insertCell(); \
             try { r.deleteCell(5); 'no-throw' } catch(e) { e.name }",
            "IndexSizeError",
        ),
        (
            // `insertRow(length)`（末尾追加）と`insertRow(-1)`（同じく末尾追加）は
            // 範囲内なので従来どおり例外にならない。
            "var t=document.createElement('table'); t.insertRow(); \
             t.insertRow(1); t.insertRow(-1); t.rows.length",
            "3",
        ),
        // `tr.sectionRowIndex`（丸ごと未対応だった。`rowIndex`は実装済み
        // なのに対になるこちらだけ抜けていた兄弟ギャップ。2026-07-17
        // 発見・実装）。`thead`2行+`tbody`3行の表で、`tbody`側2行目
        // （テーブル全体では4番目=`rowIndex:3`）の`sectionRowIndex`は
        // `tbody`内での位置`1`（0始まり）になる。
        (
            "var t=document.createElement('table'); \
             var h=t.createTHead(); h.insertRow(); h.insertRow(); \
             var b=document.createElement('tbody'); t.appendChild(b); \
             b.insertRow(); var r=b.insertRow(); b.insertRow(); \
             r.rowIndex + ',' + r.sectionRowIndex",
            "3,1",
        ),
        // `HTMLTableSectionElement.insertRow`/`.rows`（丸ごと未対応だった。
        // `table.insertRow`は実装済みなのに対になるこちらだけ抜けていた
        // 兄弟ギャップ。`tbody`自身が持つ`insertRow`/`.rows`はそのセクション
        // 内に限定される。2026-07-17 発見・実装）。
        (
            "var t=document.createElement('table'); var b=document.createElement('tbody'); \
             t.appendChild(b); b.insertRow(); b.insertRow(); b.rows.length",
            "2",
        ),
        // `thead`/`tbody`ラッパー無しで直接`table`に`insertRow`した場合は
        // `rowIndex`と`sectionRowIndex`が一致する。
        (
            "var t=document.createElement('table'); t.insertRow(); var r=t.insertRow(); \
             r.rowIndex + ',' + r.sectionRowIndex",
            "1,1",
        ),
        // `table.tHead`/`.tFoot`/`.caption`/`.tBodies`/`.createTHead()`/
        // `.createTFoot()`/`.createCaption()`/`.delete*()`（丸ごと未対応
        // だった。2026-07-17 発見・実装。「既存要素があれば返す、無ければ
        // 新規作成」の冪等な動作）。
        ("document.createElement('table').tHead", "null"),
        (
            "var t=document.createElement('table'); var h=t.createTHead(); h===t.tHead && h.tagName",
            "THEAD",
        ),
        (
            "var t=document.createElement('table'); var h1=t.createTHead(); var h2=t.createTHead(); h1===h2",
            "true",
        ),
        (
            "var t=document.createElement('table'); t.createTHead(); t.deleteTHead(); t.tHead",
            "null",
        ),
        (
            "var t=document.createElement('table'); var f=t.createTFoot(); f===t.tFoot && f.tagName",
            "TFOOT",
        ),
        (
            "var t=document.createElement('table'); var c=t.createCaption(); c===t.caption && c.tagName",
            "CAPTION",
        ),
        (
            "var t=document.createElement('table'); t.appendChild(document.createElement('tbody')); \
             t.appendChild(document.createElement('tbody')); t.tBodies.length",
            "2",
        ),
        // `node.isConnected`（click-outside 判定等で使われる）が丸ごと未対応だった。
        (
            "document.createElement('div').isConnected",
            "false",
        ),
        (
            "document.getElementById('t').isConnected",
            "true",
        ),
        (
            "var e=document.getElementById('t'); e.remove(); e.isConnected",
            "false",
        ),
        // `Node.ELEMENT_NODE`/`Node.TEXT_NODE`（`if (node.nodeType === Node.
        // ELEMENT_NODE)` という定番パターンで使われる標準定数）が丸ごと未対応
        // だった（グローバル `Node` 自体が存在しなかった）。
        (
            "document.createElement('div').nodeType === Node.ELEMENT_NODE",
            "true",
        ),
        ("Node.TEXT_NODE", "3"),
        ("Node.COMMENT_NODE", "8"),
        ("var c=document.createComment('test'); c.nodeType", "8"),
        ("var c=document.createComment('test'); c.nodeName", "#comment"),
        ("var c=document.createComment('test'); c.nodeValue", "test"),
        ("var c=document.createComment('test'); c.data", "test"),
        ("var c=document.createComment('test'); c.length", "4"),
        ("var c=document.createComment('test'); c.nodeValue='new'; c.nodeValue", "new"),
        ("var c=document.createComment('test'); c.data='new'; c.data", "new"),
        ("var c=document.createComment('test'); c.textContent", "test"),
        ("var c=document.createComment('test'); c.textContent='new'; c.textContent", "new"),
        (
            "var d=document.createElement('div'); var c=document.createComment('foo'); d.appendChild(c); d.innerHTML",
            "<!--foo-->",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.cssRules.length",
            "1",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.cssRules[0].cssText",
            "div { color: red; }",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.cssRules[0].selectorText",
            "div",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.insertRule('span { color: blue; }', 1); sheet.cssRules.length",
            "2",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.insertRule('span { color: blue; }', 1); sheet.cssRules[1].cssText",
            "span { color: blue; }",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.insertRule('span { color: blue; }', 1); sheet.deleteRule(0); sheet.cssRules.length",
            "1",
        ),
        (
            "var t=document.getElementById('t'); var s=document.createElement('style'); s.textContent='div { color: red; }'; t.appendChild(s); var sheet=document.styleSheets[0]; sheet.insertRule('span { color: blue; }', 1); sheet.deleteRule(0); sheet.cssRules[0].cssText",
            "span { color: blue; }",
        ),
        // `document.title` が常に install 時の空文字列固定で `<title>` 要素の中身/
        // 代入結果と一切連動していなかったバグ。ここでは `<head>` 自体が無い状態
        // （フレッシュな JsRuntime）での内部プロパティへのフォールバック保存/読み出し
        // を確認する（`<head>`/`<title>` 実要素との連動は別ブロックで確認）。
        ("document.title = 'Hello'; document.title", "Hello"),
        // `element.lang`/`.dir`（グローバル属性の JS プロパティ版）が他の属性直結
        // プロパティ群の点検から漏れて丸ごと未対応だった。
        (
            "var e=document.createElement('p'); e.lang='ja'; e.lang",
            "ja",
        ),
        (
            "var e=document.createElement('p'); e.dir='rtl'; e.dir",
            "rtl",
        ),
        (
            "var e=document.createElement('p'); e.setAttribute('lang','fr'); e.lang",
            "fr",
        ),
        // `element.title`/`.accessKey`/`.translate`（同じ理由で丸ごと未対応
        // だった。未マッチキーは巨大 match の末尾 `_ => Value::Undefined`
        // に落ちるだけで汎用フォールバックが無いため常に `undefined` に
        // なっていた。2026-07-16 発見・実装）。
        (
            "var e=document.createElement('p'); e.title='tip'; e.title",
            "tip",
        ),
        (
            "var e=document.createElement('p'); e.setAttribute('title','x'); e.title",
            "x",
        ),
        (
            "var e=document.createElement('p'); e.accessKey='k'; e.getAttribute('accesskey')",
            "k",
        ),
        // `translate` は既定 `true`、`translate=\"no\"` の時のみ `false`。
        ("document.createElement('p').translate", "true"),
        (
            "var e=document.createElement('p'); e.setAttribute('translate','no'); e.translate",
            "false",
        ),
        (
            "var e=document.createElement('p'); e.translate=false; e.getAttribute('translate')",
            "no",
        ),
        // `element.draggable`（丸ごと未対応だった。2026-07-16 発見・実装。
        // 明示指定が無ければ既定 `false` の簡略実装）。
        ("document.createElement('div').draggable", "false"),
        (
            "var e=document.createElement('div'); e.draggable=true; e.getAttribute('draggable')",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.setAttribute('draggable','true'); e.draggable",
            "true",
        ),
        // `element.slot`（named slot 割り当て名。丸ごと未対応だった。
        // 2026-07-16 発見・実装）。
        (
            "var e=document.createElement('div'); e.slot='header'; e.getAttribute('slot')",
            "header",
        ),
        // DOM コンストラクタ階層 (Node -> Element -> HTMLElement -> HTMLXxxElement)
        // および `instanceof` / `.constructor` 連携の自己テスト
        (
            "document.createElement('div') instanceof HTMLDivElement",
            "true",
        ),
        (
            "document.createElement('div') instanceof HTMLElement",
            "true",
        ),
        (
            "document.createElement('div') instanceof Element",
            "true",
        ),
        (
            "document.createElement('div') instanceof Node",
            "true",
        ),
        (
            "document.createElement('div') instanceof HTMLInputElement",
            "false",
        ),
        (
            "document.createElement('input') instanceof HTMLInputElement",
            "true",
        ),
        (
            "document.createElement('input') instanceof HTMLElement",
            "true",
        ),
        (
            "document.createElement('form') instanceof HTMLFormElement",
            "true",
        ),
        (
            "document.createElement('div').constructor === HTMLDivElement",
            "true",
        ),
        (
            "try { new Node(); false; } catch(e) { e instanceof TypeError }",
            "true",
        ),
        (
            "try { new HTMLElement(); false; } catch(e) { e instanceof TypeError }",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.setAttribute('slot','footer'); e.slot",
            "footer",
        ),
        // `element.tabIndex`（`tabindex` 属性の数値プロパティ版）も同じ理由で
        // 丸ごと未対応だった。未指定時の既定値は `-1`。
        (
            "document.createElement('div').tabIndex",
            "-1",
        ),
        (
            "var e=document.createElement('div'); e.tabIndex=3; e.tabIndex",
            "3",
        ),
        (
            "var e=document.createElement('div'); e.tabIndex=2; e.getAttribute('tabindex')",
            "2",
        ),
        // `element.hidden = true/false`（要素の表示/非表示切替の定番イディオム）の
        // setter が丸ごと未対応だった（getter は既に対応済み）。
        (
            "var e=document.createElement('div'); e.hidden=true; e.hidden",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.hidden=true; e.hasAttribute('hidden')",
            "true",
        ),
        (
            "var e=document.createElement('div'); e.hidden=true; e.hidden=false; e.hidden",
            "false",
        ),
        // `form.noValidate`（`novalidate` 属性の camelCase プロパティ版）が丸ごと
        // 未対応だった。
        (
            "var f=document.createElement('form'); f.noValidate=true; f.noValidate",
            "true",
        ),
        (
            "var f=document.createElement('form'); f.noValidate=true; f.hasAttribute('novalidate')",
            "true",
        ),
        (
            "document.createElement('form').noValidate",
            "false",
        ),
        // `form.elements`（全フォームコントロールを走査する定番イディオム）が丸ごと
        // 未対応だった。
        (
            "var f=document.createElement('form'); var i=document.createElement('input'); f.appendChild(i); f.elements.length",
            "1",
        ),
        (
            "var f=document.createElement('form'); var i=document.createElement('input'); i.name='x'; f.appendChild(i); f.elements[0].name",
            "x",
        ),
        // `form.length`（`form.elements.length`と同じ値を返すIDL属性の数値
        // ショートハンド。`select.length`の対になる`<form>`側だが丸ごと
        // 未対応だった）。
        (
            "var f=document.createElement('form'); var i=document.createElement('input'); \
             var s=document.createElement('select'); f.appendChild(i); f.appendChild(s); \
             f.length + ',' + f.elements.length",
            "2,2",
        ),
        (
            "document.createElement('form').length",
            "0",
        ),
        // `fieldset.elements`（`HTMLFieldSetElement`のIDLプロパティ。丸ごと
        // 未対応だった。`form.elements`と異なり純粋なDOM子孫のみが対象。
        // 2026-07-17 発見・実装）。
        (
            "var fs=document.createElement('fieldset'); var i=document.createElement('input'); \
             fs.appendChild(i); fs.elements.length",
            "1",
        ),
        (
            "document.createElement('fieldset').elements.length",
            "0",
        ),
        // `fieldset.type`（仕様上、属性値に関わらず常に固定文字列
        // `"fieldset"`を返す読み取り専用IDLプロパティ。丸ごと未対応
        // だった。2026-07-17 発見・実装）。
        ("document.createElement('fieldset').type", "fieldset"),
        (
            "var fs=document.createElement('fieldset'); fs.setAttribute('type','x'); fs.type",
            "fieldset",
        ),
        // `select.type`（仕様上、`multiple`属性の有無で`"select-multiple"`/
        // `"select-one"`のいずれか固定文字列を返す読み取り専用IDL
        // プロパティ。`fieldset.type`と同じ理由で丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        ("document.createElement('select').type", "select-one"),
        (
            "var s=document.createElement('select'); s.multiple=true; s.type",
            "select-multiple",
        ),
        // `button.type`（`type`属性が無いか不正な値なら既定`"submit"`に
        // フォールバックする。`fieldset.type`/`select.type`と同じ理由で
        // 丸ごと未対応だった。`if (btn.type === 'submit')`という定番
        // チェックが常に偽になる実害があった。2026-07-17 発見・実装）。
        ("document.createElement('button').type", "submit"),
        // `textarea.type`（仕様上、属性値に関わらず常に固定文字列
        // `"textarea"`を返す読み取り専用IDLプロパティ。`fieldset.type`と
        // 同じ理由で丸ごと未対応だった。2026-07-17 発見・実装）。
        ("document.createElement('textarea').type", "textarea"),
        (
            "var b=document.createElement('button'); b.setAttribute('type','reset'); b.type",
            "reset",
        ),
        (
            "var b=document.createElement('button'); b.setAttribute('type','button'); b.type",
            "button",
        ),
        (
            "var b=document.createElement('button'); b.setAttribute('type','bogus'); b.type",
            "submit",
        ),
        // `input.type`（`type`属性が無いか既知の列挙値以外なら既定
        // `"text"`にフォールバックする。`fieldset.type`/`select.type`/
        // `button.type`と同じ理由で丸ごと未対応だった。全入力系IDL
        // プロパティの中で最も広く参照される`.type`が常に空文字列に
        // なっていた実害の大きいバグ。2026-07-17 発見・実装）。
        ("document.createElement('input').type", "text"),
        (
            "var i=document.createElement('input'); i.setAttribute('type','checkbox'); i.type",
            "checkbox",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('type','DATE'); i.type",
            "date",
        ),
        (
            "var i=document.createElement('input'); i.setAttribute('type','bogus'); i.type",
            "text",
        ),
        // `form.elements`が`form="formId"`属性によるフォーム外関連付け
        // （HTML5仕様の「form owner」）を反映していなかった兄弟ギャップの
        // 自己テストは、この配列が`(&str, &str)`（HTML fixtureを持たない）
        // 型のため3要素タプルでは追加できない。別途、独自のHTML fixtureを
        // 持つ`fd2_cases`（本ファイル内。`FormData`のform owner対応テストと
        // 同じfixtureを再利用）に追加してある。
        // `input.form`（自身が属する `<form>` への逆参照）が丸ごと未対応だった。
        (
            "var f=document.createElement('form'); f.id='ff'; var i=document.createElement('input'); f.appendChild(i); i.form.id",
            "ff",
        ),
        (
            "document.createElement('input').form === null",
            "true",
        ),
        // `input.labels`（`for` 属性の明示的な関連付けと、`<label>` 子孫の暗黙の
        // 関連付けの両方）が丸ごと未対応だった。
        (
            "var i=document.createElement('input'); i.id='u'; var l=document.createElement('label'); l.setAttribute('for','u'); i.labels.length",
            "1",
        ),
        (
            "var l=document.createElement('label'); var i=document.createElement('input'); l.appendChild(i); i.labels.length",
            "1",
        ),
        (
            "document.createElement('input').labels.length",
            "0",
        ),
        // `label.control`（`labels` の逆方向）が丸ごと未対応だった。
        (
            "var i=document.createElement('input'); i.id='v'; var l=document.createElement('label'); l.setAttribute('for','v'); l.control.id",
            "v",
        ),
        (
            "var l=document.createElement('label'); var i=document.createElement('input'); i.name='y'; l.appendChild(i); l.control.name",
            "y",
        ),
        (
            "document.createElement('label').control === null",
            "true",
        ),
        // `node.contains(other)`（click-outside 判定等で広く使われる）が丸ごと
        // 未対応だった。
        (
            "var w=document.getElementById('wrap'); var t=document.getElementById('t'); w.contains(t)+','+t.contains(w)+','+t.contains(t)",
            "true,false,true",
        ),
        // `Node.compareDocumentPosition(other)` が丸ごと未対応だった（`contains()` はあったが
        // 兄弟同士の前後関係や祖先/子孫の判定を1回のビットマスクで得る標準APIが欠落）。
        (
            "var t=document.getElementById('t'); t.compareDocumentPosition(t)",
            "0",
        ),
        (
            "var w=document.getElementById('wrap'); var t=document.getElementById('t'); t.compareDocumentPosition(w)",
            "10",
        ),
        (
            "var w=document.getElementById('wrap'); var t=document.getElementById('t'); w.compareDocumentPosition(t)",
            "20",
        ),
        (
            "var t=document.getElementById('t'); var s=document.getElementById('s'); t.compareDocumentPosition(s)",
            "4",
        ),
        (
            "var t=document.getElementById('t'); var s=document.getElementById('s'); s.compareDocumentPosition(t)",
            "2",
        ),
        // `element.click()` が単なる no-op で、実際のクリック（登録済みリスナの発火）を
        // 一切引き起こさなかったバグ（プログラム的クリックはテストコードで広く使われる
        // 定番パターン）。
        (
            "var e=document.getElementById('t'); var clicked=false; e.addEventListener('click', function(){ clicked=true; }); e.click(); clicked",
            "true",
        ),
        // `document.scrollingElement`（HTML5。丸ごと未対応だった。標準準拠
        // モードでは `documentElement`（`<html>`）と同じ要素を返す仕様）。
        ("document.scrollingElement.tagName", "HTML"),
        ("document.scrollingElement === document.documentElement", "true"),
        // `document.activeElement`/`element.focus()`/`.blur()`（HTML5。丸ごと
        // 未対応だった。以前は `activeElement` が常に `null` 固定、
        // `.focus()`/`.blur()` 自体が丸ごと存在しなかった）。
        (
            "document.getElementById('t').focus(); document.activeElement.id",
            "t",
        ),
        (
            "document.getElementById('t').focus(); document.getElementById('t') === document.activeElement",
            "true",
        ),
        (
            "document.getElementById('t').focus(); document.getElementById('s').focus(); document.activeElement.id",
            "s",
        ),
        (
            "document.getElementById('t').focus(); document.getElementById('t').blur(); \
             document.getElementById('t') === document.activeElement",
            "false",
        ),
        (
            "var log=''; document.getElementById('t').addEventListener('focus', ()=>log+='f'); \
             document.getElementById('t').addEventListener('blur', ()=>log+='b'); \
             document.getElementById('t').focus(); document.getElementById('s').focus(); log",
            "fb",
        ),
        (
            "var n=0; document.getElementById('t').addEventListener('focus', ()=>n++); \
             document.getElementById('t').focus(); document.getElementById('t').focus(); n",
            "1",
        ),
    ];
    total += dom2_cases.len();
    for (src, expect) in dom2_cases {
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(dom2_html));
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
        }
    }
    // ===== DOM イベントシステム（Phase 3+）=====
    // addEventListener / removeEventListener / dispatchEvent と Event オブジェクトの
    // 伝播（capture→target→bubble）、preventDefault / stopPropagation /
    // stopImmediatePropagation / once / target・currentTarget を JS 層から検証する。
    // dispatchEvent はホストの dispatch_key/dispatch_mouse と同じ dispatch_event_in_interp を
    // 通るため、ここで伝播ロジック全体を決定論的にカバーできる。
    let ev_html = "<div id='outer'><div id='mid'><button id='btn'>go</button></div></div>";
    let event_cases: &[(&str, &str)] = &[
        // 基本: addEventListener したリスナが dispatchEvent で発火する。
        ("var n=0; var b=document.getElementById('btn'); b.addEventListener('click', function(){ n++; }); b.dispatchEvent({type:'click'}); n", "1"),
        // 同一要素に複数リスナ → 登録順に全て発火。
        ("var s=''; var b=document.getElementById('btn'); b.addEventListener('click', ()=>s+='a'); b.addEventListener('click', ()=>s+='b'); b.dispatchEvent({type:'click'}); s", "ab"),
        // removeEventListener で解除したリスナは発火しない。
        ("var n=0; var f=()=>n++; var b=document.getElementById('btn'); b.addEventListener('click', f); b.removeEventListener('click', f); b.dispatchEvent({type:'click'}); n", "0"),
        // バブリング: button で発火 → 祖先 mid / outer の click リスナも発火。
        ("var s=''; document.getElementById('outer').addEventListener('click', ()=>s+='O'); document.getElementById('mid').addEventListener('click', ()=>s+='M'); document.getElementById('btn').addEventListener('click', ()=>s+='B'); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "BMO"),
        // event.target は発火元、currentTarget は処理中の要素（バブリング中は祖先）。
        ("var t=''; document.getElementById('outer').addEventListener('click', function(e){ t = e.target.id + '/' + e.currentTarget.id; }); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); t", "btn/outer"),
        // stopPropagation: button のリスナで止めると祖先には伝わらない。
        ("var s=''; document.getElementById('outer').addEventListener('click', ()=>s+='O'); document.getElementById('btn').addEventListener('click', function(e){ s+='B'; e.stopPropagation(); }); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "B"),
        // stopImmediatePropagation: 同一要素の後続リスナも止める。
        ("var s=''; var b=document.getElementById('btn'); b.addEventListener('click', function(e){ s+='1'; e.stopImmediatePropagation(); }); b.addEventListener('click', ()=>s+='2'); b.dispatchEvent({type:'click'}); s", "1"),
        // preventDefault → dispatchEvent は false を返す（defaultPrevented）。
        ("var b=document.getElementById('btn'); b.addEventListener('click', e=>e.preventDefault()); b.dispatchEvent({type:'click'})", "false"),
        // preventDefault しなければ dispatchEvent は true を返す。
        ("var b=document.getElementById('btn'); b.addEventListener('click', ()=>{}); b.dispatchEvent({type:'click'})", "true"),
        // e.defaultPrevented フラグが preventDefault 後に true。
        ("var d=false; var b=document.getElementById('btn'); b.addEventListener('click', function(e){ e.preventDefault(); d=e.defaultPrevented; }); b.dispatchEvent({type:'click'}); d", "true"),
        // once: true のリスナは 1 回だけ発火し、2 回目は無視される。
        ("var n=0; var b=document.getElementById('btn'); b.addEventListener('click', ()=>n++, {once:true}); b.dispatchEvent({type:'click'}); b.dispatchEvent({type:'click'}); n", "1"),
        // capture フェーズ: 祖先の capture リスナは target より先に発火。
        ("var s=''; document.getElementById('outer').addEventListener('click', ()=>s+='C', true); document.getElementById('btn').addEventListener('click', ()=>s+='T'); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "CT"),
        // event.type が正しく渡る。
        ("var ty=''; var b=document.getElementById('btn'); b.addEventListener('custom', function(e){ ty=e.type; }); b.dispatchEvent({type:'custom'}); ty", "custom"),
        // カスタムプロパティ（detail 等）がリスナ側へ転送される。
        ("var d=0; var b=document.getElementById('btn'); b.addEventListener('ping', function(e){ d=e.detail; }); b.dispatchEvent({type:'ping', detail:7}); d", "7"),
        // 異なるイベント型のリスナは発火しない。
        ("var n=0; var b=document.getElementById('btn'); b.addEventListener('mouseover', ()=>n++); b.dispatchEvent({type:'click'}); n", "0"),
        // バブリングフラグ未指定でも、本エンジンは委譲（イベント委譲）を成立させるため
        // 祖先のリスナも発火する設計（blur/focus を親で受ける UI を許容）。
        ("var s=''; document.getElementById('outer').addEventListener('foo', ()=>s+='O'); document.getElementById('btn').addEventListener('foo', ()=>s+='B'); document.getElementById('btn').dispatchEvent({type:'foo'}); s", "BO"),
        // `document.addEventListener('click', fn)` によるイベント委譲パターンが
        // 丸ごと未対応だった（`document` は `self.dom.nodes` の一員ではないため
        // 祖先チェーンに一切含まれず、`click`等の汎用種別は登録すら黙って
        // 捨てられていた。2026-07-16 発見・実装）。要素からバブリングした
        // クリックが `document` レベルのリスナまで届くことを確認。
        ("var s=''; document.addEventListener('click', ()=>s+='D'); document.getElementById('btn').addEventListener('click', ()=>s+='B'); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "BD"),
        // `stopPropagation()` すれば document レベルへは届かない。
        ("var s=''; document.addEventListener('click', ()=>s+='D'); document.getElementById('btn').addEventListener('click', function(e){ s+='B'; e.stopPropagation(); }); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "B"),
        // document.removeEventListener('click', fn) で解除できる。
        ("var n=0; var f=()=>n++; document.addEventListener('click', f); document.removeEventListener('click', f); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); n", "0"),
        // document 側でも e.target は発火元要素、currentTarget は document 自身。
        ("var r=''; document.addEventListener('click', function(e){ r = e.target.id + '/' + (e.currentTarget === document); }); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); r", "btn/true"),
        // `document.dispatchEvent(new Event('click'))` で document 自身から直接
        // 合成発火することもできる（実DOM要素を経由しない経路）。
        ("var n=0; document.addEventListener('click', ()=>n++); document.dispatchEvent(new Event('click')); n", "1"),
        // `document.addEventListener(type, fn, {capture:true})` がキャプチャ
        // フェーズを一切扱えないバグ（丸ごと未対応だった。`document` の汎用
        // リスナは `event_target_add_event_listener` を再利用しており、
        // `capture` オプションは元々「DOM ツリーを持たないクラスでは無意味」
        // として即座に破棄されていた。`document` に対して再利用したことで
        // 意味が変わり、キャプチャ登録が黙ってバブル扱いになっていた。
        // 2026-07-16 発見・実装）。document の capture リスナは祖先の
        // capture リスナより先（最も外側）に発火する。
        ("var s=''; document.addEventListener('click', ()=>s+='D', true); document.getElementById('outer').addEventListener('click', ()=>s+='O', true); document.getElementById('btn').addEventListener('click', ()=>s+='B'); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "DOB"),
        // capture 登録は bubble フェーズでは発火しない（両方登録すれば両方発火）。
        ("var s=''; document.addEventListener('click', ()=>s+='C', true); document.addEventListener('click', ()=>s+='B'); document.getElementById('btn').dispatchEvent({type:'click', bubbles:true}); s", "CB"),
    ];
    total += event_cases.len();
    for (src, expect) in event_cases {
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(ev_html));
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
        }
    }

    // FormData(form): <form> 配下のコントロールから値を収集（DOM 必須）。
    {
        let fd_html = "<form id='f'>\
            <input name='user' value='alice'>\
            <input name='nope'>\
            <input type='checkbox' name='agree' value='yes' checked>\
            <input type='checkbox' name='news' value='1'>\
            <input type='radio' name='plan' value='free'>\
            <input type='radio' name='plan' value='pro' checked>\
            <input type='submit' name='btn' value='go'>\
            <select name='color' value='green'><option value='red'>R</option><option value='green'>G</option></select>\
            <textarea name='bio'>hello</textarea>\
        </form>";
        let fd_cases: &[(&str, &str)] = &[
            // user=alice, agree=yes(checked), plan=pro(checked radio), color=green, bio=hello。
            // nope は name はあるが value 空 → 空値で含まれる。news/free は未チェックで除外。submit は除外。
            (
                "new FormData(document.getElementById('f')).get('user')",
                "alice",
            ),
            (
                "new FormData(document.getElementById('f')).get('agree')",
                "yes",
            ),
            (
                "new FormData(document.getElementById('f')).get('plan')",
                "pro",
            ),
            (
                "var f=new FormData(document.getElementById('f')); f.has('news')+','+f.has('btn')",
                "false,false",
            ),
        ];
        total += fd_cases.len();
        for (src, expect) in fd_cases {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(fd_html));
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }
    {
        // `collect_form_data`（FormData収集の実体）が`form="formId"`属性による
        // フォーム外関連付け（HTML5仕様の「form owner」。`element.form`/
        // `checkValidity()`は既に対応済み）を反映していなかった兄弟ギャップ。
        // 併せて`<fieldset disabled>`祖先による暗黙の無効化（`is_disabled`）も
        // 送信データ収集側では未反映だったため同時に修正した。
        let fd2_html = "<form id='f6'>\
            <input name='inside' value='a'>\
            <fieldset disabled><input name='hidden_by_fieldset' value='b'></fieldset>\
        </form>\
        <input name='outside' form='f6' value='c'>\
        <input name='not_associated' value='d'>";
        let fd2_cases: &[(&str, &str)] = &[
            (
                "new FormData(document.getElementById('f6')).get('inside')",
                "a",
            ),
            (
                "new FormData(document.getElementById('f6')).get('outside')",
                "c",
            ),
            (
                "var f=new FormData(document.getElementById('f6')); f.has('hidden_by_fieldset')",
                "false",
            ),
            (
                "var f=new FormData(document.getElementById('f6')); f.has('not_associated')",
                "false",
            ),
            // `form.elements`も同じ`form_associated_controls`を再利用するため、
            // フォーム外の`outside`（`form='f6'`）を含む3件（inside/
            // hidden_by_fieldset/outside。`not_associated`は含まれない）になる。
            (
                "document.getElementById('f6').elements.length",
                "3",
            ),
        ];
        total += fd2_cases.len();
        for (src, expect) in fd2_cases {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(fd2_html));
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }
    // `<select multiple>` — 選択された option 1つにつき1エントリを送信する仕様が
    // FormData 収集で丸ごと未対応だったバグ（複数選択リストボックスという定番 UI
    // パターン）。`selectedOptions`（丸ごと未対応だった）も合わせて確認する。
    {
        let sm_html = "<form id='f2'>\
            <select name='tags' multiple>\
                <option value='a' selected>A</option>\
                <option value='b'>B</option>\
                <option value='c' selected>C</option>\
            </select>\
        </form>";
        let sm_cases: &[(&str, &str)] = &[
            (
                "new FormData(document.getElementById('f2')).getAll('tags').join(',')",
                "a,c",
            ),
            (
                "document.querySelector('select').selectedOptions.length",
                "2",
            ),
            (
                "Array.from(document.querySelector('select').selectedOptions).map(o => o.value).join(',')",
                "a,c",
            ),
            // `select.options`（動的にドロップダウンを構築する定番イディオム）が
            // 丸ごと未対応だった。
            (
                "document.querySelector('select').options.length",
                "3",
            ),
            (
                "Array.from(document.querySelector('select').options).map(o => o.value).join(',')",
                "a,b,c",
            ),
            // `select.options.add`/`.remove`/`.namedItem`（`HTMLOptionsCollection`。
            // 丸ごと未対応だった）。
            (
                "var s=document.querySelector('select'); \
                 var o=new Option('D','d'); o.id='optd'; s.options.add(o); \
                 s.options.length + ':' + s.options[3].value",
                "4:d",
            ),
            (
                "var s=document.querySelector('select'); s.options.remove(1); \
                 Array.from(s.options).map(o => o.value).join(',')",
                "a,c",
            ),
            (
                "document.querySelector('select').options.namedItem('nope')",
                "null",
            ),
            (
                "var s=document.querySelector('select'); s.options.item(0).value",
                "a",
            ),
            (
                "var s=document.querySelector('select'); s.options.selectedIndex=1; s.selectedIndex",
                "1",
            ),
            (
                "var s=document.querySelector('select'); s.selectedIndex=2; s.options.selectedIndex",
                "2",
            ),
        ];
        total += sm_cases.len();
        for (src, expect) in sm_cases {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(sm_html));
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }
    // `<select>`配下`<optgroup>`でグループ化された`<option>`が丸ごと見えなく
    // なっていたバグ（`select.options`/`selectedOptions`/フォーム送信の
    // どちらも直接の子要素しか見ておらず、`<optgroup>`という非常によく
    // 使われるカテゴリ分けパターンを完全に見落としていた。2026-07-17
    // 発見・実装）。
    // 【2026-07-24】以前`optgroup_total`が固定値`5`だったが、実際の`og_cases`
    // 配列は4件しか無く、`total`側だけ1件多く数える「集計ずれ」の一例だった
    // （`pass == total`の一言判定のみでは個別FAIL行が一切出ないままカテゴリ
    // 丸ごとFAILになり原因不明だった）。`.len()`から動的に求めることで
    // 今後同じズレが再発しないようにする。
    let og_html = "<form id='f3'><select name='fruit'><optgroup label='Citrus'><option value='lemon'>Lemon</option><option value='lime' selected>Lime</option></optgroup><optgroup label='Berries'><option value='straw'>Strawberry</option></optgroup></select></form>";
    let og_cases: &[(&str, &str)] = &[
        (
            "document.querySelector('select').options.length",
            "3",
        ),
        (
            "Array.from(document.querySelector('select').options).map(o => o.value).join(',')",
            "lemon,lime,straw",
        ),
        (
            "document.querySelector('select').selectedOptions.length",
            "1",
        ),
        (
            "document.querySelector('select').value",
            "lime",
        ),
    ];
    total += og_cases.len();
    {
        for (src, expect) in og_cases {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(og_html));
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }
    // `document.title` が実際の `<head><title>` 要素と連動すること（既存 `<title>` の
    // 更新、無い場合は `<head>` へ新規作成）を、実 DOM 構造を持つフィクスチャで確認する。
    {
        let title_cases: &[(&str, &str, &str)] = &[
            // 既存の <title> があれば、その中身が更新される。
            (
                "<html><head><title>old</title></head><body></body></html>",
                "document.title",
                "old",
            ),
            (
                "<html><head><title>old</title></head><body></body></html>",
                "document.title='new'; document.querySelector('title').textContent",
                "new",
            ),
            // <head> はあるが <title> が無い場合、新規作成されて連動する。
            (
                "<html><head></head><body></body></html>",
                "document.title='created'; document.querySelector('title').textContent",
                "created",
            ),
        ];
        total += title_cases.len();
        for (html, src, expect) in title_cases {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(html));
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }
    // `document.forms`/`.images`/`.scripts`（文書全体をタグ横断で集約する定番の
    // HTMLCollection 群）が丸ごと未対応だった。
    {
        let coll_html = "<html><body>\
            <form id='f1'></form><form id='f2'></form>\
            <img src='a.png'><img src='b.png'><img src='c.png'>\
            <script>1</script>\
            <a href='x.html'>x</a><a name='top'>anchor</a>\
            <area href='y.html' alt='y'>\
            <embed src='z.swf'>\
        </body></html>";
        let coll_cases: &[(&str, &str)] = &[
            ("document.forms.length", "2"),
            ("document.images.length", "3"),
            ("document.scripts.length", "1"),
            // `document.links`（href 付きの a/area のみ。`name` のみの a は含まない）が
            // 丸ごと未対応だった。
            ("document.links.length", "2"),
            // `document.anchors`（`name` 属性付きの a のみ）も丸ごと未対応だった。
            ("document.anchors.length", "1"),
            // `document.embeds`/`.plugins`（仕様上同じ集合を指すエイリアス）/
            // `document.applets`（Java アプレット廃止に伴い常に空固定のレガシー
            // スタブ）が丸ごと未対応だった。2026-07-16 発見・実装。
            ("document.embeds.length", "1"),
            ("document.plugins.length", "1"),
            ("document.applets.length", "0"),
        ];
        total += coll_cases.len();
        for (src, expect) in coll_cases {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(coll_html));
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }
    // getBoundingClientRect / offset* （レンダラが set_rect で注入する矩形を JS から読む）。
    {
        let rect_checks: &[(&str, &str)] = &[
            (
                "document.getElementById('t').getBoundingClientRect().width",
                "30",
            ),
            (
                "document.getElementById('t').getBoundingClientRect().height",
                "40",
            ),
            (
                "document.getElementById('t').getBoundingClientRect().left",
                "10",
            ),
            (
                "document.getElementById('t').getBoundingClientRect().bottom",
                "60",
            ),
            ("document.getElementById('t').offsetWidth", "30"),
            ("document.getElementById('t').offsetTop", "20"),
            // clientWidth = 30 (width) - 5 (left border) - 3 (right border) = 22
            ("document.getElementById('t').clientWidth", "22"),
            // clientHeight = 40 (height) - 2 (top border) - 4 (bottom border) = 34
            ("document.getElementById('t').clientHeight", "34"),
            // clientLeft = 5 (left border)
            ("document.getElementById('t').clientLeft", "5"),
            // clientTop = 2 (top border)
            ("document.getElementById('t').clientTop", "2"),
            // `element.getClientRects()`（丸ごと未対応だった。テキスト行フラグメント
            // モデルが無いこの処理系では要素1つにつき `getBoundingClientRect()` と
            // 同じ矩形を1個だけ持つ配列として返す簡略実装）。
            ("document.getElementById('t').getClientRects().length", "1"),
            (
                "document.getElementById('t').getClientRects()[0].width",
                "30",
            ),
            // rect が未登録（レンダラ未描画）の要素は仕様どおり空配列。
            ("document.getElementById('s').getClientRects().length", "0"),
            // `element.offsetParent`（丸ごと未対応だった。祖先に position が
            // static 以外の要素も `<body>` も無ければ仕様どおり `null`）。
            (
                "document.getElementById('t').offsetParent",
                "null",
            ),
            (
                "document.getElementById('wrap').style.position='relative'; \
                 document.getElementById('t').offsetParent.id",
                "wrap",
            ),
        ];
        total += rect_checks.len();
        for (src, expect) in rect_checks {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(dom2_html));
            // レンダラ相当: #t の矩形 (x=10,y=20,w=30,h=40) を注入。
            let idx = rt.dom.borrow().get_element_by_id("t");
            if let Some(i) = idx {
                rt.dom.borrow_mut().set_rect(i, 10, 20, 30, 40);
                rt.dom.borrow_mut().set_border_widths(i, 2, 3, 4, 5); // top=2, right=3, bottom=4, left=5
            }
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }

    // `document.elementFromPoint(x,y)`/`.elementsFromPoint(x,y)`（座標ヒットテスト）
    // が丸ごと未対応だった。`rects`（レンダラが `set_rect` で注入）から座標を含む
    // 矩形を集め、最も面積が小さい（＝最も深くネストした）要素を返す簡略実装。
    {
        let point_checks: &[(&str, &str)] = &[
            ("document.elementFromPoint(20, 15).id", "t"),
            ("document.elementFromPoint(5, 5).id", "wrap"),
            ("document.elementFromPoint(500, 500)", "null"),
            (
                "document.elementsFromPoint(20, 15).map(e => e.id).join(',')",
                "t,wrap",
            ),
        ];
        total += point_checks.len();
        for (src, expect) in point_checks {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(dom2_html));
            // レンダラ相当: 'wrap'（外側、大きい矩形）に 't'（内側、小さい矩形）が
            // ネストした状態を注入。
            let wrap_idx = rt.dom.borrow().get_element_by_id("wrap");
            if let Some(i) = wrap_idx {
                rt.dom.borrow_mut().set_rect(i, 0, 0, 100, 100);
            }
            let t_idx = rt.dom.borrow().get_element_by_id("t");
            if let Some(i) = t_idx {
                rt.dom.borrow_mut().set_rect(i, 10, 10, 30, 20);
            }
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }

    // getComputedStyle（set_computed_style で注入した算出スタイルを camelCase/kebab/getPropertyValue で読む）。
    {
        let cs_checks: &[(&str, &str)] = &[
            ("getComputedStyle(document.getElementById('t')).color", "red"),
            ("getComputedStyle(document.getElementById('t')).backgroundColor", "blue"),
            ("getComputedStyle(document.getElementById('t')).getPropertyValue('background-color')", "blue"),
            ("window.getComputedStyle(document.getElementById('t')).fontSize", "16px"),
        ];
        total += cs_checks.len();
        for (src, expect) in cs_checks {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(dom2_html));
            let idx = rt.dom.borrow().get_element_by_id("t");
            if let Some(i) = idx {
                let mut d = rt.dom.borrow_mut();
                d.set_computed_style(i, "color", "red");
                d.set_computed_style(i, "background-color", "blue");
                d.set_computed_style(i, "font-size", "16px");
            }
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }

    // `element.checkVisibility()`（DOM 標準。丸ごと未対応だった）。
    {
        let cv_checks: &[(&str, &str, &[(&str, &str, &str)])] = &[
            (
                "document.getElementById('t').checkVisibility()",
                "true",
                &[],
            ),
            (
                "document.getElementById('t').checkVisibility()",
                "false",
                &[("t", "display", "none")],
            ),
            (
                "document.getElementById('t').checkVisibility()",
                "false",
                &[("wrap", "display", "none")],
            ),
            (
                "document.getElementById('t').checkVisibility()",
                "false",
                &[("t", "visibility", "hidden")],
            ),
        ];
        total += cv_checks.len();
        for (src, expect, styles) in cv_checks {
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(dom2_html));
            for (id, prop, val) in *styles {
                let idx = rt.dom.borrow().get_element_by_id(id);
                if let Some(i) = idx {
                    rt.dom.borrow_mut().set_computed_style(i, prop, val);
                }
            }
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }

    // クリックディスパッチの統合確認（リスナ登録→dispatch_click→カウンタ増加）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(dom_html));
        let _ = rt.eval("var clicks=0; document.getElementById('b').addEventListener('click', () => { clicks++; document.getElementById('out').textContent = 'clicked ' + clicks; });");
        let bidx = rt.dom.borrow().get_element_by_id("b");
        if let Some(i) = bidx {
            rt.dispatch_click(i);
            rt.dispatch_click(i);
        }
        match rt.eval("clicks + ':' + document.getElementById('out').textContent") {
            Ok(v) if v.to_js_string() == "2:clicked 2" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: click dispatch => `{}` (want `2:clicked 2`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  click dispatch => {}", e),
        }
    }

    // Event: バブリング / target・currentTarget / stopPropagation / preventDefault / stopImmediate。
    let event_html = "<div id='par'><button id='btn'>go</button></div>";
    let event_checks: &[(&str, &str, &str)] = &[
        // 委譲: par のリスナが子 btn のクリックで発火。target=btn, currentTarget=par。
        ("var L=''; document.getElementById('par').addEventListener('click', function(e){ L += 'par('+e.target.id+','+e.currentTarget.id+')'; });",
         "L", "par(btn,par)"),
        // バブリング順: target(btn) → 祖先(par)。
        ("var L=''; document.getElementById('btn').addEventListener('click', function(){ L+='btn'; }); document.getElementById('par').addEventListener('click', function(){ L+='-par'; });",
         "L", "btn-par"),
        // stopPropagation で祖先に伝播しない。
        ("var L=''; document.getElementById('btn').addEventListener('click', function(e){ L+='btn'; e.stopPropagation(); }); document.getElementById('par').addEventListener('click', function(){ L+='-par'; });",
         "L", "btn"),
        // preventDefault → defaultPrevented。
        ("var L=''; document.getElementById('btn').addEventListener('click', function(e){ e.preventDefault(); L += e.defaultPrevented; });",
         "L", "true"),
        // stopImmediatePropagation で同一ノードの後続リスナも止まる。
        ("var L=''; document.getElementById('btn').addEventListener('click', function(e){ L+='1'; e.stopImmediatePropagation(); }); document.getElementById('btn').addEventListener('click', function(){ L+='2'; });",
         "L", "1"),
        // キャプチャ→ターゲット→バブルの順。par(capture) → btn → par(bubble)。
        ("var L=''; document.getElementById('par').addEventListener('click', function(){ L+='cap'; }, true); document.getElementById('btn').addEventListener('click', function(){ L+='-tgt'; }); document.getElementById('par').addEventListener('click', function(){ L+='-bub'; });",
         "L", "cap-tgt-bub"),
        // eventPhase: capture=1, at target=2, bubble=3。
        ("var P=''; document.getElementById('par').addEventListener('click', function(e){ P+=e.eventPhase; }, true); document.getElementById('btn').addEventListener('click', function(e){ P+=e.eventPhase; }); document.getElementById('par').addEventListener('click', function(e){ P+=e.eventPhase; });",
         "P", "123"),
        // once: クリックで一度発火する（複数回 dispatch のテストは専用ブロックで実施）。
        ("var N=0; document.getElementById('btn').addEventListener('click', function(){ N++; }, {once:true}); N",
         "N", "1"),
        // removeEventListener: 登録解除すると発火しない。
        ("var L=''; function h(){ L+='x'; } document.getElementById('btn').addEventListener('click', h); document.getElementById('btn').removeEventListener('click', h);",
         "L", ""),
        // composedPath: target→祖先（btn, par, ...）。先頭2件の id を確認。
        ("var C=''; document.getElementById('btn').addEventListener('click', function(e){ var p=e.composedPath(); C=p[0].id+','+p[1].id; });",
         "C", "btn,par"),
    ];
    total += event_checks.len();
    for (setup, read, expect) in event_checks {
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(event_html));
        let _ = rt.eval(setup);
        let bidx = rt.dom.borrow().get_element_by_id("btn");
        if let Some(i) = bidx {
            rt.dispatch_click(i);
        }
        match rt.eval(read) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: event `{}` => `{}` (want `{}`)",
                read,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  event `{}` => {}", read, e),
        }
    }

    // dispatchEvent: 手動で Event を発火し、リスナが受け取りバブリングする
    // （`bubbles: true` を明示。仕様上 `new Event('foo')` の既定は `bubbles: false`
    // で、以前は `bubbles` を一切見ず常に無条件で祖先まで伝播していたバグが
    // あったため、明示的に `true` を指定してバブリングの意図を検証する）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(event_html));
        let _ = rt.eval(
            "var L=''; \
             document.getElementById('btn').addEventListener('foo', function(e){ L+='btn:'+e.type; }); \
             document.getElementById('par').addEventListener('foo', function(){ L+='-par'; }); \
             document.getElementById('btn').dispatchEvent(new Event('foo', {bubbles:true}));",
        );
        match rt.eval("L") {
            Ok(v) if v.to_js_string() == "btn:foo-par" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: dispatchEvent => `{}` (want `btn:foo-par`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  dispatchEvent => {}", e),
        }
    }

    // dispatchEvent: `bubbles: false`（既定）なら祖先へ伝播しない。以前は
    // `bubbles` を一切見ず常に無条件で祖先まで伝播してしまう仕様違反バグだった。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(event_html));
        let _ = rt.eval(
            "var L=''; \
             document.getElementById('btn').addEventListener('foo', function(e){ L+='btn:'+e.type; }); \
             document.getElementById('par').addEventListener('foo', function(){ L+='-par'; }); \
             document.getElementById('btn').dispatchEvent(new Event('foo'));",
        );
        match rt.eval("L") {
            Ok(v) if v.to_js_string() == "btn:foo" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: dispatchEvent non-bubbling => `{}` (want `btn:foo`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  dispatchEvent non-bubbling => {}", e),
        }
    }

    // dispatchEvent: CustomEvent の `bubbles` オプションが正しく反映される
    // （以前は常に `false` 決め打ちで、`{bubbles:true}` を渡しても無視されていた）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(event_html));
        let _ = rt.eval(
            "var L=''; \
             document.getElementById('btn').addEventListener('foo', function(e){ L+='btn:'+e.type; }); \
             document.getElementById('par').addEventListener('foo', function(){ L+='-par'; }); \
             document.getElementById('btn').dispatchEvent(new CustomEvent('foo', {bubbles:true}));",
        );
        match rt.eval("L") {
            Ok(v) if v.to_js_string() == "btn:foo-par" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: CustomEvent bubbles => `{}` (want `btn:foo-par`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  CustomEvent bubbles => {}", e),
        }
    }

    // once: 複数回 dispatch しても 1 回だけ発火。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(event_html));
        let _ = rt.eval(
            "var N=0; document.getElementById('btn').addEventListener('foo', function(){ N++; }, {once:true}); \
             document.getElementById('btn').dispatchEvent(new Event('foo')); \
             document.getElementById('btn').dispatchEvent(new Event('foo')); \
             document.getElementById('btn').dispatchEvent(new Event('foo'));",
        );
        match rt.eval("N") {
            Ok(v) if v.to_js_string() == "1" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: once dispatch => `{}` (want `1`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  once dispatch => {}", e),
        }
    }

    // dispatchEvent 戻り値: preventDefault されると false（`cancelable:true` の場合のみ。
    // 以前は `cancelable` が一切読まれておらず preventDefault() が常に効いていた
    // バグの修正に伴い、このテストが元々検証したかった「妨害可能なイベントで
    // preventDefault() が効く」という意図を保つため `new Event('foo', {cancelable:
    // true})` に明示する）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(event_html));
        let _ = rt.eval(
            "document.getElementById('btn').addEventListener('foo', function(e){ e.preventDefault(); }); \
             var R = document.getElementById('btn').dispatchEvent(new Event('foo', {cancelable:true}));",
        );
        match rt.eval("R") {
            Ok(v) if v.to_js_string() == "false" => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: dispatchEvent return => `{}` (want `false`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  dispatchEvent return => {}", e),
        }
    }

    // keydown / input / focus / blur / change / submit / mouse(座標含む) イベント。
    // change イベント: input/select に change リスナを登録し dispatch_event で発火。
    let change_html = "<form><input id='cb' type='checkbox'><select id='sel'><option value='a'>A</option><option value='b'>B</option></select></form>";
    let mut change_passed = 0usize;
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(change_html));
        let _ = rt.eval("var c=0; document.getElementById('cb').addEventListener('change', function(){ c++; });");
        let cidx = rt.dom.borrow().get_element_by_id("cb");
        if let Some(i) = cidx {
            rt.dispatch_event(i, "change");
            rt.dispatch_event(i, "change");
        }
        match rt.eval("c") {
            Ok(v) if v.to_js_string() == "2" => change_passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: change count => `{}` (want `2`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  change count => {}", e),
        }
    }
    {
        total += 1;
        // change イベントの target が発火要素であること。
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(change_html));
        let _ = rt.eval("var t=''; document.getElementById('sel').addEventListener('change', function(e){ t=e.target.id; });");
        let sidx = rt.dom.borrow().get_element_by_id("sel");
        if let Some(i) = sidx {
            rt.dispatch_event(i, "change");
        }
        match rt.eval("t") {
            Ok(v) if v.to_js_string() == "sel" => change_passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: change target => `{}` (want `sel`)",
                v.to_js_string()
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  change target => {}", e),
        }
    }
    passed += change_passed;

    {
        let kev_html = "<div id='par'><input id='inp'></div>";
        // 1. keydown が e.type/e.key 付きで発火。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('inp').addEventListener('keydown', function(e){ L = e.type + ':' + e.key; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_key(i, "keydown", "x");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "keydown:x" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: keydown e.key");
            }
        }
        // 2. keydown が祖先へバブリング（委譲）。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('par').addEventListener('keydown', function(e){ L = 'par:' + e.target.id; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_key(i, "keydown", "a");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "par:inp" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: keydown bubbling");
            }
        }
        // 3. keydown の preventDefault が dispatch_key の戻り値 .1 に反映。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("document.getElementById('inp').addEventListener('keydown', function(e){ e.preventDefault(); });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            let prevented = idx
                .map(|i| rt.dispatch_key(i, "keydown", "a").1)
                .unwrap_or(false);
            if prevented {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: keydown preventDefault");
            }
        }
        // 4. input イベントが発火。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var N=0; document.getElementById('inp').addEventListener('input', function(){ N++; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "input");
            }
            if rt.eval("N").map(|v| v.to_js_string()).unwrap_or_default() == "1" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: input event");
            }
        }
        // 5. focus イベントが発火（e.type）。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('inp').addEventListener('focus', function(e){ L = e.type; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "focus");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "focus" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: focus event");
            }
        }
        // 6. blur イベントが祖先へバブリング。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('par').addEventListener('blur', function(e){ L = 'blur:' + e.target.id; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "blur");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "blur:inp" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: blur bubbling");
            }
        }
        // 7. change イベントが発火。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('inp').addEventListener('change', function(e){ L = e.type; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "change");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "change" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: change event");
            }
        }
        // 8/9. submit イベントの発火と preventDefault（送信キャンセル）。
        let form_html = "<form id='f'><input id='inp2'></form>";
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(form_html));
            let _ = rt.eval("var S=0; document.getElementById('f').addEventListener('submit', function(){ S++; });");
            let idx = rt.dom.borrow().get_element_by_id("f");
            if let Some(i) = idx {
                rt.dispatch_event_with(i, "submit", &[]);
            }
            if rt.eval("S").map(|v| v.to_js_string()).unwrap_or_default() == "1" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: submit event");
            }
        }
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(form_html));
            let _ = rt.eval("document.getElementById('f').addEventListener('submit', function(e){ e.preventDefault(); });");
            let idx = rt.dom.borrow().get_element_by_id("f");
            let prevented = idx
                .map(|i| rt.dispatch_event_with(i, "submit", &[]).1)
                .unwrap_or(false);
            if prevented {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: submit preventDefault");
            }
        }
        // 10. mouseover が発火（e.type）。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('inp').addEventListener('mouseover', function(e){ L = e.type; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "mouseover");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "mouseover" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: mouseover event");
            }
        }
        // 11. mouseout が祖先へバブリング。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('par').addEventListener('mouseout', function(e){ L = 'out:' + e.target.id; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "mouseout");
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "out:inp" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: mouseout bubbling");
            }
        }
        // 12. mousemove が発火（回数カウント）。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var N=0; document.getElementById('inp').addEventListener('mousemove', function(){ N++; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_event(i, "mousemove");
                rt.dispatch_event(i, "mousemove");
            }
            if rt.eval("N").map(|v| v.to_js_string()).unwrap_or_default() == "2" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: mousemove event");
            }
        }
        // 13. dispatch_mouse が clientX/clientY を付与。
        {
            total += 1;
            let mut rt = JsRuntime::new();
            rt.dom
                .borrow_mut()
                .build_from(&crate::os_lib::dom::parse_html(kev_html));
            let _ = rt.eval("var L=''; document.getElementById('inp').addEventListener('click', function(e){ L = e.clientX + ',' + e.clientY; });");
            let idx = rt.dom.borrow().get_element_by_id("inp");
            if let Some(i) = idx {
                rt.dispatch_mouse(i, "click", 42, 17);
            }
            if rt.eval("L").map(|v| v.to_js_string()).unwrap_or_default() == "42,17" {
                passed += 1;
            } else {
                crate::println!("JS_SELFTEST FAIL: mouse clientX/clientY");
            }
        }
    }

    // window/document.location（set_page_url 後に各成分を検証）。
    let location_cases: &[(&str, &str)] = &[
        ("location.href", "https://example.com/foo/bar?q=1#h"),
        ("location.protocol", "https:"),
        ("location.host", "example.com"),
        ("location.hostname", "example.com"),
        ("location.pathname", "/foo/bar"),
        ("location.search", "?q=1"),
        ("location.hash", "#h"),
        ("location.origin", "https://example.com"),
        ("window.location.href", "https://example.com/foo/bar?q=1#h"),
        ("document.location.pathname", "/foo/bar"),
        ("location.toString()", "https://example.com/foo/bar?q=1#h"),
        ("window.location === document.location", "true"),
        // `location.protocol`/`.host`/`.hostname`/`.port`への代入は仕様上
        // 再ナビゲーションを要求すべきだが、`href`/`hash`/`pathname`/`search`
        // だけがナビゲーション要求（`_pending_location`）に変換されており、
        // この4つは常に黙って見かけ上の`.props`値だけ更新され、実際には
        // どこへも「移動しない」バグだった。
        // `location_cases`は1つの`rt`を全ケースで使い回す（前のケースの代入が
        // 後続へ持ち越される）ため、各ケースの先頭で`protocol`/`host`を
        // 明示的に既知の状態へリセットしてから検証し、実行順に依存しない
        // ようにする。
        (
            "location.protocol='http:'; location._pending_location",
            "http://example.com/foo/bar?q=1",
        ),
        (
            "location.protocol='https:'; location.host='example.com'; \
             location.hostname='other.com'; location._pending_location",
            "https://other.com/foo/bar?q=1",
        ),
        (
            "location.host='example.com'; location.port='8080'; location._pending_location",
            "https://example.com:8080/foo/bar?q=1",
        ),
        (
            "location.host='new.com:9090'; location._pending_location",
            "https://new.com:9090/foo/bar?q=1",
        ),
        (
            "location.host='new.com:9090'; location.hostname + ',' + location.port",
            "new.com,9090",
        ),
        // `<a>.href`/`<img>.src`/`<form>.action` は仕様上、生の属性文字列ではなく
        // ページURL基準で解決した絶対URLを返す必要があるが、以前はこの解決が
        // 一切行われず相対文字列がそのまま返るバグだった。
        (
            "var a=document.createElement('a'); a.setAttribute('href','/p3'); a.href",
            "https://example.com/p3",
        ),
        (
            "var i=document.createElement('img'); i.setAttribute('src','x.png'); i.src",
            "https://example.com/foo/x.png",
        ),
        (
            "var a=document.createElement('a'); a.setAttribute('href','https://o.com/z'); a.href",
            "https://o.com/z",
        ),
        // `document.URL`/`document.documentURI`/`node.baseURI`（DOM 標準。丸ごと
        // 未対応だった。`<base>` タグ非対応のため常に `location.href` と同値）。
        ("document.URL", "https://example.com/foo/bar?q=1#h"),
        ("document.documentURI", "https://example.com/foo/bar?q=1#h"),
        (
            "document.createElement('div').baseURI",
            "https://example.com/foo/bar?q=1#h",
        ),
        // `document.readyState`（HTML5。丸ごと未対応だった。この処理系は常に
        // "complete" を返す簡略実装）。
        ("document.readyState", "complete"),
        // `document.cookie`（丸ごと未対応だった。`expires`/`path` 等の属性は
        // 無視する簡略実装で `name=value` のみ反映する）。
        (
            "document.cookie='ck_a=1'; document.cookie='ck_b=2; path=/'; document.cookie",
            "ck_a=1; ck_b=2",
        ),
        // `cookieStore`（Cookie Store API。丸ごと未対応だった。`document.cookie`
        // と同じ実データを共有する非同期版。他のテストと Cookie 名が衝突しない
        // よう `cs_` 接頭辞を使う）。
        (
            "await cookieStore.set('cs_x', '1'); (await cookieStore.get('cs_x')).value",
            "1",
        ),
        ("(await cookieStore.get('cs_missing'))", "null"),
        (
            "await cookieStore.set('cs_y', '2'); \
             (await cookieStore.getAll('cs_y')).map(c => c.name+'='+c.value).join(',')",
            "cs_y=2",
        ),
        (
            "await cookieStore.set('cs_z', '3'); await cookieStore.delete('cs_z'); \
             (await cookieStore.get('cs_z'))",
            "null",
        ),
        (
            "await cookieStore.set({name:'cs_w', value:'4'}); (await cookieStore.get('cs_w')).value",
            "4",
        ),
        // Page Visibility API（`document.hidden`/`.visibilityState`）が丸ごと
        // 未対応だった。タブ/バックグラウンド化の概念が無いため常に「表示中」。
        ("document.hidden", "false"),
        ("document.visibilityState", "visible"),
    ];
    total += location_cases.len();
    {
        let mut rt = JsRuntime::new();
        rt.set_page_url("https://example.com/foo/bar?q=1#h");
        for (src, expect) in location_cases {
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }

    // history.pushState / replaceState（location 書換え + state/length）。
    let history_cases: &[(&str, &str)] = &[
        (
            "history.pushState({a:1},'','/p2'); location.pathname",
            "/p2",
        ),
        (
            "history.pushState({},'','/p2'); location.href",
            "https://example.com/p2",
        ),
        ("history.pushState({a:9},'','/p2'); history.state.a", "9"),
        (
            "var n=history.length; history.pushState({},'','/x'); history.length - n",
            "1",
        ),
        (
            "var n=history.length; history.replaceState({},'','/y'); history.length - n",
            "0",
        ),
        (
            "history.replaceState({},'','about.html'); location.pathname",
            "/foo/about.html",
        ),
        ("typeof history.pushState", "function"),
        ("typeof history.back", "function"),
    ];
    total += history_cases.len();
    for (src, expect) in history_cases {
        let mut rt = JsRuntime::new();
        rt.set_page_url("https://example.com/foo/bar");
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
        }
    }

    // 相対URL解決（resolve_url 純関数。fetch/XHR の base 基準解決）。
    let resolve_cases: &[(&str, &str, &str)] = &[
        ("http://h.com/a/b.html", "/api", "http://h.com/api"),
        ("http://h.com/a/b.html", "x.json", "http://h.com/a/x.json"),
        ("http://h.com/a/", "x.json", "http://h.com/a/x.json"),
        (
            "http://h.com/a/b.html",
            "https://o.com/z",
            "https://o.com/z",
        ),
        ("http://h.com/a/b.html", "data:,hi", "data:,hi"),
        ("https://h.com/", "/p/q", "https://h.com/p/q"),
        ("http://h.com", "y", "http://h.com/y"),
        ("", "/api", "/api"),
        // `.`/`..` セグメント解決（以前は文字列結合のみで未解決のまま残っていた）。
        ("https://h.com/a/b/c", "../style.css", "https://h.com/a/style.css"),
        ("https://h.com/a/b/c", "./style.css", "https://h.com/a/b/style.css"),
        ("https://h.com/a/b/c/d", "../../x", "https://h.com/a/x"),
    ];
    total += resolve_cases.len();
    for (base, url, expect) in resolve_cases {
        let got = builtins::resolve_url(base, url);
        if &got == expect {
            passed += 1;
        } else {
            crate::println!(
                "JS_SELFTEST FAIL: resolve_url({:?},{:?}) => `{}` (want `{}`)",
                base,
                url,
                got,
                expect
            );
        }
    }

    // HTML5 制約バリデーション（checkValidity / setCustomValidity / validity）。
    let validity_cases: &[(&str, &str, &str)] = &[
        // (html, script, expect)
        ("<input id='a' required value=''>", "document.getElementById('a').checkValidity()", "false"),
        ("<input id='a' required value='x'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' value='hi'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' type='email' value='nope'>", "document.getElementById('a').checkValidity()", "false"),
        ("<input id='a' type='email' value='x@y.com'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' type='number' min='5' value='3'>", "document.getElementById('a').checkValidity()", "false"),
        ("<input id='a' type='number' min='5' value='9'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' minlength='3' value='ab'>", "document.getElementById('a').checkValidity()", "false"),
        ("<input id='a' maxlength='2' value='abc'>", "document.getElementById('a').checkValidity()", "false"),
        ("<input id='a' value='ok'>", "var e=document.getElementById('a'); e.setCustomValidity('bad'); e.checkValidity()", "false"),
        ("<input id='a' value='ok'>", "var e=document.getElementById('a'); e.setCustomValidity('bad'); e.setCustomValidity(''); e.checkValidity()", "true"),
        ("<input id='a' required value=''>", "document.getElementById('a').validity.valueMissing", "true"),
        ("<input id='a' required value='x'>", "document.getElementById('a').validity.valid", "true"),
        ("<input id='a' value='hi'>", "document.getElementById('a').willValidate", "true"),
        ("<input id='a' type='submit'>", "document.getElementById('a').willValidate", "false"),
        // `pattern` 属性が以前はメタ文字を含む複雑なパターンを「誤検知回避のため」
        // 無条件で通過させる簡易近似だった。本物の RegExp エンジンで `^(?:pattern)$`
        // として正しく検証するよう修正（`\d+`/`[0-9]{3}` 等、通常の JS RegExp 構文）。
        ("<input id='a' pattern='[0-9]{3}' value='123'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' pattern='[0-9]{3}' value='ab'>", "document.getElementById('a').checkValidity()", "false"),
        ("<input id='a' pattern='\\d+' value='123'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' pattern='\\d+' value='abc'>", "document.getElementById('a').checkValidity()", "false"),
        // 空値は非 required なら pattern チェック自体を適用しない（仕様どおり）。
        ("<input id='a' pattern='[0-9]{3}' value=''>", "document.getElementById('a').checkValidity()", "true"),
        // `stepMismatch`（HTML5 制約検証。min/max はあったが step が丸ごと未対応だった）。
        ("<input id='a' type='number' step='2' value='4'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' type='number' step='2' value='3'>", "document.getElementById('a').checkValidity()", "false"),
        // step の基準点は min（無ければ 0）。min=1, step=2 なら 1,3,5,... が有効。
        ("<input id='a' type='number' min='1' step='2' value='5'>", "document.getElementById('a').checkValidity()", "true"),
        ("<input id='a' type='number' min='1' step='2' value='4'>", "document.getElementById('a').checkValidity()", "false"),
        // `step=\"any\"` は制約なし。
        ("<input id='a' type='number' step='any' value='3.14159'>", "document.getElementById('a').checkValidity()", "true"),
        // `validity` オブジェクトが `valid`/`valueMissing`/`customError` の3つしか
        // 公開しておらず、`patternMismatch`/`typeMismatch`/`rangeOverflow`/
        // `rangeUnderflow`/`stepMismatch`/`tooLong`/`tooShort`/`badInput` という
        // 特定の制約を狙い撃ちする定番パターンが常に `undefined` になっていた。
        ("<input id='a' pattern='[0-9]{3}' value='ab'>", "document.getElementById('a').validity.patternMismatch", "true"),
        ("<input id='a' pattern='[0-9]{3}' value='123'>", "document.getElementById('a').validity.patternMismatch", "false"),
        ("<input id='a' type='email' value='nope'>", "document.getElementById('a').validity.typeMismatch", "true"),
        ("<input id='a' type='number' min='5' value='3'>", "document.getElementById('a').validity.rangeUnderflow", "true"),
        ("<input id='a' type='number' max='5' value='9'>", "document.getElementById('a').validity.rangeOverflow", "true"),
        ("<input id='a' type='number' step='2' value='3'>", "document.getElementById('a').validity.stepMismatch", "true"),
        ("<input id='a' maxlength='2' value='abc'>", "document.getElementById('a').validity.tooLong", "true"),
        ("<input id='a' minlength='3' value='ab'>", "document.getElementById('a').validity.tooShort", "true"),
        ("<input id='a' type='number' value='abc'>", "document.getElementById('a').validity.badInput", "true"),
        // **重要**: `<form>.checkValidity()` が子孫コントロールを一切見ず、`<form>`
        // タグ自身に対する検証（常に無条件で true）を返すだけだったバグ。
        (
            "<form id='f3'><input required value=''></form>",
            "document.getElementById('f3').checkValidity()",
            "false",
        ),
        (
            "<form id='f3'><input required value='x'></form>",
            "document.getElementById('f3').checkValidity()",
            "true",
        ),
        (
            "<form id='f3'><input required value='x'><input type='email' value='nope'></form>",
            "document.getElementById('f3').checkValidity()",
            "false",
        ),
        // `checkValidity()`/`.validationMessage`/`.validity`が`get_attr(idx,"value")`
        // だけを見ており、`value`属性を持たない`<select>`（選択状態は子の
        // `<option selected>`が持つ）や、初期値がテキストノードで表現される
        // `<textarea>`では、実際には値があっても常に空文字列＝未入力として
        // 誤って`required`違反になっていたバグ。`.value`ゲッターは既に正しい
        // フォールバックを持っていたが、制約バリデーション側に伝わっていなかった。
        (
            "<select id='a' required><option value='x' selected>X</option></select>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<select id='a' required><option value='x' selected>X</option></select>",
            "document.getElementById('a').validity.valueMissing",
            "false",
        ),
        (
            "<textarea id='a' required>hello</textarea>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<textarea id='a' required></textarea>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        (
            "<form id='f4'><select required><option value='x' selected>X</option></select></form>",
            "document.getElementById('f4').checkValidity()",
            "true",
        ),
        // `required`のcheckbox/radioは「値」でなく「チェック状態」で判定すべき
        // （HTML5仕様）だが、以前は他のinputと同じ「value属性が空か」で判定して
        // いたため、value属性を持たないcheckedなチェックボックスが常にrequired
        // 違反（valueが空文字列扱い）、逆にvalue属性だけ設定した未チェックの
        // チェックボックスが常に妥当、というチェック状態と無関係な結果になっていた。
        (
            "<input id='a' type='checkbox' required>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        (
            "<input id='a' type='checkbox' required checked>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='checkbox' value='yes' required>",
            "document.getElementById('a').validity.valueMissing",
            "true",
        ),
        (
            "<input id='a' type='checkbox' required checked>",
            "document.getElementById('a').validity.valueMissing",
            "false",
        ),
        // radioはグループ内のいずれかがcheckedであれば充足（自身がcheckedで
        // なくても良い）。
        (
            "<input id='a' type='radio' name='g' required><input type='radio' name='g' checked>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='radio' name='g' required><input type='radio' name='g'>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        // `type="range"`は`type="number"`と同じmin/max/step制約検証規則を持つ
        // （`.stepUp()`/`.valueAsNumber`は既に両者を同列に扱っていたが、
        // `validity.rangeOverflow`/`.rangeUnderflow`/`.stepMismatch`だけ
        // `number`型限定になっており、range型では常にfalse固定だった）。
        (
            "<input id='a' type='range' min='0' max='10' value='20'>",
            "document.getElementById('a').validity.rangeOverflow",
            "true",
        ),
        (
            "<input id='a' type='range' min='0' max='10' value='-5'>",
            "document.getElementById('a').validity.rangeUnderflow",
            "true",
        ),
        (
            "<input id='a' type='range' min='0' max='10' value='5'>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='range' min='0' max='10' step='2' value='3'>",
            "document.getElementById('a').validity.stepMismatch",
            "true",
        ),
        // `type="date"`/`type="month"`の形式チェックが丸ごと未対応だった
        // （`input.valueAsDate`は既存の`input_value_as_date_ms()`で妥当性を
        // 判定していたが、`validity.typeMismatch`には配線されておらず、
        // 不正な日付文字列を代入しても常に`typeMismatch: false`だった）。
        (
            "<input id='a' type='date' value='2026-07-17'>",
            "document.getElementById('a').validity.typeMismatch",
            "false",
        ),
        (
            "<input id='a' type='date' value='not-a-date'>",
            "document.getElementById('a').validity.typeMismatch",
            "true",
        ),
        (
            "<input id='a' type='month' value='2026-07'>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='date' value='2026-13-99'>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        // `<input type="email" multiple>`はカンマ区切りで複数アドレスを入力できる
        // 仕様だが、以前は`is_valid_email(value)`を値全体にそのまま適用しており、
        // 2件目以降のアドレスやカンマを含む正当な値が常に不正判定されていた。
        (
            "<input id='a' type='email' multiple value='a@b.com,c@d.com'>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='email' multiple value='a@b.com, c@d.com'>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='email' multiple value='a@b.com,nope'>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        (
            // `multiple`が無ければ従来どおりカンマ区切りは単一アドレスとして不正。
            "<input id='a' type='email' value='a@b.com,c@d.com'>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        // `type="date"`/`type="month"`の`min`/`max`範囲制約（`type="number"`と同様に
        // 対応可能な仕様なのに丸ごと欠けていた）。
        (
            "<input id='a' type='date' min='2026-01-01' max='2026-12-31' value='2025-12-31'>",
            "document.getElementById('a').validity.rangeUnderflow",
            "true",
        ),
        (
            "<input id='a' type='date' min='2026-01-01' max='2026-12-31' value='2027-01-01'>",
            "document.getElementById('a').validity.rangeOverflow",
            "true",
        ),
        (
            "<input id='a' type='date' min='2026-01-01' max='2026-12-31' value='2026-06-15'>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<input id='a' type='month' min='2026-03' max='2026-09' value='2026-01'>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        // `<fieldset disabled>`の子孫コントロールは自身に`disabled`属性が無くても
        // 暗黙に無効化される（HTML5仕様）。以前は要素自身の`disabled`属性しか
        // 見ておらず、`.disabled`が常に`false`・制約バリデーションも無効化
        // されずに常に対象内のままだった。
        (
            "<fieldset disabled><input id='a' required></fieldset>",
            "document.getElementById('a').disabled",
            "true",
        ),
        (
            "<fieldset disabled><input id='a' required></fieldset>",
            "document.getElementById('a').checkValidity()",
            "true",
        ),
        (
            "<fieldset><input id='a' required></fieldset>",
            "document.getElementById('a').disabled",
            "false",
        ),
        (
            // 無効化されている以上、値が実際には空でも valueMissing にはならない
            // （disabled要素は制約バリデーションの対象外という仕様どおり）。
            "<fieldset disabled><input id='a' required value=''></fieldset>",
            "document.getElementById('a').validity.valueMissing",
            "false",
        ),
        // `form="formId"`属性（HTML5仕様の「form owner」）による、`<form>`の外に
        // 置かれたコントロールとの明示的な関連付けが丸ごと未対応だった。
        // `element.form`は祖先探索（`closest_tag`）しか見ておらず、
        // `<form>.checkValidity()`もフォームの子孫しか走査していなかったため、
        // フォーム外配置のコントロールが両方から漏れていた。
        (
            "<form id='f5'></form><input id='a' form='f5'>",
            "document.getElementById('a').form === document.getElementById('f5')",
            "true",
        ),
        (
            "<form id='f5'></form><input id='a' form='f5' required>",
            "document.getElementById('f5').checkValidity()",
            "false",
        ),
        (
            "<form id='f5'></form><input id='a' form='f5' required value='x'>",
            "document.getElementById('f5').checkValidity()",
            "true",
        ),
        (
            // `form`属性が無い通常の input はこれまでどおり祖先探索のみ。
            "<div><input id='a'></div>",
            "document.getElementById('a').form",
            "null",
        ),
        // `type="datetime-local"`の`validity.typeMismatch`/`min`/`max`が丸ごと
        // 未対応だった。`input_value_as_date_ms()`は既存の`parse_iso_date`が
        // `YYYY-MM-DDTHH:MM`形式を既にサポートしているため、`date`/`month`と
        // 同じ扱いに含めるだけで対応できた。
        (
            "<input id='a' type='datetime-local' value='2026-07-17T14:30'>",
            "document.getElementById('a').validity.typeMismatch",
            "false",
        ),
        (
            "<input id='a' type='datetime-local' value='not-a-datetime'>",
            "document.getElementById('a').checkValidity()",
            "false",
        ),
        (
            "<input id='a' type='datetime-local' min='2026-01-01T00:00' max='2026-12-31T23:59' value='2025-06-01T00:00'>",
            "document.getElementById('a').validity.rangeUnderflow",
            "true",
        ),
        // `<details name="...">`排他グループの初期状態正規化（HTML5。
        // 丸ごと未対応だった）。同じ`name`を持つ複数の`<details open>`が
        // HTML記述時点で並んでいた場合、文書順で最後の1つだけが開いた
        // ままで残り、それより前のものは`build_from`（パース直後）の
        // 時点で自動的に閉じられる必要がある。2026-07-18 発見・実装）。
        (
            "<details id='a' name='g' open></details><details id='b' name='g' open></details>",
            "document.getElementById('a').open+','+document.getElementById('b').open",
            "false,true",
        ),
        (
            "<details id='a' name='g' open></details><details id='b' open></details>",
            "document.getElementById('a').open+','+document.getElementById('b').open",
            "true,true",
        ),
        // `HTMLCollection` / `HTMLFormControlsCollection` の `item(index)` / `namedItem(name)`
        // および `classList.value` ゲッター/セッター。
        (
            "<div id='wrap'><p id='t' name='foo'></p><span id='s'></span></div>",
            "document.getElementById('wrap').children.item(0).id + ',' + document.getElementById('wrap').children.namedItem('s').tagName + ',' + document.getElementById('wrap').children.namedItem('foo').id",
            "t,SPAN,t",
        ),
        (
            "<div id='wrap'><span></span></div>",
            "String(document.getElementById('wrap').children.item(99))",
            "null",
        ),
        (
            "<form id='f'><input id='i' name='user'></form>",
            "document.getElementById('f').elements.item(0).id + ',' + document.getElementById('f').elements.namedItem('user').id",
            "i,i",
        ),
        (
            "<form id='f'><input type='radio' name='r' value='v1'><input type='radio' name='r' value='v2' checked></form>",
            "var f=document.getElementById('f'); var list=f.elements.namedItem('r'); var v1=list.value; var len=list.length; list.value='v1'; var v2=list.value; var c0=list[0].checked; v1+','+len+','+v2+','+c0",
            "v2,2,v1,true",
        ),
        (
            "<div id='d' class='a b'></div>",
            "var d=document.getElementById('d'); var v=d.classList.value; d.classList.value='c d'; v+','+d.className",
            "a b,c d",
        ),
    ];
    total += validity_cases.len();
    for (html, src, expect) in validity_cases {
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(html));
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
        }
    }

    // ES modules（import/export）: 複数モジュールを define_module で登録し、
    // import 側スクリプトを評価して名前解決・default・namespace・再エクスポートを検証。
    {
        // 単純な named export を持つ算術モジュール。
        let math_src = "export const PI = 3; export function sq(x){ return x*x; } \
                        const e = 2; export { e as E };";
        // default export と named export の混在。
        let greet_src = "export default function(n){ return 'hi ' + n; } \
                          export const lang = 'ja';";
        // 別モジュールからの再エクスポート（集約モジュール）。
        let index_src = "export { PI, sq } from 'math'; export * from 'math';";
        // 循環 import: a は b を import し、b は a を import する。
        let cyc_a = "import { bVal } from 'cycb'; export const aVal = 10; \
                      export function getB(){ return bVal; }";
        let cyc_b = "import { aVal } from 'cyca'; export const bVal = 20;";

        let module_checks: &[(&str, &str)] = &[
            // named import + 関数呼び出し。
            ("import { PI, sq } from 'math'; sq(PI)", "9"),
            // as による別名 export を import。
            ("import { E } from 'math'; E", "2"),
            // default import。
            ("import greet from 'greet'; greet('bob')", "hi bob"),
            // default + named を同時 import。
            ("import greet, { lang } from 'greet'; greet(lang)", "hi ja"),
            // namespace import。
            ("import * as M from 'math'; M.sq(4) + M.PI", "19"),
            // 再エクスポート（named）。
            ("import { PI } from 'index'; PI", "3"),
            // 再エクスポート（export *）経由の関数。
            ("import { sq } from 'index'; sq(5)", "25"),
            // 循環 import: a 経由で b の値を取得。
            ("import { getB } from 'cyca'; getB()", "20"),
            // 副作用のみ import（エラーにならず undefined 評価が通ること）。
            ("import 'math'; 42", "42"),
        ];
        total += module_checks.len();
        for (src, expect) in module_checks {
            let mut rt = JsRuntime::new();
            rt.define_module("math", math_src);
            rt.define_module("greet", greet_src);
            rt.define_module("index", index_src);
            rt.define_module("cyca", cyc_a);
            rt.define_module("cycb", cyc_b);
            match rt.eval(src) {
                Ok(v) if &v.to_js_string() == expect => passed += 1,
                Ok(v) => crate::println!(
                    "JS_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                    src,
                    v.to_js_string(),
                    expect
                ),
                Err(e) => crate::println!("JS_SELFTEST ERR:  `{}` => {}", src, e),
            }
        }
    }

    // `window.scrollTo(x, y)`/`window.scrollBy(x, y)`（丸ごと未対応だった。
    // 以前は`scrollTo`が孤立した`SCROLL_Y` staticへ書くだけ、`scrollBy`は
    // `dom_noop`のままで、どちらも`window.scrollY`や実際の描画位置に一切
    // 反映されない死んだ経路だった。2026-07-16 発見・実装）。実際の視覚的
    // 反映は`web_engine/render.rs`の`draw()`側で行われヘッドレスJS自己テスト
    // からは駆動できないため、ここではJS→`DomBridge`への配線（`window_
    // scroll_to`/`window_scroll_by`が正しい保留値を書き込むこと）のみを
    // 直接Rustレベルで検証する。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        let _ = rt.eval("window.scrollTo(0, 120);");
        let y = rt.dom.borrow().pending_scroll_abs_y;
        if y == Some(120) {
            passed += 1;
        } else {
            crate::println!(
                "JS_SELFTEST FAIL: window.scrollTo pending_scroll_abs_y => `{:?}` (want `Some(120)`)",
                y
            );
        }
    }
    {
        total += 1;
        let mut rt = JsRuntime::new();
        let _ = rt.eval("window.scrollBy(0, 30); window.scrollBy(0, 15);");
        let dy = rt.dom.borrow().pending_scroll_by_y;
        if dy == Some(45) {
            passed += 1;
        } else {
            crate::println!(
                "JS_SELFTEST FAIL: window.scrollBy pending_scroll_by_y (累積) => `{:?}` (want `Some(45)`)",
                dy
            );
        }
    }
    // `element.scrollIntoView()`が丸ごとno-opだった（実サイト www.sugi-lab.net の
    // ナビゲーションリンクの`target.scrollIntoView({behavior:'smooth',
    // block:'start'})`が完全に無効化されていた。2026-07-22発見・修正）。
    // `window.scrollTo`と同じ`pending_scroll_abs_y`機構を再利用しているかを
    // 直接Rustレベルで検証する（対象要素のY座標250px、scrollY=0の状態から
    // `scrollIntoView()`を呼ぶと、絶対Y座標250へスクロールする保留値が
    // 設定されるはず）。
    {
        total += 1;
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html("<div id='t'></div>"));
        let idx = rt.dom.borrow().get_element_by_id("t");
        if let Some(i) = idx {
            rt.dom.borrow_mut().set_rect(i, 0, 250, 100, 50);
        }
        let _ = rt.eval("document.getElementById('t').scrollIntoView();");
        let y = rt.dom.borrow().pending_scroll_abs_y;
        if y == Some(250) {
            passed += 1;
        } else {
            crate::println!(
                "JS_SELFTEST FAIL: element.scrollIntoView pending_scroll_abs_y => `{:?}` (want `Some(250)`)",
                y
            );
        }
    }

    let dom_parser_cases: &[(&str, &str)] = &[
        (
            "var p = new DOMParser(); var doc = p.parseFromString('<div id=\"dp\">hello</div>', 'text/html'); doc.getElementById('dp').textContent",
            "hello",
        ),
    ];
    total += dom_parser_cases.len();
    for (code, expect) in dom_parser_cases {
        let mut rt = JsRuntime::new();
        let res = rt.eval(code);
        let got = res.map(|v| v.to_js_string()).unwrap_or_else(|e| alloc::format!("ERR: {:?}", e));
        if &got == expect {
            passed += 1;
        } else {
            crate::println!(
                "JS_SELFTEST FAIL: DOMParser code {:?} => `{}` (want `{}`)",
                code,
                got,
                expect
            );
        }
    }

    // DOMMatrix / DOMPoint / URLPattern / Iterator.concat / Iterator.from 自己テスト
    let geom_web_cases = [
        ("const m = new DOMMatrix([1,0,0,1,10,20]); m.a === 1 && m.e === 10", "true"),
        ("const m = new DOMMatrix(); m.translateSelf(10, 20); m.e === 10 && m.f === 20", "true"),
        ("const m = new DOMMatrix(); m.scaleSelf(2, 3); m.a === 2 && m.d === 3", "true"),
        ("const m = new DOMMatrix(); const p = new DOMPoint(5, 10); const p2 = m.translate(10, 20).transformPoint(p); p2.x === 15 && p2.y === 30", "true"),
        ("const m2 = DOMMatrix.fromMatrix({a: 2, d: 3, e: 5, f: 10}); m2.a === 2 && m2.e === 5", "true"),
        ("const p3 = new DOMPoint(1, 2).matrixTransform(new DOMMatrix([2,0,0,3,10,20])); p3.x === 12 && p3.y === 26", "true"),
        ("const pat = new URLPattern({ pathname: '/api/*' }); pat.test('/api/users')", "true"),
        ("const res = new URLPattern({ pathname: '/users/:id' }).exec('https://example.com/users/42'); res.pathname.groups.id", "42"),
        ("const it = Iterator.concat([1, 2], [3, 4]); it.toArray().join(',')", "1,2,3,4"),
        ("const it = Iterator.from([10, 20, 30]); it.take(2).toArray().join(',')", "10,20"),
        ("new Intl.DurationFormat('en', {style:'long'}).format({hours:1, minutes:30})", "1 hour, 30 minutes"),
        ("new Intl.DurationFormat('en').resolvedOptions().locale", "en-US"),
        ("Iterator.range(1, 5).toArray().join(',')", "1,2,3,4"),
        ("Iterator.range(0, 10, 2).toArray().join(',')", "0,2,4,6,8"),
        ("Iterator.range(5, 1, -1).toArray().join(',')", "5,4,3,2"),
    ];
    total += geom_web_cases.len();
    for (code, expect) in geom_web_cases {
        let mut rt = JsRuntime::new();
        let res = rt.eval(code);
        let got = res.map(|v| v.to_js_string()).unwrap_or_else(|e| alloc::format!("ERR: {:?}", e));
        if &got == expect {
            passed += 1;
        } else {
            crate::println!(
                "JS_SELFTEST FAIL: Geom/Web API code {:?} => `{}` (want `{}`)",
                code,
                got,
                expect
            );
        }
    }

    let template_html = r#"<div><template id="tmpl"><span>Hello</span></template></div>"#;
    let template_cases = [
        ("document.createElement('template') instanceof HTMLTemplateElement", "true"),
        ("const t = document.createElement('template'); t.content.nodeType === 11", "true"),
        ("const t = document.getElementById('tmpl'); t.content.childNodes.length", "1"),
        ("const t = document.getElementById('tmpl'); t.content.children[0].tagName", "SPAN"),
        ("const t = document.getElementById('tmpl'); const f = t.content.cloneNode(true); f.nodeType === 11 && f.children[0].textContent === 'Hello'", "true"),
        ("const s = document.createElement('select'); const o = document.createElement('option'); o.value='v1'; o.text='t1'; s.add(o); s.options.length === 1 && s.value === 'v1'", "true"),
        ("const u = new URL('https://www.sugi-lab.net/?a=1'); u.searchParams.set('b', '2'); u.search === '?a=1&b=2'", "true"),
        ("const div = document.createElement('div'); div.setAttribute('id', 'd1'); const c = div.cloneNode(true); c.id === 'd1' && c !== div", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx !== null && ctx.canvas === cv", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.measureText('test').width > 0", "true"),
        ("const cv = document.createElement('canvas'); cv.toDataURL().startsWith('data:image/png;base64,')", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.lineWidth = 10; ctx.reset(); ctx.lineWidth === 1", "true"),
        ("const p = new Path2D('M10 10 H 90 V 90 H 10 Z'); typeof p.moveTo === 'function' && typeof p.roundRect === 'function'", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); const p = new Path2D('M 10 10 H 90 V 90 Z'); ctx.fill(p); ctx.stroke(p); ctx.clip(p); true", "true"),
        ("const p1 = new Path2D(); p1.rect(0, 0, 10, 10); const p2 = new Path2D(p1); p2.addPath(p1); typeof p2.closePath === 'function'", "true"),
        ("const div = document.createElement('div'); div.getRootNode() === div", "true"),
        ("const div = document.getElementById('tmpl'); div.getRootNode() === document", "true"),
        ("const el = document.createElement('div'); document.adoptNode(el) === el", "true"),
        ("const el = document.createElement('div'); document.importNode(el, true) !== null", "true"),
        ("ArrayBuffer.isView(new Uint8Array(5)) && !ArrayBuffer.isView(new ArrayBuffer(5))", "true"),
        ("Math.clamp(15, 0, 10) === 10 && Math.clamp(-5, 0, 10) === 0 && Math.clamp(5, 0, 10) === 5", "true"),
        ("const io = new IntersectionObserver(()=>{}); typeof io.takeRecords === 'function' && io.takeRecords().length === 0", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.fillStyle = 'red'; ctx.save(); ctx.fillStyle = 'blue'; ctx.restore(); ctx.fillStyle === 'red'", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.strokeStyle = 'green'; ctx.font = '24px serif'; ctx.save(); ctx.strokeStyle = 'purple'; ctx.font = '12px sans-serif'; ctx.restore(); ctx.strokeStyle === 'green' && ctx.font === '24px serif'", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); typeof ctx.strokeText === 'function'", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.imageSmoothingEnabled === true", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.imageSmoothingEnabled = false; ctx.imageSmoothingEnabled === false", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); ctx.imageSmoothingEnabled = false; ctx.save(); ctx.imageSmoothingEnabled = true; ctx.restore(); ctx.imageSmoothingEnabled === false", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); const g = ctx.createLinearGradient(0, 0, 100, 0); g.addColorStop(0, 'red'); g.addColorStop(1, 'blue'); ctx.fillStyle = g; typeof ctx.fillRect === 'function'", "true"),
        ("const cv = document.createElement('canvas'); const ctx = cv.getContext('2d'); const g = ctx.createRadialGradient(50, 50, 0, 50, 50, 50); g.addColorStop(0, 'white'); g.addColorStop(1, 'black'); ctx.fillStyle = g; ctx.fillRect(0, 0, 100, 100); true", "true"),
    ];
    total += template_cases.len();
    for (src, expect) in template_cases {
        let mut rt = JsRuntime::new();
        rt.dom
            .borrow_mut()
            .build_from(&crate::os_lib::dom::parse_html(template_html));
        match rt.eval(src) {
            Ok(v) if &v.to_js_string() == expect => passed += 1,
            Ok(v) => crate::println!(
                "JS_SELFTEST FAIL: Template test `{}` => `{}` (want `{}`)",
                src,
                v.to_js_string(),
                expect
            ),
            Err(e) => crate::println!("JS_SELFTEST ERR:  Template test `{}` => {}", src, e),
        }
    }

    (passed, total)
}