atmos/os_lib/js/interp/

calls.rs

// 分割: interp.rs の `impl Interp` から機械的に移動（2026-07-16 リファクタ フェーズ5）。
// ロジック不変。メソッド可視性のみ pub(crate) へ昇格（別モジュールの impl Interp
// からの self 呼び出しのため）。impl ブロックは型 Interp に自動で結合する。
use super::*;

/// 診断用の関数名（`name`、関数定義の名前、`a.b=function(){}` の `~b`、無ければ `<anonymous>`）。
pub(crate) fn func_diag_name(func: &Value) -> String {
    match func {
        Value::Object(o) => {
            let b = o.borrow();
            b.props
                .get("name")
                .map(|v| v.to_js_string())
                .filter(|n| !n.is_empty())
                .or_else(|| match &b.kind {
                    ObjKind::Function(fd) if !fd.name.is_empty() => Some(fd.name.clone()),
                    _ => None,
                })
                .or_else(|| b.props.get("_diag_name").map(|v| alloc::format!("~{}", v.to_js_string())))
                .unwrap_or_else(|| String::from("<anonymous>"))
        }
        _ => String::from("<anonymous>"),
    }
}

impl Interp {
    pub(crate) fn eval_call(
        &mut self,
        callee: &Expression,
        arguments: &[Expression],
        optional: bool,
        scope: &Rc<RefCell<Scope>>,
        this: &Value,
    ) -> EvalResult {
        // super(...): 基底クラスのコンストラクタを現在の this で呼ぶ。
        if matches!(callee, Expression::Super) {
            let sc = self.super_ctor(scope)?;
            let args = self.eval_arguments(arguments, scope, this)?;
            return self.call_value(&sc, this.clone(), &args);
        }
        // super.method(...): 基底プロトタイプのメソッドを現在の this で呼ぶ。
        if let Expression::Member {
            object, property, ..
        } = callee
        {
            if matches!(**object, Expression::Super) {
                let sp = self.super_proto(scope)?;
                let f = self.get_property(&sp, property)?;
                let args = self.eval_arguments(arguments, scope, this)?;
                return self.call_value(&f, this.clone(), &args);
            }
        }
        // this の決定: メンバ/添字呼出なら receiver。オブジェクト側のオプショナルチェイン
        // (`a?.b.c()` 等)の短絡は `resolve_callee` 内で検知される。
        let (func, call_this, broke) = self.resolve_callee(callee, scope, this)?;
        if broke {
            return Ok(Value::Undefined);
        }
        if optional && matches!(func, Value::Undefined | Value::Null) {
            return Ok(Value::Undefined);
        }
        let args = self.eval_arguments(arguments, scope, this)?;
        // 【2026-10-16】呼べない値なら、呼び出し式を添えた TypeError にする（V8 と同じ
        // `a.b is not a function`）。従来は `call_value_inner` の「not a function: object」
        // だけで、どの呼び出しか分からず実サイトの JS_ERR を追えなかった。
        let callable = match &func {
            Value::Object(o) => o.borrow().is_callable(),
            _ => false,
        };
        if !callable {
            let desc = super::properties::describe_expr(callee);
            return Err(self.type_error(alloc::format!("{} is not a function", desc)));
        }
        self.call_value(&func, call_this, &args)
    }

    /// `Call` の callee を this 束縛込みで解決する（`super`/`super.method` は呼出元
    /// `eval_call` で先に処理済みのためここには来ない）。戻り値は
    /// `(関数, call_this, 途中で ?. 短絡したか)`。`object`/`callee` 側は
    /// `eval_chain_object` を再帰的に使うため、`a?.b.c()` のように途中で短絡した場合は
    /// 以降のプロパティアクセス/引数評価/呼出を一切行わずチェーン全体が `undefined` になる
    /// （ECMA-262 の OptionalChain セマンティクス。以前は最初の `?.` の直近1段しか
    /// 短絡せず、後続のアクセスで `TypeError` になっていた）。
    pub(crate) fn resolve_callee(
        &mut self,
        callee: &Expression,
        scope: &Rc<RefCell<Scope>>,
        this: &Value,
    ) -> Result<(Value, Value, bool), Value> {
        match callee {
            Expression::Member {
                object,
                property,
                optional: mopt,
            } if !matches!(**object, Expression::Super) => {
                let (obj, broke) = self.eval_chain_object(object, scope, this)?;
                if broke {
                    return Ok((Value::Undefined, Value::Undefined, true));
                }
                if *mopt && matches!(obj, Value::Undefined | Value::Null) {
                    return Ok((Value::Undefined, Value::Undefined, true));
                }
                let f = self.get_property_of_expr(&obj, property, object)?;
                Ok((f, obj, false))
            }
            Expression::Index {
                object,
                index,
                optional: iopt,
            } => {
                let (obj, broke) = self.eval_chain_object(object, scope, this)?;
                if broke {
                    return Ok((Value::Undefined, Value::Undefined, true));
                }
                if *iopt && matches!(obj, Value::Undefined | Value::Null) {
                    return Ok((Value::Undefined, Value::Undefined, true));
                }
                let key = self.eval(index, scope, this)?;
                let f = self.get_property(&obj, &to_property_key(&key))?;
                Ok((f, obj, false))
            }
            _ => {
                let (f, broke) = self.eval_chain_object(callee, scope, this)?;
                Ok((f, Value::Undefined, broke))
            }
        }
    }

    /// `Member`/`Index`/`Call` の「object/callee」位置を短絡込みで評価する。戻り値の
    /// `bool` は「このサブチェーンのどこかで `?.` が短絡したか」。短絡時、値は常に
    /// `Value::Undefined`。グローバルな可変フラグではなく戻り値だけで伝播するため、
    /// 無関係な式の評価に短絡状態が漏れることが無い。`super`/`super.method` を含む
    /// `Call` は短絡セマンティクス対象外のため既存の `eval_call` にそのまま委譲する。
    pub(crate) fn eval_chain_object(
        &mut self,
        expr: &Expression,
        scope: &Rc<RefCell<Scope>>,
        this: &Value,
    ) -> Result<(Value, bool), Value> {
        match expr {
            Expression::Member {
                object,
                property,
                optional,
            } => {
                if matches!(**object, Expression::Super) {
                    let sp = self.super_proto(scope)?;
                    return Ok((self.get_property(&sp, property)?, false));
                }
                let (obj, broke) = self.eval_chain_object(object, scope, this)?;
                if broke {
                    return Ok((Value::Undefined, true));
                }
                if *optional && matches!(obj, Value::Undefined | Value::Null) {
                    return Ok((Value::Undefined, true));
                }
                Ok((self.get_property(&obj, property)?, false))
            }
            Expression::Index {
                object,
                index,
                optional,
            } => {
                let (obj, broke) = self.eval_chain_object(object, scope, this)?;
                if broke {
                    return Ok((Value::Undefined, true));
                }
                if *optional && matches!(obj, Value::Undefined | Value::Null) {
                    return Ok((Value::Undefined, true));
                }
                let key = self.eval(index, scope, this)?;
                Ok((self.get_property(&obj, &to_property_key(&key))?, false))
            }
            Expression::Call {
                callee,
                arguments,
                optional,
            } => {
                let involves_super = matches!(**callee, Expression::Super)
                    || matches!(&**callee, Expression::Member { object, .. } if matches!(**object, Expression::Super));
                if involves_super {
                    return Ok((self.eval(expr, scope, this)?, false));
                }
                let (func, call_this, broke) = self.resolve_callee(callee, scope, this)?;
                if broke {
                    return Ok((Value::Undefined, true));
                }
                if *optional && matches!(func, Value::Undefined | Value::Null) {
                    return Ok((Value::Undefined, true));
                }
                let args = self.eval_arguments(arguments, scope, this)?;
                Ok((self.call_value(&func, call_this, &args)?, false))
            }
            _ => Ok((self.eval(expr, scope, this)?, false)),
        }
    }

    /// 呼出引数を評価し、スプレッド `...x` を展開した Vec を返す。
    pub(crate) fn eval_arguments(
        &mut self,
        arguments: &[Expression],
        scope: &Rc<RefCell<Scope>>,
        this: &Value,
    ) -> Result<Vec<Value>, Value> {
        let mut args = Vec::with_capacity(arguments.len());
        for a in arguments {
            if let Expression::Spread(inner) = a {
                let v = self.eval(inner, scope, this)?;
                let items = self.iter_to_vec(&v);
                args.extend(items);
            } else {
                args.push(self.eval(a, scope, this)?);
            }
        }
        Ok(args)
    }

    pub(crate) fn eval_new(
        &mut self,
        callee: &Expression,
        arguments: &[Expression],
        scope: &Rc<RefCell<Scope>>,
        this: &Value,
    ) -> EvalResult {
        let func = self.eval(callee, scope, this)?;
        let args = self.eval_arguments(arguments, scope, this)?;
        // Proxy: construct トラップがあれば呼ぶ。無ければ target を new する。
        let proxy = match &func {
            Value::Object(o) => match &o.borrow().kind {
                ObjKind::Proxy { target, handler } => Some((target.clone(), handler.clone())),
                _ => None,
            },
            _ => None,
        };
        if let Some((target, handler)) = proxy {
            let trap = handler.borrow().props.get("construct").cloned();
            if let Some(trap) =
                trap.filter(|t| matches!(t, Value::Object(f) if f.borrow().is_callable()))
            {
                let arg_arr = Value::Object(Obj::array(args.clone()));
                let targs = [
                    Value::Object(target),
                    arg_arr,
                    Value::Object(handler.clone()),
                ];
                return self.call_value(&trap, Value::Object(handler), &targs);
            }
            return self.construct_object(&Value::Object(target), &args);
        }
        self.construct_object(&func, &args)
    }

    /// `new` の本体: インスタンスを生成しコンストラクタを呼ぶ。
    pub fn construct_value(&mut self, func: &Value, args: &[Value]) -> EvalResult {
        self.construct_object(func, args)
    }

    pub(crate) fn construct_object(&mut self, func: &Value, args: &[Value]) -> EvalResult {
        self.construct_with_target(func, args, func)
    }

    /// `new` / `Reflect.construct(func, args, new_target)`。インスタンスの原型は
    /// `new_target.prototype`（仕様の OrdinaryCreateFromConstructor）。
    pub(crate) fn construct_with_target(&mut self, func: &Value, args: &[Value], new_target: &Value) -> EvalResult {
        // 束縛済み関数の `new` は、束縛した this を無視し、束縛引数を前に足して元の関数を
        // `new` する（仕様の [[Construct]]）。【2026-10-17】従来は束縛関数自身（prototype
        // 無し）からインスタンスを作り、元の関数を束縛 this（null）で呼んでいたため、
        // ES5 の定番 `new (Function.prototype.bind.apply(C, [null].concat(args)))` が
        // メソッドの無いオブジェクトを返していた（YouTube の DI コンテナ）。
        if let Value::Object(fo) = func {
            let bound = match &fo.borrow().kind {
                ObjKind::Bound { target, bound_args, .. } => Some((target.clone(), bound_args.clone())),
                _ => None,
            };
            if let Some((target, mut all)) = bound {
                all.extend_from_slice(args);
                let nt = match (new_target, func) {
                    (Value::Object(a), Value::Object(b)) if Rc::ptr_eq(a, b) => target.clone(),
                    _ => new_target.clone(),
                };
                return self.construct_with_target(&target, &all, &nt);
            }
        }
        // カスタム要素のクラス（`HTMLElement` を継承）なら、this は DOM 要素のハンドル。
        if let Some(proto) = self.element_class_proto(new_target) {
            let (idx, fresh) = self.ce_construct_target(new_target, proto)?;
            let inst = Value::Object(Obj::dom(idx));
            if fresh {
                self.ce_stack.push((idx, new_target.clone()));
            }
            self.pending_new_target = Some(new_target.clone());
            let ret = self.call_value(func, inst.clone(), args);
            if fresh {
                self.ce_stack.pop();
            }
            return match ret? {
                r @ Value::Object(_) => Ok(r),
                _ => Ok(inst),
            };
        }
        // インスタンスを生成し、コンストラクタの prototype を proto に設定（メソッド解決用）。
        let inst_obj = Obj::plain();
        if let Value::Object(fo) = new_target {
            if let Some(Value::Object(p)) = fo.borrow().props.get("prototype") {
                inst_obj.borrow_mut().proto = Some(p.clone());
            }
        }
        let inst = Value::Object(inst_obj);
        // `new.target` はこの呼び出し先関数（コンストラクタ自身）。`call_value_inner` が
        // 消費してスタックへ push する（`super(...)` は construct_object を介さず直接
        // call_value を呼ぶため、基底クラスのコンストラクタ内では `new.target` が
        // undefined になる既知の簡略化。実用上最も一般的な「コンストラクタ先頭での
        // `new.target` チェック」は正しく動作する）。
        self.pending_new_target = Some(new_target.clone());
        let ret = self.call_value(func, inst.clone(), args)?;
        match ret {
            Value::Object(_) => Ok(ret),
            _ => Ok(inst),
        }
    }

    /// 関数値を呼び出す。
    pub fn call_value(&mut self, func: &Value, this: Value, args: &[Value]) -> EvalResult {
        self.depth += 1;
        // 呼び出しが深すぎる（回数・ネイティブスタックの使用量）なら、ブラウザと同じく捕捉可能な
        // RangeError を投げる。【2026-10-17】従来は回数上限 400 でスクリプト全体を打ち切っており、
        // スタック使用量も見ていなかった（起動スレッドの 64 KiB スタックがあふれて BSS を壊した）。
        let sp = super::current_sp();
        if sp < self.stack_limit.0.saturating_sub(super::JS_STACK_MARGIN) || sp > self.stack_limit.1 {
            self.stack_limit = super::js_stack_window();
        }
        let used = self.stack_limit.1.saturating_sub(sp);
        if self.depth > self.max_depth || sp < self.stack_limit.0 {
            static N: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
            if N.fetch_add(1, core::sync::atomic::Ordering::Relaxed) < 5 {
                let top: Vec<&str> = self.call_names.iter().rev().take(16).map(|s| s.as_str()).collect();
                crate::warn!(
                    "[JSPROF] call stack exceeded thread={:?} depth={} stack={}KB (steps={}) top={:?}",
                    crate::kernel::scheduler::get_current_process_name(),
                    self.depth,
                    used / 1024,
                    self.steps,
                    top
                );
            }
            self.depth -= 1;
            return Err(self.range_error("Maximum call stack size exceeded"));
        }
        // 例外の発生箇所を示すため、呼び出し中の関数名を積む（深さ上限と同じく有限）。
        let name = func_diag_name(func);
        self.call_names.push(name);
        self.tmp_bodies.push(match func { Value::Object(o) => match &o.borrow().kind { ObjKind::Function(fd) => Some(fd.body.clone()), _ => None }, _ => None }); // TMPAPPLY
        // 循環ゴミの回収（実行の途中でも安全。`cycle_gc` 参照）。
        if crate::os_lib::js::cycle_gc::should_collect() {
            let _ = crate::os_lib::js::cycle_gc::maybe_collect();
        }
        let result = self.call_value_inner(func, this, args);
        self.process_ce_reactions();
        self.call_names.pop();
        self.tmp_bodies.pop(); // TMPAPPLY
        self.depth -= 1;
        result
    }

    /// イベントリスナ・タイマコールバック・オブザーバ通知など、
    /// **呼び出し元へ例外を返せない場所**からの関数呼び出し。
    ///
    /// 【2026-07-28】これらは従来 `let _ = self.call_value(...)` と書かれており、
    /// ハンドラ内で投げられた例外はコンソールにもログにも現れず完全に消えていた
    /// （「ボタンを押しても何も起きない」だけが症状として残る）。ブラウザ同様、
    /// 捕捉されなかった例外は必ず報告する。
    pub fn call_listener(
        &mut self,
        func: &Value,
        this: Value,
        args: &[Value],
        context: &str,
    ) -> bool {
        match self.call_value(func, this, args) {
            Ok(_) => true,
            Err(thrown) => {
                self.report_uncaught(context, &thrown);
                false
            }
        }
    }

    /// 捕捉されなかった例外を、ページのコンソール出力とシリアルログの両方へ出す。
    pub fn report_uncaught(&mut self, context: &str, thrown: &Value) {
        let mut repr = thrown.to_js_string();
        // 【2026-10-18】Error 以外のオブジェクト（`[object Object]`）は中身が分からないので、
        // プロパティを数段まで添える（YouTube の `_.oj` は原因を `args[0]` に入れる）。
        if repr == "[object Object]" {
            repr = alloc::format!("[object Object] {}", describe_thrown(thrown, 3));
        }
        let line = crate::os_lib::js::uncaught::format_uncaught(context, &repr);
        crate::warn!("[JS] {}", line);
        self.out.push_str(&line);
        self.out.push('\n');
    }

    /// element.dispatchEvent から呼ぶ Interp 内ディスパッチ。JsRuntime 版と同じ
    /// capture→target→bubble の3フェーズ・once・stopPropagation を再現するが、
    /// リスナは self.call_value で同一 Interp 上で実行する。戻り値: (発火したか, defaultPrevented)。
    pub fn dispatch_event_in_interp(
        &mut self,
        node_idx: usize,
        event_type: &str,
        extra: &[(String, Value)],
    ) -> (bool, bool) {
        // 伝播パス（target→祖先）。
        let path = {
            let dom = self.dom.borrow();
            let mut path = alloc::vec![node_idx];
            let mut cur = node_idx;
            let mut guard = 0;
            while let Some(p) = dom.nodes.get(cur).and_then(|n| n.parent) {
                path.push(p);
                cur = p;
                guard += 1;
                if guard > dom.nodes.len() {
                    break;
                }
            }
            path
        };
        let any = path
            .iter()
            .any(|&n| self.dom.borrow().has_listener_on(n, event_type));
        // `document.addEventListener('click', fn)` のみが登録され、経路上の
        // どの DOM ノードにも直接のリスナが無いケース（要素側リスナ0件の
        // 純粋なイベント委譲）を早期 return で取りこぼさないよう、document
        // 側の汎用リスナ（`_listeners`）の有無も合わせて確認する（2026-07-16
        // 発見・実装。以前は `any` が false ならここで即座に `(false, false)`
        // を返しており、後段の document リスナ発火コードへ一切到達しなかった）。
        let doc_has_listener = {
            let doc_opt = self.global.borrow().vars.get("document").cloned();
            doc_opt
                .and_then(|d| super::super::builtins::event_target_listeners(&d))
                .and_then(|listeners| listeners.borrow().props.get(event_type).cloned())
                .is_some_and(|arr| match arr {
                    Value::Object(o) => matches!(&o.borrow().kind, ObjKind::Array(items) if !items.is_empty()),
                    _ => false,
                })
        };
        let on_attr_name = alloc::format!("on{}", event_type);
        // 【2026-07-23 発見・修正】`Obj::dom(n)`は呼び出す度に新規生成される使い捨ての
        // ラッパーオブジェクトのため、`element.onchange = fn`で書き込まれた関数値は
        // `dom_set_property`が書いた先の`Obj::dom(n)`インスタンスが破棄された瞬間に
        // 失われ、ここで`obj_prop`経由で新規生成した別インスタンスを読んでも常に
        // 見つからなかった（＝ハンドラ関数値が丸ごと発火しない静かなバグ）。
        // `DomBridge::on_handlers`（`listeners`と同じくDOM構造体側の永続ストレージ）
        // から読む。
        let has_on_handler = path.iter().any(|&n| {
            if self.dom.borrow().get_on_handler(n, &on_attr_name).is_some() {
                return true;
            }
            self.dom.borrow().get_attr(n, &on_attr_name).is_some()
        });
        if !any && !doc_has_listener && !has_on_handler {
            return (false, false);
        }

        // `bubbles` を `extra` から読む（`Event`/`CustomEvent` から転送された実値。
        // 無ければ内部発火イベント向けの既定値として `true` を使う）。以前はここを
        // 一切見ずバブリング段階を常に無条件で全祖先まで辿っていたため、
        // `new CustomEvent('x', {bubbles: false})` を dispatch しても祖先の
        // リスナーが発火してしまう仕様違反バグだった（capture 段階は仕様上
        // `bubbles` に関わらず常に祖先を辿るため、そちらは変更しない）。
        let bubbles = extra
            .iter()
            .find(|(k, _)| k == "bubbles")
            .map(|(_, v)| v.truthy())
            .unwrap_or(true);
        let composed: Vec<Value> = path.iter().map(|&n| Value::Object(Obj::dom(n))).collect();
        let target = Value::Object(Obj::dom(node_idx));
        let ev = Obj::plain();
        {
            let mut e = ev.borrow_mut();
            e.props.insert(String::from("type"), Value::str(event_type));
            e.props.insert(String::from("target"), target.clone());
            e.props.insert(String::from("bubbles"), Value::Bool(true));
            // `cancelable` が一切読まれておらず、`{cancelable: false}` で構築した
            // イベントでも `preventDefault()` が常に効いてしまう仕様違反バグだった。
            // 内部発火（click/submit 等）は `extra` が空のまま呼ばれ続けており、
            // それらは「妨害可能」という既存の挙動に依存しているため、`bubbles`
            // と同じく既定値は `true`（後段の `extra` ループが明示指定時のみ上書き）。
            e.props.insert(String::from("cancelable"), Value::Bool(true));
            // `isTrusted` が丸ごと未対応だった。仕様上、スクリプトから発火した
            // イベント（`dispatchEvent()`・内部シミュレートの `.click()` 等）は
            // 常に `false`（実ユーザー入力由来のイベントのみ `true`。この処理系に
            // その区別自体が無いため常に `false` で問題ない）。読み取り専用の
            // 定数のため `extra` での上書きは考慮しない。
            e.props.insert(String::from("isTrusted"), Value::Bool(false));
            e.props
                .insert(String::from("eventPhase"), Value::Number(0.0));
            e.props
                .insert(String::from("defaultPrevented"), Value::Bool(false));
            // `timeStamp` が丸ごと未対応で常に `undefined` だった（このエンジン
            // 全体に存在しない機能だった。`EventTarget` 経路にも同時に追加済み）。
            e.props.insert(
                String::from("timeStamp"),
                Value::Number(super::super::builtins::next_perf_timestamp()),
            );
            // レガシー DOM Level 0 の `returnValue`/`cancelBubble`/`srcElement`
            // が丸ごと未対応だった。`srcElement` は `target` と同じ値の別名。
            e.props.insert(String::from("returnValue"), Value::Bool(true));
            e.props.insert(String::from("cancelBubble"), Value::Bool(false));
            e.props.insert(String::from("srcElement"), target.clone());
            e.props.insert(
                String::from("_composedPath"),
                Value::Object(Obj::array(composed)),
            );
            for (k, v) in extra {
                e.props.insert(k.clone(), v.clone());
            }
            e.props.insert(
                String::from("preventDefault"),
                Value::Object(Obj::native("preventDefault", |_, this, _| {
                    if let Value::Object(o) = &this {
                        let cancelable = o
                            .borrow()
                            .props
                            .get("cancelable")
                            .map(|v| v.truthy())
                            .unwrap_or(true);
                        if cancelable {
                            let mut b = o.borrow_mut();
                            b.props
                                .insert(String::from("defaultPrevented"), Value::Bool(true));
                            // レガシー DOM Level 0 の `event.returnValue`
                            // （`preventDefault()` と等価の意味を持つべきだが
                            // 丸ごと未対応で常に `undefined` だった）を追従させる。
                            b.props.insert(String::from("returnValue"), Value::Bool(false));
                        }
                    }
                    Ok(Value::Undefined)
                })),
            );
            e.props.insert(
                String::from("stopPropagation"),
                Value::Object(Obj::native("stopPropagation", |_, this, _| {
                    if let Value::Object(o) = &this {
                        let mut b = o.borrow_mut();
                        b.props
                            .insert(String::from("_stop"), Value::Bool(true));
                        // レガシー DOM Level 0 の `event.cancelBubble`（同じく
                        // 丸ごと未対応だった）を追従させる。
                        b.props.insert(String::from("cancelBubble"), Value::Bool(true));
                    }
                    Ok(Value::Undefined)
                })),
            );
            e.props.insert(
                String::from("stopImmediatePropagation"),
                Value::Object(Obj::native("stopImmediatePropagation", |_, this, _| {
                    if let Value::Object(o) = &this {
                        let mut b = o.borrow_mut();
                        b.props.insert(String::from("_stop"), Value::Bool(true));
                        b.props
                            .insert(String::from("_stopImmediate"), Value::Bool(true));
                        b.props.insert(String::from("cancelBubble"), Value::Bool(true));
                    }
                    Ok(Value::Undefined)
                })),
            );
            e.props.insert(
                String::from("composedPath"),
                Value::Object(Obj::native("composedPath", |_, this, _| {
                    if let Value::Object(o) = &this {
                        if let Some(p) = o.borrow().props.get("_composedPath") {
                            return Ok(p.clone());
                        }
                    }
                    Ok(Value::Object(Obj::array(Vec::new())))
                })),
            );
        }

        let mut steps: Vec<(usize, bool, f64)> = Vec::new();
        for &n in path.iter().skip(1).rev() {
            steps.push((n, true, 1.0));
        }
        steps.push((node_idx, true, 2.0));
        steps.push((node_idx, false, 2.0));
        if bubbles {
            for &n in path.iter().skip(1) {
                steps.push((n, false, 3.0));
            }
        }

        let mut fired = false;
        let mut to_remove: Vec<u64> = Vec::new();
        let mut propagation_stopped = false;
        // `document`のキャプチャフェーズリスナ（`{capture:true}`）を、DOMノードの
        // キャプチャフェーズ（`path`を祖先→target方向に辿る`steps`の`want_
        // capture=true`群）より先に発火する。`document`は`self.dom.nodes`の
        // 一員ではなく`path`祖先チェーンに含まれないため、キャプチャ方向では
        // 最も外側の仮想的な祖先として扱う（仕様上キャプチャフェーズは`bubbles`
        // に関わらず常に発火する。2026-07-16 発見・実装。詳細は
        // `fire_document_listeners`参照）。
        let (doc_cap_fired, doc_cap_stopped) = self.fire_document_listeners(&ev, event_type, true);
        if doc_cap_fired {
            fired = true;
        }
        if doc_cap_stopped {
            propagation_stopped = true;
        }
        if !propagation_stopped {
            'outer: for (n, want_capture, phase) in steps {
                let listeners = self
                    .dom
                    .borrow()
                    .listeners_phase(n, event_type, want_capture);
                let on_attr_name = alloc::format!("on{}", event_type);
                let node_this = Value::Object(Obj::dom(n));
                // 【2026-10-18】`on<type>` のハンドラにも currentTarget/eventPhase を渡す（従来は
                // addEventListener のリスナの直前でしか設定せず、onclick では undefined だった）。
                {
                    let mut e = ev.borrow_mut();
                    e.props.insert(String::from("currentTarget"), Value::Object(Obj::dom(n)));
                    e.props.insert(String::from("eventPhase"), Value::Number(phase));
                }
                if !want_capture {
                    // 上の`has_on_handler`と同じ理由で、使い捨ての`Obj::dom(n)`ではなく
                    // 永続ストレージ`DomBridge::on_handlers`から読む。
                    let on_handler = self
                        .dom
                        .borrow()
                        .get_on_handler(n, &on_attr_name)
                        .filter(|v| !matches!(v, Value::Undefined | Value::Null))
                        .or_else(|| self.dom.borrow().get_attr(n, &on_attr_name).map(Value::str));
                    if let Some(h) = on_handler {
                        match h {
                            Value::Object(_) => {
                                let ctx = alloc::format!("on{} handler", event_type);
                                self.call_listener(
                                    &h,
                                    node_this.clone(),
                                    &[Value::Object(ev.clone())],
                                    &ctx,
                                );
                                fired = true;
                            }
                            Value::Str(code) if !code.is_empty() => {
                                if let Err(thrown) = self.eval_source(&code) {
                                    let ctx = alloc::format!("on{} attribute", event_type);
                                    self.report_uncaught(&ctx, &thrown);
                                }
                                fired = true;
                            }
                            _ => {}
                        }
                    }
                }
                if listeners.is_empty() {
                    continue;
                }
                {
                    let mut e = ev.borrow_mut();
                    e.props
                        .insert(String::from("currentTarget"), Value::Object(Obj::dom(n)));
                    e.props
                        .insert(String::from("eventPhase"), Value::Number(phase));
                }
                let node_this = Value::Object(Obj::dom(n));
                for (func, once, id) in listeners {
                    let ctx = alloc::format!("{} listener", event_type);
                    self.call_listener(
                        &func,
                        node_this.clone(),
                        &[Value::Object(ev.clone())],
                        &ctx,
                    );
                    fired = true;
                    if once {
                        to_remove.push(id);
                    }
                    if ev
                        .borrow()
                        .props
                        .get("_stopImmediate")
                        .map(|v| v.truthy())
                        .unwrap_or(false)
                    {
                        propagation_stopped = true;
                        break 'outer;
                    }
                }
                if ev
                    .borrow()
                    .props
                    .get("_stop")
                    .map(|v| v.truthy())
                    .unwrap_or(false)
                {
                    propagation_stopped = true;
                    break 'outer;
                }
            }
        }
        if !to_remove.is_empty() {
            let mut dom = self.dom.borrow_mut();
            for id in to_remove {
                dom.remove_listener_by_id(id);
            }
        }
        // `document.addEventListener('click', fn)` 等の汎用イベント委譲パターン
        // （丸ごと未対応だった。`document` は `self.dom.nodes` の一員ではないため
        // 上記の祖先チェーン `path` に一切含まれず、`document`自身の`_listeners`
        // （`document_add_event_listener`が書き込む先）は従来一切読まれていな
        // かった。実DOMイベントのバブリングがトップまで到達し `stopPropagation()`
        // で止められていなければ、最後に `document` を仮想的な最終祖先として
        // 扱い、対応する（非capture）汎用リスナを発火する。2026-07-16
        // 発見・実装。capture版は関数冒頭の`fire_document_listeners(...,
        // true)`呼び出し参照）。
        if bubbles && !propagation_stopped {
            let (doc_bub_fired, _) = self.fire_document_listeners(&ev, event_type, false);
            if doc_bub_fired {
                fired = true;
            }
        }
        let default_prevented = ev
            .borrow()
            .props
            .get("defaultPrevented")
            .map(|v| v.truthy())
            .unwrap_or(false);
        (fired, default_prevented)
    }

    /// `document`の`_listeners[event_type]`のうち`capture`フラグが`want_capture`
    /// と一致するリスナを発火する。`document`は`self.dom.nodes`の一員では
    /// なくDOMの祖先チェーン`path`に含まれないため、キャプチャ方向では
    /// 最も外側、バブル方向では最後の仮想的な祖先として`dispatch_event_
    /// in_interp`の冒頭（キャプチャ）と末尾（バブル）から呼ばれる
    /// （2026-07-16新設。`event_target_dispatch_event`の発火ループと同型の
    /// ロジックだが、`document`用にターゲット/フェーズ番号を差し替えている）。
    /// 戻り値は `(1件でも発火したか, stopPropagation/stopImmediatePropagation
    /// で打ち切られたか)`。
    fn fire_document_listeners(
        &mut self,
        ev: &super::super::value::ObjRef,
        event_type: &str,
        want_capture: bool,
    ) -> (bool, bool) {
        let mut fired = false;
        // `self.global.borrow()`の一時`Ref`を`if let`の被走査式に直接置くと、
        // 一時値ライフタイム延長でブロック終端まで生き続け、ブロック内の
        // `self.call_value`（`&mut self`要求）と借用が衝突してビルドが通ら
        // なくなる。ブロックで包んで明示的にドロップさせる。
        let doc_opt = {
            let g = self.global.borrow();
            g.vars.get("document").cloned()
        };
        let Some(Value::Object(doc)) = doc_opt else {
            return (false, false);
        };
        let doc_val = Value::Object(doc);
        let Some(listeners) = super::super::builtins::event_target_listeners(&doc_val) else {
            return (false, false);
        };
        let cbs: alloc::vec::Vec<Value> = match listeners.borrow().props.get(event_type) {
            Some(Value::Object(arr)) => match &arr.borrow().kind {
                ObjKind::Array(items) => items.clone(),
                _ => alloc::vec::Vec::new(),
            },
            _ => alloc::vec::Vec::new(),
        };
        let matching: alloc::vec::Vec<Value> = cbs
            .into_iter()
            .filter(|entry| super::super::builtins::event_target_listener_capture(entry) == want_capture)
            .collect();
        if matching.is_empty() {
            return (false, false);
        }
        {
            let mut e = ev.borrow_mut();
            e.props.insert(String::from("currentTarget"), doc_val.clone());
            e.props
                .insert(String::from("eventPhase"), Value::Number(if want_capture { 1.0 } else { 3.0 }));
        }
        for entry in matching {
            if super::super::builtins::event_target_listener_aborted(&entry) {
                continue;
            }
            let cb = super::super::builtins::event_target_listener_cb(&entry);
            let once = super::super::builtins::event_target_listener_once(&entry);
            let ctx = alloc::format!("{} listener (document)", event_type);
            self.call_listener(&cb, doc_val.clone(), &[Value::Object(ev.clone())], &ctx);
            fired = true;
            if once {
                if let Some(Value::Object(arr)) = listeners.borrow().props.get(event_type).cloned() {
                    if let ObjKind::Array(items) = &mut arr.borrow_mut().kind {
                        items.retain(|v| match (&super::super::builtins::event_target_listener_cb(v), &cb) {
                            (Value::Object(x), Value::Object(y)) => !Rc::ptr_eq(x, y),
                            _ => true,
                        });
                    }
                }
            }
            if ev
                .borrow()
                .props
                .get("_stopImmediate")
                .map(|v| v.truthy())
                .unwrap_or(false)
            {
                return (fired, true);
            }
        }
        let stopped = ev.borrow().props.get("_stop").map(|v| v.truthy()).unwrap_or(false);
        (fired, stopped)
    }

    pub(crate) fn call_value_inner(&mut self, func: &Value, this: Value, args: &[Value]) -> EvalResult {
        let obj = match func {
            Value::Object(o) => o.clone(),
            // 【2026-09-05】何が関数でなかったのかを出す。
            // 「not a function」だけでは、どの呼び出しか分からない。
            _ => {
                let d = alloc::format!("{}", func.to_js_string());
                // 【一時】直前のプロパティ参照の並びを添える。
                // `$` 自体なのか `.ready` なのかを区別するため。
                return Err(self.throw(alloc::format!("not a function: {}", d)));
            }
        };
        // Proxy: apply トラップがあれば呼ぶ。無ければ target を呼ぶ。
        let proxy = match &obj.borrow().kind {
            ObjKind::Proxy { target, handler } => Some((target.clone(), handler.clone())),
            _ => None,
        };
        if let Some((target, handler)) = proxy {
            let trap = handler.borrow().props.get("apply").cloned();
            if let Some(trap) =
                trap.filter(|t| matches!(t, Value::Object(f) if f.borrow().is_callable()))
            {
                let arg_arr = Value::Object(Obj::array(args.to_vec()));
                let targs = [Value::Object(target), this, arg_arr];
                return self.call_value(&trap, Value::Object(handler), &targs);
            }
            return self.call_value(&Value::Object(target), this, args);
        }
        // `Function.prototype.bind()` が返す束縛済み関数: `bound_this` を this に固定し、
        // 束縛済み引数 `bound_args` の後ろに実引数 `args` を連結して `target` を呼ぶ
        // （呼び出し側が渡す `this` は spec 通り無視する）。
        let bound = match &obj.borrow().kind {
            ObjKind::Bound {
                target,
                bound_this,
                bound_args,
            } => Some((target.clone(), bound_this.clone(), bound_args.clone())),
            _ => None,
        };
        if let Some((target, bound_this, bound_args)) = bound {
            let mut combined = bound_args;
            combined.extend_from_slice(args);
            return self.call_value(&target, bound_this, &combined);
        }
        // kind を取り出す（借用を跨がないようクローン）。
        let kind = {
            let b = obj.borrow();
            match &b.kind {
                ObjKind::Function(fd) => CallKind::User(fd.clone()),
                ObjKind::Native { func, .. } => CallKind::Native(*func),
                ObjKind::Resolver { state, reject } => CallKind::Resolver(state.clone(), *reject),
                // 呼べないオブジェクトの種別を出す（配列なのか素の
                // オブジェクトなのかで原因の見当が変わる）。
                other => {
                    let kind_name = match other {
                        ObjKind::Array(_) => "array",
                        ObjKind::Plain => "object",
                        ObjKind::DomElement(_) => "dom element",
                        ObjKind::Host(_) => "host object",
                        _ => "other",
                    };
                    return Err(self.throw(alloc::format!(
                        "not a function: {} (呼べない種別)",
                        kind_name
                    )));
                }
            }
        };
        match kind {
            CallKind::Native(f) => f(self, this, args),
            CallKind::Resolver(state, reject) => {
                let arg = args.first().cloned().unwrap_or(Value::Undefined);
                if reject {
                    self.promise_reject(&state, arg);
                } else {
                    self.promise_resolve(&state, arg);
                }
                Ok(Value::Undefined)
            }
            CallKind::User(fd) => {
                // `new.target`: アロー関数以外の呼び出し毎に push/pop する（アローは
                // `this` と同様に周囲のスコープからレキシカルに継承するため対象外）。
                // `construct_object()` が `new` 経由の呼び出し直前に `pending_new_target`
                // をセットする。早期 return（`?`）を挟んでもスタックの対応が崩れないよう、
                // 本体の実行を別メソッドへ切り出し、push/pop はこの呼び出しの外側で行う。
                let nt = self.pending_new_target.take().unwrap_or(Value::Undefined);
                let pushed = !fd.is_arrow;
                if pushed {
                    self.new_target_stack.push(nt);
                }
                let result = self.call_user_function(fd, this, args, func.clone());
                if pushed {
                    self.new_target_stack.pop();
                }
                result
            }
        }
    }

    pub(crate) fn call_user_function(
        &mut self,
        fd: FunctionData,
        this: Value,
        args: &[Value],
        callee: Value,
    ) -> EvalResult {
        // 非 strict の関数では this が undefined/null ならグローバルオブジェクト（window）。
        // 【2026-10-17】従来は常に undefined のままで、YouTube の player（base.js）の
        // `(function(g){var window=this;…})(_yt_player)` で window が undefined になっていた。
        let this = if !fd.is_arrow && !fd.body.strict && matches!(this, Value::Undefined | Value::Null) {
            self.global.borrow().vars.get("window").cloned().unwrap_or(Value::Undefined)
        } else {
            this
        };
        {
                let call_scope = Scope::child(fd.closure.clone());
                for (i, p) in fd.params.iter().enumerate() {
                    if p.is_rest {
                        // レスト引数: 残余を配列束縛。
                        let rest_args: Vec<Value> =
                            args.get(i..).map(|s| s.to_vec()).unwrap_or_default();
                        self.bind_pattern(
                            &p.pattern,
                            Value::Object(Obj::array(rest_args)),
                            &call_scope,
                            &this,
                        )?;
                        break;
                    }
                    let mut v = args.get(i).cloned().unwrap_or(Value::Undefined);
                    // デフォルト引数: 実引数が undefined のとき評価。
                    if matches!(v, Value::Undefined) {
                        if let Some(def) = &p.default {
                            v = self.eval(def, &call_scope, &this)?;
                        }
                    }
                    self.bind_pattern(&p.pattern, v, &call_scope, &this)?;
                }
                let use_this = if fd.is_arrow {
                    fd.bound_this
                        .as_ref()
                        .map(|b| (**b).clone())
                        .unwrap_or(Value::Undefined)
                } else {
                    this
                };
                if fd.is_generator {
                    // generator は遅延評価: 本体は実行せず、関数定義と実引数/this を
                    // GenState に保存して Generator オブジェクトを返す。実際の本体実行は
                    // .next()/for-of/spread での resume 時に replay 方式で行う。
                    return Ok(Value::Object(Obj::generator(GenState {
                        func: fd.clone(),
                        args: args.to_vec(),
                        this: use_this,
                        sent: Vec::new(),
                        started: false,
                        done: false,
                        returned: Value::Undefined,
                    })));
                }
                let stmts = fd.body.stmts();
                // arguments 配列。`.callee`（Annex B。無名関数の自己再帰呼び出し
                // イディオム `arguments.callee` で今も使われる）が丸ごと未対応
                // だったため、呼び出された関数自身への参照を追加する。
                // 【2026-10-19】アロー関数は自身の `arguments` を持たず（外側のスコープから継承）、
                // また通常の関数でも本体が `arguments` / `eval` を参照しない（98% 以上）なら
                // 確保しない。従来は全呼び出しで無条件に確保して `callee` を入れていたため、
                // バンドル最外の即時関数（`kevlar_base` 等）の `call_scope` に `arguments.callee` が
                // 残り、内側の全クロージャから最外の関数と構文木が生きたまま握られていた。
                if !fd.is_arrow && fd.body.uses_arguments(&stmts) {
                    let arguments_obj = Obj::array(args.to_vec());
                    arguments_obj.borrow_mut().props.insert("callee".into(), callee);
                    scope_declare(&call_scope, "arguments", Value::Object(arguments_obj));
                }
                if fd.is_async {
                    // async 関数は同期実行し、結果/例外を Promise に包んで返す
                    // （await はマイクロタスクを駆動して解決まで進める）。
                    let outcome = self.exec_statements(&stmts, &call_scope, &use_this);
                    let pstate = Rc::new(RefCell::new(PromiseState::pending()));
                    match outcome {
                        Ok(Completion::Return(v)) => self.promise_resolve(&pstate, v),
                        Ok(_) => self.promise_resolve(&pstate, Value::Undefined),
                        Err(e) => {
                            if self.aborted {
                                return Err(e);
                            }
                            self.promise_reject(&pstate, e);
                        }
                    }
                    return Ok(Value::Object(Obj::promise(pstate)));
                }
                match self.exec_statements(&stmts, &call_scope, &use_this)? {
                    Completion::Return(v) => Ok(v),
                    _ => Ok(Value::Undefined),
                }
        }
    }

    // ============ プロパティアクセス ============

}

/// 捕捉されなかった例外値の簡易な中身表示（`depth` 段まで。配列は先頭 4 要素）。
pub(crate) fn describe_thrown(v: &Value, depth: u32) -> String {
    match v {
        Value::Object(o) => {
            if depth == 0 {
                return String::from("{…}");
            }
            let b = o.borrow();
            if let ObjKind::Array(items) = &b.kind {
                let parts: Vec<String> = items.iter().take(4).map(|x| describe_thrown(x, depth - 1)).collect();
                return alloc::format!("[{}]", parts.join(", "));
            }
            let parts: Vec<String> = b
                .props
                .iter()
                .take(8)
                .map(|(k, x)| alloc::format!("{}={}", k, describe_thrown(x, depth - 1)))
                .collect();
            alloc::format!("{{{}}}", parts.join(", "))
        }
        other => other.to_js_string().chars().take(300).collect(),
    }
}