feat: 事件目标弱引用注册表加三方法加原型链

Cargo.lock

@@ -1160,7 +1160,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_builtins"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "chrono",
  "fast-float",
@@ -1185,7 +1185,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_bytecode"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "num-bigint",
  "oxide_log",
@@ -1193,7 +1193,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cfg"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_emit",
@@ -1204,7 +1204,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cli"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "ansi_term",
  "bumpalo",
@@ -1226,7 +1226,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_code_cache"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "lru",
  "oxide_bytecode",
@@ -1235,7 +1235,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_compiler"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1255,7 +1255,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_dce"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1269,7 +1269,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_emit"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "num-bigint",
  "oxc_allocator",
@@ -1284,7 +1284,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_engine"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1296,7 +1296,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_ir"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_log",
@@ -1305,7 +1305,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_kernel"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1319,7 +1319,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_liveness"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1331,7 +1331,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_log"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "tracing",
  "tracing-appender",
@@ -1340,7 +1340,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_parser"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxc_allocator",
  "oxc_ast",
@@ -1355,7 +1355,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_regalloc"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1371,7 +1371,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_runtime_api"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -1384,7 +1384,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_test262"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1402,7 +1402,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_types"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1415,7 +1415,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_vm"
-version = "0.14.8"
+version = "0.14.9"
 dependencies = [
  "bumpalo",
  "chrono",

Cargo.toml

@@ -23,7 +23,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.14.8"
+version = "0.14.9"
 edition = "2021"
 license = "MIT"
 rust-version = "1.80"

crates/oxide_builtins/src/event.rs

@@ -86,6 +86,56 @@ pub fn drop_event_native(obj: &mut JsObject) -> u64 {
     bytes
 }
 
+/// 读事件类型串（GC 字符串边）。非 Event 对象或无载荷盒返回 None。
+///
+/// 供派发路径（`dispatchEvent`）取事件类型串、intern 后查监听器。
+pub fn event_type_value(obj: &JsObject) -> Option<JsValue> {
+    let ptr = event_payload_ptr(obj)?;
+    if ptr.is_null() {
+        return None;
+    }
+    // SAFETY: ptr 指向有效载荷盒（构造期写入、释放时置空），只读字段。
+    Some(unsafe { &*ptr }.r#type)
+}
+
+/// 设派发目标与阶段：`target` / `current_target` 置 `target`、`event_phase` 置
+/// `phase`。非 Event 对象或无载荷盒时 no-op。
+///
+/// 供派发路径（`dispatchEvent`）在调用监听器前设目标与 AT_TARGET 阶段。
+pub fn event_set_dispatch(obj: &mut JsObject, target: JsValue, phase: u32) {
+    let Some(ptr) = event_payload_ptr(obj) else {
+        return;
+    };
+    if ptr.is_null() {
+        return;
+    }
+    // SAFETY: ptr 指向有效载荷盒，写入派发字段（无 GC 窗口）。
+    let inner = unsafe { &mut *ptr };
+    inner.target = target;
+    inner.current_target = target;
+    inner.event_phase = phase;
+}
+
+/// 读 `defaultPrevented` 标志。非 Event 对象或无载荷盒返回 None。
+pub fn event_default_prevented(obj: &JsObject) -> Option<bool> {
+    let ptr = event_payload_ptr(obj)?;
+    if ptr.is_null() {
+        return None;
+    }
+    // SAFETY: ptr 指向有效载荷盒，只读字段。
+    Some(unsafe { &*ptr }.default_prevented)
+}
+
+/// 读 `stopImmediatePropagation` 标志。非 Event 对象或无载荷盒返回 None。
+pub fn event_immediate_stopped(obj: &JsObject) -> Option<bool> {
+    let ptr = event_payload_ptr(obj)?;
+    if ptr.is_null() {
+        return None;
+    }
+    // SAFETY: ptr 指向有效载荷盒，只读字段。
+    Some(unsafe { &*ptr }.immediate_stopped)
+}
+
 /// 解析 this 为 Event 载荷盒共享引用：非 Event 对象或无载荷盒返回 None。
 ///
 /// # 注意事项
@@ -235,6 +285,40 @@ pub fn event_constructor<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     NativeResult::Ok(this_val)
 }
 
+/// 建一个 Event 载荷盒对象（type 为 `type_str`），返回对象指针。
+///
+/// 供交付路径（消息事件 / 错误事件）建真实 Event 盒，使 `dispatchEvent` 品牌守卫
+/// 通过。盒的 `target` / `currentTarget` 初始 null、`eventPhase` 初始 0（派发时设）；
+/// `[[Prototype]]` 指向 `Event.prototype`（`e instanceof Event` 成立）。
+///
+/// # 副作用
+/// - 新建一个 Event 盒对象（经 `alloc_object` 入对象表）。
+pub fn create_event_box<H: VmHost>(vm: &mut H, type_str: &str) -> *mut JsObject {
+    let type_js = vm.new_string(type_str);
+    let inner = Box::into_raw(Box::new(EventInner {
+        r#type: type_js,
+        target: JsValue::null(),
+        current_target: JsValue::null(),
+        event_phase: 0,
+        is_trusted: false,
+        bubbles: false,
+        cancelable: false,
+        default_prevented: false,
+        propagation_stopped: false,
+        immediate_stopped: false,
+        composed: false,
+    }));
+    let event_proto = JsValue::from_js_object(vm.builtin_proto(ProtoKind::EventProto));
+    let obj = JsObject::new_empty(EMPTY_SHAPE_ID, event_proto);
+    let ptr = vm.alloc_object(obj);
+    // SAFETY: ptr 是本函数刚 alloc_object 的对象，存活且本段无别名；native_fn 存
+    // 不透明 `Box<EventInner>` 指针，与 ArrayBuffer / RegExp 的类型化存储模式一致。
+    let event_obj = unsafe { &mut *ptr };
+    event_obj.type_tag = JsObject::OBJ_TYPE_EVENT;
+    event_obj.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(inner as *const ()) }));
+    ptr
+}
+
 /// `Event.prototype.type`：返回事件类型串。
 pub fn event_type_getter<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });

crates/oxide_builtins/src/event_target.rs

@@ -0,0 +1,255 @@
+//! EventTarget 行为面：`addEventListener` / `removeEventListener` / `dispatchEvent`
+//! 三原型方法。
+//!
+//! 监听器注册表是 per-realm 弱引用结构（目标对象裸指针为键、不保活），由 `VmHost`
+//! 的 `et_register` / `et_unregister` / `et_lookup` 三方法操作，GC sweep 按 mark 位
+//! 剪枝、full_reset 清表。注册表值（`EventTargetState`）持监听器回调的 GC 对象边，
+//! mark 期经根枚举标活（存活目标的回调随目标存活）。`ListenerEntry` /
+//! `EventTargetState` 类型落 `oxide_runtime_api`（trait 所在层，本 crate 依赖之）。
+
+use oxide_runtime_api::{ListenerEntry, NativeResult, VmHost};
+use oxide_types::value::JsValue;
+
+use crate::event;
+
+/// 解析 `addEventListener` / `removeEventListener` 的 options 参数：布尔（capture）
+/// 或对象（once / capture，passive / signal 忽略）。返回 (capture, once)。
+///
+/// # 边界与前提
+/// - options 对象属性经 `ordinary_get` 读（getter 副作用与异常原值传播）。
+/// - 缺失或非对象时取缺省（capture=false, once=false）。
+fn parse_event_options<H: VmHost>(vm: &mut H, args: &[u8]) -> Result<(bool, bool), JsValue> {
+    let opt_val = if args.len() > 3 { vm.reg(args[3]) } else { JsValue::undefined() };
+    if opt_val.is_bool() {
+        return Ok((oxide_runtime_api::to_boolean(opt_val), false));
+    }
+    if !opt_val.is_object() {
+        return Ok((false, false));
+    }
+    let opt_ptr = opt_val.as_js_object_ptr();
+    // SAFETY: opt_val 已确认是对象值，借用即时消费。
+    let opt_obj = unsafe { &*opt_ptr };
+    let mut capture = false;
+    let mut once = false;
+    for (name, slot) in [("capture", &mut capture), ("once", &mut once)] {
+        let si = vm.perm_intern(name);
+        match vm.ordinary_get(opt_obj, si, opt_val) {
+            Ok(v) => *slot = oxide_runtime_api::to_boolean(v),
+            Err(_) => {
+                if let Some(exc) = vm.take_uncaught_value() {
+                    return Err(exc);
+                }
+                return Err(crate::error::create_type_error(vm, "Event options property getter failed"));
+            }
+        }
+    }
+    Ok((capture, once))
+}
+
+/// `EventTarget.prototype.addEventListener(type, callback, options)`。
+///
+/// # 步骤
+/// 1. this 解析为目标对象（非对象抛 TypeError）。
+/// 2. type 经完整 ToString 转串、intern 得 si；空串抛 SyntaxError。
+/// 3. callback 须为函数（首版不支持对象形 handleEvent，非函数抛 TypeError）。
+/// 4. options 是布尔（capture）或对象（once / capture，passive / signal 忽略）。
+/// 5. 重复登记（同 type + callback + capture）为 no-op；否则追加进注册表。
+///
+/// # 副作用
+/// - 写注册表（`et_register`）。
+pub fn event_target_add_event_listener<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    if !this_val.is_object() {
+        return NativeResult::Err(crate::error::create_type_error(vm, "addEventListener called on non-object"));
+    }
+    let this_ptr = this_val.as_js_object_ptr();
+
+    // type 经完整 ToString 转串（对象经 ToPrimitive，Symbol 抛 TypeError）。
+    let type_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
+    let type_str = match oxide_runtime_api::to_string_full(type_val, vm) {
+        Ok(s) => s,
+        Err(_) => {
+            if let Some(exc) = vm.take_uncaught_value() {
+                return NativeResult::Err(exc);
+            }
+            return NativeResult::Err(crate::error::create_type_error(
+                vm,
+                "Cannot convert event type to a string",
+            ));
+        }
+    };
+    if type_str.is_empty() {
+        return NativeResult::Err(crate::error::create_syntax_error(vm, "The provided type is empty"));
+    }
+    let type_si = vm.perm_intern(&type_str);
+
+    // callback 须为函数（首版不支持对象形 handleEvent）。
+    let callback = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
+    if !crate::iterator::is_callable(callback) {
+        return NativeResult::Err(crate::error::create_type_error(
+            vm,
+            "Event listener callback must be a function",
+        ));
+    }
+
+    // options：布尔（capture）或对象（once / capture）。
+    let (capture, once) = match parse_event_options(vm, args) {
+        Ok(co) => co,
+        Err(e) => return NativeResult::Err(e),
+    };
+
+    // 重复登记（同 type + callback + capture）为 no-op；否则追加。
+    let entry = ListenerEntry { type_si, callback, capture, once, is_attribute: false };
+    let existing = vm.et_lookup(this_ptr);
+    if existing.iter().any(|e| e.type_si == type_si && e.capture == capture && e.callback == callback) {
+        return NativeResult::Ok(JsValue::undefined());
+    }
+    vm.et_register(this_ptr, entry);
+    NativeResult::Ok(JsValue::undefined())
+}
+
+/// `EventTarget.prototype.removeEventListener(type, callback, options)`。
+///
+/// # 步骤
+/// 1. this 解析为目标对象（非对象抛 TypeError）。
+/// 2. type 经完整 ToString 转串、intern 得 si。
+/// 3. 按同 type + callback + capture 查条目移除（不存在为 no-op）。
+///
+/// # 副作用
+/// - 写注册表（`et_unregister`）。
+pub fn event_target_remove_event_listener<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    if !this_val.is_object() {
+        return NativeResult::Err(crate::error::create_type_error(vm, "removeEventListener called on non-object"));
+    }
+    let this_ptr = this_val.as_js_object_ptr();
+
+    // type 经完整 ToString 转串（与 addEventListener 同一 intern 口径）。
+    let type_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
+    let type_str = match oxide_runtime_api::to_string_full(type_val, vm) {
+        Ok(s) => s,
+        Err(_) => {
+            if let Some(exc) = vm.take_uncaught_value() {
+                return NativeResult::Err(exc);
+            }
+            return NativeResult::Err(crate::error::create_type_error(
+                vm,
+                "Cannot convert event type to a string",
+            ));
+        }
+    };
+    let type_si = vm.perm_intern(&type_str);
+
+    let callback = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
+    let (capture, _) = match parse_event_options(vm, args) {
+        Ok(co) => co,
+        Err(e) => return NativeResult::Err(e),
+    };
+    vm.et_unregister(this_ptr, type_si, callback, capture);
+    NativeResult::Ok(JsValue::undefined())
+}
+
+/// `EventTarget.prototype.dispatchEvent(event)`：同步派发事件，返回
+/// `!event.defaultPrevented`。
+///
+/// # 步骤
+/// 1. this 解析为目标对象（非对象抛 TypeError）。
+/// 2. event 品牌守卫（须为 Event 系对象），设 target / currentTarget 为 this、
+///    eventPhase 为 AT_TARGET（2）。
+/// 3. 取事件类型串、intern 得 si，查注册表取本对象该类型的监听器快照。
+/// 4. 逐个监听器调用（GC 根纪律：调用前钉事件与回调进寄存器，调用后重读载荷指针）；
+///    `once` 条目调用后移除；`stopImmediatePropagation` 截断循环。
+/// 5. 返回 `!event.defaultPrevented`。
+///
+/// # 边界与前提
+/// - 首版派发只在目标（无冒泡、无捕获阶段），监听器按登记序调用。
+/// - 监听器回调的异常原值上抛（不吞）。
+///
+/// # 副作用
+/// - 写事件载荷盒（target / currentTarget / eventPhase）；移除 `once` 条目。
+pub fn event_target_dispatch_event<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    if !this_val.is_object() {
+        return NativeResult::Err(crate::error::create_type_error(vm, "dispatchEvent called on non-object"));
+    }
+    let this_ptr = this_val.as_js_object_ptr();
+
+    // event 品牌守卫：须为 Event 系对象（首版仅 Event 标签，派生类由后续任务接入）。
+    let event_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
+    if !event_val.is_object() {
+        return NativeResult::Err(crate::error::create_type_error(vm, "dispatchEvent requires an Event"));
+    }
+    let event_ptr = event_val.as_js_object_ptr();
+    if event_ptr.is_null() {
+        return NativeResult::Err(crate::error::create_type_error(vm, "dispatchEvent requires an Event"));
+    }
+    // SAFETY: event_val 已确认是对象值，event_ptr 指向合法 JsObject。
+    let event_obj = unsafe { &*event_ptr };
+    if !event_obj.is_event_obj() {
+        return NativeResult::Err(crate::error::create_type_error(vm, "dispatchEvent requires an Event"));
+    }
+
+    // 设派发目标与阶段（AT_TARGET = 2）。
+    // SAFETY: event_obj 存活，无 GC 窗口。
+    unsafe {
+        event::event_set_dispatch(&mut *event_ptr, this_val, 2);
+    }
+
+    // 取事件类型串、intern 得 si，查注册表取监听器快照。
+    let type_val = match event::event_type_value(event_obj) {
+        Some(v) => v,
+        None => return NativeResult::Ok(JsValue::bool(true)),
+    };
+    let type_text = match vm.lookup_str(type_val) {
+        Some(t) => t,
+        None => return NativeResult::Ok(JsValue::bool(true)),
+    };
+    let type_si = vm.perm_intern(&type_text);
+    // 注册表按目标对象存全部监听器，此处按事件类型过滤（同型才派发）。
+    let listeners: Vec<ListenerEntry> = vm
+        .et_lookup(this_ptr)
+        .into_iter()
+        .filter(|e| e.type_si == type_si)
+        .collect();
+    if listeners.is_empty() {
+        return NativeResult::Ok(JsValue::bool(true));
+    }
+
+    // 逐个监听器调用（GC 根纪律：调用前钉事件与回调进寄存器，调用后重读载荷指针）。
+    for entry in &listeners {
+        // 钉事件对象与回调进返回寄存器（GC 根，防调用窗口内被回收）。
+        vm.set_reg(0, event_val);
+        vm.set_reg(1, entry.callback);
+        // 调用监听器（this = 目标，实参 = 事件）。异常原值上抛。
+        match vm.call_function_sync(entry.callback, this_val, &[event_val]) {
+            Ok(_) => {}
+            Err(_) => {
+                if let Some(exc) = vm.take_uncaught_value() {
+                    return NativeResult::Err(exc);
+                }
+                return NativeResult::Err(crate::error::create_type_error(vm, "Event listener threw"));
+            }
+        }
+        // 调用窗口后重读事件对象（窗口内可发生 GC，原地不搬移但重读守纪律）。
+        let event_val = vm.reg(0);
+        let event_ptr = event_val.as_js_object_ptr();
+        // SAFETY: event_val 是 Event 对象（品牌守卫已过），存活。
+        let event_obj = unsafe { &*event_ptr };
+        // once 条目调用后移除。
+        if entry.once {
+            vm.et_unregister(this_ptr, entry.type_si, entry.callback, entry.capture);
+        }
+        // stopImmediatePropagation 截断循环。
+        if event::event_immediate_stopped(event_obj) == Some(true) {
+            break;
+        }
+    }
+
+    // 返回 !event.defaultPrevented（末次调用窗口后重读载荷指针）。
+    let event_val = vm.reg(0);
+    let event_ptr = event_val.as_js_object_ptr();
+    // SAFETY: event_val 是 Event 对象（品牌守卫已过），存活。
+    let event_obj = unsafe { &*event_ptr };
+    let default_prevented = event::event_default_prevented(event_obj).unwrap_or(false);
+    NativeResult::Ok(JsValue::bool(!default_prevented))
+}

crates/oxide_builtins/src/lib.rs

@@ -36,6 +36,9 @@ pub mod error;
 pub mod eval;
 /// Event 基类实现（构造器、原型 getter 与传播方法，载荷盒与 GC 三自由函数族）。
 pub mod event;
+/// EventTarget 实现（addEventListener / removeEventListener / dispatchEvent 三原型
+/// 方法与 per-realm 弱引用监听器注册表）。
+pub mod event_target;
 /// Function 内置对象实现（call/apply/bind/toString）。
 pub mod function;
 /// 全局函数模块（URI 编解码与 Annex B 的 escape/unescape）。

crates/oxide_runtime_api/src/event_target.rs

@@ -0,0 +1,29 @@
+//! EventTarget 监听器注册表的数据类型：`ListenerEntry`（单条监听器登记）与
+//! `EventTargetState`（一个目标的监听器集合，注册表值）。
+//!
+//! 本类型落 `oxide_runtime_api`（`VmHost` trait 所在层）：`et_register` /
+//! `et_lookup` 的签名引用 `ListenerEntry`，而 trait 不依赖 `oxide_builtins`
+//! （依赖方向 `runtime_api ← builtins`），故类型须落在 trait 可引用的层。
+
+use oxide_types::value::JsValue;
+
+/// 单条监听器登记：事件类型 si、回调函数、捕获标志、once 标志、属性 handler 标志。
+///
+/// `type_si` 是事件类型串的 perm intern 下标（同型同回调同 capture 的重复登记为
+/// no-op）。`callback` 是回调函数（GC 对象边）。`is_attribute` 区分属性 handler
+/// （`onmessage` 等）与 `addEventListener` 登记（首版恒 false，属性 handler 由后续
+/// 任务接入）。
+#[derive(Clone, Debug)]
+pub struct ListenerEntry {
+    pub type_si: u32,
+    pub callback: JsValue,
+    pub capture: bool,
+    pub once: bool,
+    pub is_attribute: bool,
+}
+
+/// 一个 EventTarget 的监听器集合（per-realm 弱引用注册表的值）。
+#[derive(Clone, Debug, Default)]
+pub struct EventTargetState {
+    pub listeners: Vec<ListenerEntry>,
+}

crates/oxide_runtime_api/src/host.rs

@@ -8,6 +8,8 @@ use oxide_types::mem::P;
 use oxide_types::object::{Cell, JsObject, PropAttributes};
 use oxide_types::value::JsValue;
 
+use super::event_target::ListenerEntry;
+
 /// shape 节点只读投影：shape forge 节点字段的中立镜像（免跨 crate 引用具体类型）。
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct ShapeNode {
@@ -473,4 +475,26 @@ pub trait VmHost {
     /// - 列表元素为弱引用裸指针，调用方不得跨用户调用持有（GC 可释放
     ///   通道对象，须在下一次使用前重新查表校验）。
     fn bc_lookup(&self, name: &str) -> Vec<*mut JsObject>;
+
+    // EventTarget 监听器注册表（per-realm 弱引用，目标对象裸指针为键）
+    /// 把一条监听器登记追加到目标对象的注册表条目（无条目时新建）。
+    ///
+    /// # 边界与前提
+    /// - `target` 为登记时刻的目标对象指针（弱引用，不保活）；重复登记
+    ///   （同 type + callback + capture）由调用方保证不发生。
+    /// # 副作用
+    /// - 写注册表（内部可变）；`entry` 的 callback 是 GC 对象边，mark 期经根枚举标活。
+    fn et_register(&self, target: *mut JsObject, entry: ListenerEntry);
+    /// 从目标对象的注册表移除同 type + callback + capture 的监听器条目；
+    /// 不存在时 no-op。空集合条目随移除删除（不留空壳）。
+    ///
+    /// # 副作用
+    /// - 写注册表（内部可变）；幂等，重复移除不报错。
+    fn et_unregister(&self, target: *mut JsObject, type_si: u32, callback: JsValue, capture: bool);
+    /// 查目标对象的监听器条目列表（返回克隆；无条目为空列表）。
+    ///
+    /// # 边界与前提
+    /// - 列表元素含 callback 的 GC 对象边，调用方不得跨用户调用持有
+    ///   （GC 可回收目标对象，须在下一次使用前重新查表校验）。
+    fn et_lookup(&self, target: *mut JsObject) -> Vec<ListenerEntry>;
 }

crates/oxide_runtime_api/src/lib.rs

@@ -14,6 +14,8 @@
 mod coercion;
 /// 动态编译服务接口（`Vm` 经它解耦对编译器的直接依赖）。
 pub mod compiler_service;
+/// EventTarget 监听器注册表数据类型（`ListenerEntry` / `EventTargetState`）。
+pub mod event_target;
 /// builtins 依赖的 `VmHost` 能力面。
 mod host;
 /// builtin native 函数的三态返回值。
@@ -29,5 +31,6 @@ pub use coercion::{
     ToPrimitiveHint,
 };
 pub use compiler_service::CompilerService;
+pub use event_target::{EventTargetState, ListenerEntry};
 pub use host::{ProtoKind, ShapeNode, VmHost};
 pub use native_result::NativeResult;

crates/oxide_vm/src/bindings/bind_broadcast_channel.rs

@@ -85,9 +85,9 @@ pub fn bind_broadcast_channel(core: &Arc<KernelCore>, session: &KernelSession, g
         proto.bump_generation();
     }
 
-    // [[Prototype]] → Object.prototype（幂等，裸写槽）。
-    let object_proto_val = JsValue::from_js_object(world.object_proto.as_ptr() as *mut JsObject);
-    let _ = proto.set_proto(object_proto_val);
+    // [[Prototype]] → EventTarget.prototype（事件三方法经原型链可达；幂等，裸写槽）。
+    let et_proto_val = JsValue::from_js_object(world.event_target_proto.as_ptr() as *mut JsObject);
+    let _ = proto.set_proto(et_proto_val);
 
     // 原型方法：postMessage / close（每方法先 lookup_position 守卫）。
     let si_post_message = sf.intern("postMessage").0;

crates/oxide_vm/src/bindings/bind_event.rs

@@ -162,4 +162,39 @@ pub fn bind_event(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
             bind_accessor_getter(core, session, proto, name, fn_ptr);
         }
     }
+
+    // ---- 填 EventTarget 原型占位（无构造器，仅暴露原型与三方法）----
+    // 幂等：三方法经 lookup_position 守卫，[[Prototype]] 裸写槽幂等。
+    let et_proto_ptr = world.event_target_proto.as_ptr() as *mut JsObject;
+    let et_proto = unsafe { &mut *et_proto_ptr };
+    // [[Prototype]] → Object.prototype（幂等，裸写槽）。
+    let object_proto_val = JsValue::from_js_object(world.object_proto.as_ptr() as *mut JsObject);
+    let _ = et_proto.set_proto(object_proto_val);
+    // 三方法：addEventListener / removeEventListener / dispatchEvent（每方法先
+    // lookup_position 守卫）。
+    let si_add = sf.intern("addEventListener").0;
+    if sh.lookup_position(et_proto.shape_id(), si_add).is_none() {
+        apply_binding_table(
+            world,
+            et_proto,
+            core,
+            &[
+                (
+                    "addEventListener",
+                    oxide_builtins::event_target::event_target_add_event_listener::<crate::vm::Vm> as *const (),
+                    3,
+                ),
+                (
+                    "removeEventListener",
+                    oxide_builtins::event_target::event_target_remove_event_listener::<crate::vm::Vm> as *const (),
+                    3,
+                ),
+                (
+                    "dispatchEvent",
+                    oxide_builtins::event_target::event_target_dispatch_event::<crate::vm::Vm> as *const (),
+                    1,
+                ),
+            ],
+        );
+    }
 }

crates/oxide_vm/src/bindings/bind_message_channel.rs

@@ -85,9 +85,9 @@ pub fn bind_message_channel(core: &Arc<KernelCore>, session: &KernelSession, glo
         proto.bump_generation();
     }
 
-    // [[Prototype]] → Object.prototype（幂等，裸写槽）。
-    let object_proto_val = JsValue::from_js_object(world.object_proto.as_ptr() as *mut JsObject);
-    let _ = proto.set_proto(object_proto_val);
+    // [[Prototype]] → EventTarget.prototype（事件三方法经原型链可达；幂等，裸写槽）。
+    let et_proto_val = JsValue::from_js_object(world.event_target_proto.as_ptr() as *mut JsObject);
+    let _ = proto.set_proto(et_proto_val);
 
     // 原型方法：postMessage / close / start（每方法先 lookup_position 守卫）。
     let si_post_message = sf.intern("postMessage").0;

crates/oxide_vm/src/bindings/bind_worker.rs

@@ -75,8 +75,10 @@ pub fn bind_worker(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
         match sh.lookup_position(ctor.shape_id(), si_prototype) {
             Some(pos) if ctor.get_prop_at(pos).is_object() => ctor.get_prop_at(pos).as_js_object_ptr(),
             _ => {
-                let object_proto = world.object_proto.as_ptr() as *mut JsObject;
-                let proto = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(object_proto));
+                // Worker.prototype 的 [[Prototype]] 指向 EventTarget.prototype
+                // （事件三方法经原型链可达；EventTarget 无构造器，仅暴露原型）。
+                let et_proto = world.event_target_proto.as_ptr() as *mut JsObject;
+                let proto = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(et_proto));
                 let ptr = Box::into_raw(Box::new(proto));
                 world.track_leaked_object(ptr);
                 // 回填构造器 prototype 槽（描述符 { f,f,f }）。
@@ -145,6 +147,33 @@ pub fn bind_worker(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
             ],
         );
     }
+    // EventTarget 三方法直绑全局（worker realm 经 self === global 可达；全局原型链
+    // 是 Object.prototype，首版不改全局原型，三方法直绑全局等价可见）。幂等守卫。
+    let si_self_add = sf.intern("addEventListener").0;
+    if sh.lookup_position(global.shape_id(), si_self_add).is_none() {
+        apply_binding_table(
+            world,
+            global,
+            core,
+            &[
+                (
+                    "addEventListener",
+                    oxide_builtins::event_target::event_target_add_event_listener::<crate::vm::Vm> as *const (),
+                    3,
+                ),
+                (
+                    "removeEventListener",
+                    oxide_builtins::event_target::event_target_remove_event_listener::<crate::vm::Vm> as *const (),
+                    3,
+                ),
+                (
+                    "dispatchEvent",
+                    oxide_builtins::event_target::event_target_dispatch_event::<crate::vm::Vm> as *const (),
+                    1,
+                ),
+            ],
+        );
+    }
     // self 全局属性：值为 global 对象本身（worker realm 经 self === global 可达，
     // self.onmessage / self.postMessage 由此成立）。幂等守卫。
     let si_self = sf.intern("self").0;

crates/oxide_vm/src/session_gc.rs

@@ -706,6 +706,21 @@ impl SessionGc {
             .broadcast_channels
             .retain(|_, channels| !channels.is_empty());
 
+        // EventTarget 监听器注册表剪枝：按 mark 位移除死目标对象（弱键，同
+        // broadcast_channels 时序——死目标在随后的分流循环被释放，注册表已先
+        // 移除其条目，无悬垂）。
+        vm.realm
+            .gc
+            .borrow_mut()
+            .event_targets
+            .retain(|&ptr, _| {
+                if ptr.is_null() {
+                    return false;
+                }
+                // SAFETY: ptr 来自 session 对象表登记，sweep 运行期间有效。
+                unsafe { (*ptr).is_gc_marked() }
+            });
+
         // 按 mark 位分流：存活保留清位，死对象释放本体、堆区与 upvalue 出表。
         let mut dead = 0u64;
         let mut freed_bytes = 0u64;

crates/oxide_vm/src/vm/gc_hooks.rs

@@ -42,11 +42,12 @@ pub(crate) enum RootGroup {
     Global,
     WorkerObjects,
     DisposeStack,
+    EventTargets,
 }
 
 impl RootGroup {
     /// 根组总数（与变体数同源，绑定逐组计数数组的长度）。
-    pub const COUNT: usize = 27;
+    pub const COUNT: usize = 28;
 }
 
 impl Vm {
@@ -180,6 +181,14 @@ impl Vm {
         for &worker_obj in self.worker_objects.values() {
             f(RootGroup::WorkerObjects, worker_obj);
         }
+        // EventTarget 监听器注册表：监听器回调是 GC 根（存活目标的回调随目标存活，
+        // 漏根 → 回调被 sweep 释放 → 派发解引用悬垂）。弱键剪枝见 sweep；此处
+        // 无条件标活全部回调（死目标的回调多活一轮收集，非泄漏，sweep 已剪其条目）。
+        for state in self.realm.gc.borrow().event_targets.values() {
+            for entry in &state.listeners {
+                f(RootGroup::EventTargets, entry.callback);
+            }
+        }
     }
 
     /// GC 根统一枚举入口：遍历的字段清单与 `for_each_value` 相同。

crates/oxide_vm/src/vm/vmhost.rs

@@ -4,7 +4,7 @@ use std::ffi::c_void;
 use std::sync::Arc;
 
 use oxide_kernel::KernelCore;
-use oxide_runtime_api::{ProtoKind, ShapeNode};
+use oxide_runtime_api::{ListenerEntry, ProtoKind, ShapeNode};
 use oxide_types::mem::P;
 use oxide_types::object::{Cell, JsObject, PropAttributes};
 use oxide_types::value::JsValue;
@@ -449,4 +449,27 @@ impl oxide_runtime_api::VmHost for Vm {
     fn bc_lookup(&self, name: &str) -> Vec<*mut JsObject> {
         self.realm.gc.borrow().broadcast_channels.get(name).cloned().unwrap_or_default()
     }
+    fn et_register(&self, target: *mut JsObject, entry: ListenerEntry) {
+        self.realm
+            .gc
+            .borrow_mut()
+            .event_targets
+            .entry(target)
+            .or_default()
+            .listeners
+            .push(entry);
+    }
+    fn et_unregister(&self, target: *mut JsObject, type_si: u32, callback: JsValue, capture: bool) {
+        let mut gc = self.realm.gc.borrow_mut();
+        let should_remove = gc.event_targets.get_mut(&target).is_some_and(|state| {
+            state.listeners.retain(|e| !(e.type_si == type_si && e.capture == capture && e.callback == callback));
+            state.listeners.is_empty()
+        });
+        if should_remove {
+            gc.event_targets.remove(&target);
+        }
+    }
+    fn et_lookup(&self, target: *mut JsObject) -> Vec<ListenerEntry> {
+        self.realm.gc.borrow().event_targets.get(&target).map(|s| s.listeners.clone()).unwrap_or_default()
+    }
 }

crates/oxide_vm/src/vm_state.rs

@@ -14,6 +14,7 @@ use std::collections::HashMap;
 use crate::session_gc::SessionGc;
 use crate::vm::ForInIter;
 use oxide_builtins::iterator::BuiltinIterKind;
+use oxide_runtime_api::EventTargetState;
 use oxide_types::object::{Cell as UpvalueCell, JsObject, JsString};
 use oxide_types::private_key::WELL_KNOWN_SYMBOL_COUNT;
 use oxide_types::value::JsValue;
@@ -65,6 +66,11 @@ pub(crate) struct GcState {
     /// （弱引用，不保活）。构造器分配后登记、close 注销、GC sweep 按 mark 位
     /// 剪枝、full_reset 随 session 对象一并清表。
     pub(crate) broadcast_channels: HashMap<String, Vec<*mut JsObject>>,
+    /// EventTarget per-realm 弱引用监听器注册表：目标对象裸指针 → 监听器集合
+    /// （弱键，不保活）。addEventListener 登记、removeEventListener 注销、GC
+    /// sweep 按 mark 位剪枝、full_reset 随 session 对象一并清表。值持监听器
+    /// 回调的 GC 对象边，mark 期经根枚举标活（存活目标的回调随目标存活）。
+    pub(crate) event_targets: HashMap<*mut JsObject, EventTargetState>,
 }
 
 impl GcState {

crates/oxide_vm/src/vm_support.rs

@@ -103,6 +103,7 @@ impl Vm {
                     pending_forced_collect: false,
                     gc_pressure_mode: gc_pressure_mode_from_env(),
                     broadcast_channels: std::collections::HashMap::new(),
+                    event_targets: std::collections::HashMap::new(),
                 }),
                 symbols: RefCell::new(SymbolState {
                     symbol_descriptions: Vec::new(),
@@ -269,6 +270,7 @@ impl Vm {
                     pending_forced_collect: false,
                     gc_pressure_mode: gc_pressure_mode_from_env(),
                     broadcast_channels: std::collections::HashMap::new(),
+                    event_targets: std::collections::HashMap::new(),
                 }),
                 symbols: RefCell::new(SymbolState {
                     symbol_descriptions: Vec::new(),
@@ -490,6 +492,9 @@ impl Vm {
         // BroadcastChannel 注册表持 session 对象裸指针：teardown 释放全部
         // session 对象前须清表，否则残留悬垂指针。
         self.realm.gc.borrow_mut().broadcast_channels.clear();
+        // EventTarget 监听器注册表同持 session 对象裸指针（弱键）：teardown 释放
+        // 全部 session 对象前须清表，否则残留悬垂指针。
+        self.realm.gc.borrow_mut().event_targets.clear();
         // Worker 对象注册表持 session 对象指针：teardown 释放全部 session 对象
         // 前须清表，否则残留悬垂指针。
         self.worker_objects.clear();

crates/oxide_vm/src/worker/bindings.rs

@@ -287,42 +287,43 @@ pub(crate) fn self_location(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     NativeResult::Ok(vm.new_string(""))
 }
 
-/// 事件构造辅助：建事件对象（`data` + `type` + `message` 属性）。
+/// 事件构造辅助：建真实 Event 盒（`type` 字段）加 `data` / `message` 普通属性。
 ///
 /// 消息事件与错误事件同型，共用本辅助：消息事件 `message` 为 undefined，
 /// 错误事件 `data` 为 undefined、`message` 为错误串。
 ///
 /// # 步骤
-/// 1. 建 PLAIN 对象（`[[Prototype]]` → `%Object.prototype%`）。
-/// 2. define `data` 属性（rehydrate 后的消息值，可枚举）。
-/// 3. define `type` 属性（事件类型串，可枚举）。
-/// 4. define `message` 属性（错误消息串，可枚举；消息事件为 undefined）。
-/// 5. 返回对象。
+/// 1. 经 `create_event_box` 建真实 Event 盒（`type` 取 `type_val` 的字符串形态，
+///    `[[Prototype]]` → `Event.prototype`），使 `dispatchEvent` 品牌守卫通过。
+/// 2. define `data` 属性（rehydrate 后的消息值，可枚举；GC 边）。
+/// 3. `message` 非 undefined 时 define `message` 属性（错误消息串，可枚举）。
+/// 4. 返回对象。
 ///
 /// # 边界与前提
-/// - `data` 是 rehydrate 后的消息值（GC 边，经 `alloc_object` 入对象表即成根）。
+/// - `data` 是 rehydrate 后的消息值（GC 边，经属性区入 mark）。
 /// - `type` 是事件类型串（`"message"`/`"error"`/`"messageerror"`）。
 /// - `message` 是错误消息串（仅错误事件定义，消息事件为 undefined）。
+/// - Event 盒无 `data` 字段（8.4 的 MessageEvent 才补），`data` 作盒对象普通属性。
 ///
 /// # 副作用
-/// - 新建一个事件对象（经 `alloc_object` 入对象表）。
+/// - 新建一个 Event 盒对象（经 `alloc_object` 入对象表）。
 pub(crate) fn message_event_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let data_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let type_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     let message_val = if args.len() > 3 { vm.reg(args[3]) } else { JsValue::undefined() };
 
-    let object_proto = JsValue::from_js_object(vm.builtin_proto(ProtoKind::ObjectProto));
-    let obj = JsObject::new_empty(EMPTY_SHAPE_ID, object_proto);
-    let ptr = vm.alloc_object(obj);
-    // SAFETY: ptr 是本函数刚 alloc_object 的对象，存活且本段无别名。
+    // 建真实 Event 盒（type 取 type_val 的字符串形态）。
+    let type_text = vm.lookup_str(type_val).unwrap_or_default();
+    let ptr = oxide_builtins::event::create_event_box(vm, &type_text);
+    // SAFETY: ptr 是 create_event_box 刚 alloc_object 的对象，存活且本段无别名。
     let event_obj = unsafe { &mut *ptr };
 
     let si_data = vm.perm_intern("data");
     let _ = vm.define_data_property(event_obj, si_data, data_val, PropAttributes::DEFAULT_DATA);
-    let si_type = vm.perm_intern("type");
-    let _ = vm.define_data_property(event_obj, si_type, type_val, PropAttributes::DEFAULT_DATA);
-    let si_message = vm.perm_intern("message");
-    let _ = vm.define_data_property(event_obj, si_message, message_val, PropAttributes::DEFAULT_DATA);
+    if !message_val.is_undefined() {
+        let si_message = vm.perm_intern("message");
+        let _ = vm.define_data_property(event_obj, si_message, message_val, PropAttributes::DEFAULT_DATA);
+    }
 
     NativeResult::Ok(JsValue::from_js_object(ptr))
 }

crates/oxide_vm/src/worker/mod.rs

@@ -20,7 +20,7 @@ use std::time::Duration;
 use oxide_builtins::message_value::{rehydrate_message, MessageValue};
 use oxide_kernel::kernel::KernelCore;
 use oxide_kernel::message_queue::{channel, Receiver, Sender, Timeout};
-use oxide_runtime_api::{CompilerService, NativeResult, VmHost};
+use oxide_runtime_api::{CompilerService, NativeResult};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
@@ -345,30 +345,23 @@ impl Vm {
             let Some(worker_obj) = self.worker_object(id) else {
                 continue;
             };
-            // 错误面：逐条交付 onerror（编译 / 执行失败）。
+            // 错误面：逐条经 dispatchEvent 交付 error 事件（编译 / 执行失败）。
             for err in &poll.errors {
                 if self.worker_object(id).is_none() {
                     break;
                 }
-                self.deliver_error_event(worker_obj, "onerror", "error", err);
+                self.deliver_error_event(worker_obj, "error", err);
             }
-            // 消息交付失败面：逐条交付 onmessageerror（当前架构不可达，前向钩子）。
+            // 消息交付失败面：逐条经 dispatchEvent 交付 messageerror 事件
+            // （当前架构不可达，前向钩子）。
             for msg_err in &poll.message_errors {
                 if self.worker_object(id).is_none() {
                     break;
                 }
-                self.deliver_error_event(worker_obj, "onmessageerror", "messageerror", msg_err);
-            }
-            // 数据面：读 onmessage 属性（undefined 或非可调用即静默跳过）。
-            let si_onmessage = self.perm_intern("onmessage");
-            let handler = match self.ordinary_get(unsafe { &*worker_obj.as_js_object_ptr() }, si_onmessage, worker_obj)
-            {
-                Ok(h) => h,
-                Err(_) => continue,
-            };
-            if !is_callable(handler) {
-                continue;
+                self.deliver_error_event(worker_obj, "messageerror", msg_err);
             }
+            // 数据面：经 dispatchEvent 交付（注册表查监听器，addEventListener 与
+            // 属性 handler 同权；首版属性 handler 尚不支持，8.7 完成）。
             for data in poll.messages {
                 // 交付前二次校验存活（GC 防护）：worker 在事件循环中被终止
                 // （注册表条目移除）即停止交付。
@@ -376,40 +369,46 @@ impl Vm {
                     break;
                 }
                 let event = self.build_message_event(data, "message", None);
-                let _ = self.execute_task(|vm| vm.call_function_sync(handler, worker_obj, &[event]));
+                self.dispatch_event_on(worker_obj, event);
                 self.drain_microtasks();
             }
         }
         any
     }
 
-    /// 交付错误事件：读 handler 属性、建事件、调用（不可调用时静默）。
+    /// 经 `dispatchEvent` 交付事件到目标对象（注册表查监听器，按登记序调用）。
     ///
     /// # 步骤
-    /// 1. 读 `worker_obj` 的 `handler_name` 属性。
-    /// 2. 不可调用时静默返回（浏览器语义：无 handler 即丢弃）。
-    /// 3. 建错误事件（`type` = `event_type`、`message` = `message`）。
-    /// 4. 经 `execute_task` + `call_function_sync` 触发，后 `drain_microtasks`。
+    /// 1. 目标与事件钉入寄存器 0 / 1（GC 根，防交付窗口内被回收）。
+    /// 2. 调 `event_target_dispatch_event`（this = 目标，实参 = 事件）。
     ///
     /// # 边界与前提
-    /// - `handler_name` 是 `onerror` 或 `onmessageerror`。
-    /// - `event_type` 是 `"error"` 或 `"messageerror"`。
-    /// - `worker_obj` 与 handler 均为 `JsValue`（Copy），在 `execute_task` 前提取，
-    ///   不跨 `&mut self` 持引用。
+    /// - 监听器回调的异常原值上抛（不吞）；无监听器时 no-op（返回 true）。
     ///
     /// # 副作用
-    /// - 触发 handler 回调与微任务 drain。
-    fn deliver_error_event(&mut self, worker_obj: JsValue, handler_name: &str, event_type: &str, message: &str) {
-        let si_handler = self.perm_intern(handler_name);
-        let handler = match self.ordinary_get(unsafe { &*worker_obj.as_js_object_ptr() }, si_handler, worker_obj) {
-            Ok(h) => h,
-            Err(_) => return,
-        };
-        if !is_callable(handler) {
-            return;
-        }
+    /// - 触发监听器回调与 `once` 条目移除；写事件载荷盒（target / 阶段）。
+    fn dispatch_event_on(&mut self, target: JsValue, event: JsValue) {
+        self.set_reg(0, target);
+        self.set_reg(1, event);
+        let _ = oxide_builtins::event_target::event_target_dispatch_event(self, &[0, 1]);
+    }
+
+    /// 交付错误事件：建事件、经 `dispatchEvent` 交付（注册表查监听器）。
+    ///
+    /// # 步骤
+    /// 1. 建错误事件（`type` = `event_type`、`message` = `message`、`data` = undefined）。
+    /// 2. 经 `dispatch_event_on` 交付到 `worker_obj`，后 `drain_microtasks`。
+    ///
+    /// # 边界与前提
+    /// - `event_type` 是 `"error"` 或 `"messageerror"`。
+    /// - `worker_obj` 是 `JsValue`（Copy），不跨 `&mut self` 持引用。
+    /// - 无监听器时 `dispatchEvent` 返回 true（no-op）。
+    ///
+    /// # 副作用
+    /// - 触发监听器回调与微任务 drain。
+    fn deliver_error_event(&mut self, worker_obj: JsValue, event_type: &str, message: &str) {
         let event = self.build_message_event(JsValue::undefined(), event_type, Some(message));
-        let _ = self.execute_task(|vm| vm.call_function_sync(handler, worker_obj, &[event]));
+        self.dispatch_event_on(worker_obj, event);
         self.drain_microtasks();
     }
 
@@ -463,21 +462,20 @@ impl Vm {
         }
     }
 
-    /// worker 侧消息交付：rehydrate 进 worker realm、建 MessageEvent、交付到
-    /// `self.onmessage`（worker global 的 `onmessage` 属性）。
+    /// worker 侧消息交付：rehydrate 进 worker realm、建 MessageEvent、经
+    /// `dispatchEvent` 交付到 worker global（注册表查监听器）。
     ///
     /// # 步骤
     /// 1. rehydrate 消息值进 worker realm。
     /// 2. 建 MessageEvent（data + type "message"）。
-    /// 3. 读 worker global 的 `onmessage` 属性。
-    /// 4. 可调用时经 `execute_task` + `call_function_sync` 触发，后 `drain_microtasks`。
+    /// 3. 取 worker global 对象，经 `dispatch_event_on` 交付，后 `drain_microtasks`。
     ///
     /// # 边界与前提
-    /// - `onmessage` 缺失或非可调用时静默跳过（消息已消费，符合浏览器
+    /// - 无监听器时 `dispatchEvent` 返回 true（消息已消费，符合浏览器
     ///   "无 handler 即丢弃"语义）。
     ///
     /// # 副作用
-    /// - 触发 `self.onmessage` 回调与微任务 drain。
+    /// - 触发监听器回调与微任务 drain。
     pub(crate) fn deliver_self_message(&mut self, value: MessageValue) {
         let data = rehydrate_message(self, &value);
         let event = self.build_message_event(data, "message", None);
@@ -487,29 +485,13 @@ impl Vm {
             session.global_object().as_ptr() as *mut JsObject
         };
         // SAFETY: global_ptr 是当前 session 的 global 对象，存活。
-        let global_obj = unsafe { &*global_ptr };
-        let si_onmessage = self.perm_intern("onmessage");
-        let handler = match self.ordinary_get(global_obj, si_onmessage, JsValue::from_js_object(global_ptr)) {
-            Ok(h) => h,
-            Err(_) => return,
-        };
-        if !is_callable(handler) {
-            return;
-        }
-        let _ = self.execute_task(|vm| vm.call_function_sync(handler, JsValue::from_js_object(global_ptr), &[event]));
+        let global_val = JsValue::from_js_object(global_ptr);
+        // 经 dispatchEvent 交付（注册表查监听器，属性 handler 与 addEventListener 同权）。
+        self.dispatch_event_on(global_val, event);
         self.drain_microtasks();
     }
 }
 
-/// 判定值是否可调用（对象且函数对象，header bit 31）。
-///
-/// # 边界与前提
-/// - 非对象值恒不可调用。
-/// - 对象经 `as_js_object_ptr` 解引用读函数位（unsafe，惯例形态）。
-fn is_callable(val: JsValue) -> bool {
-    val.is_object() && unsafe { &*val.as_js_object_ptr() }.is_function()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -545,9 +527,9 @@ mod tests {
     fn worker_round_trip() {
         let mut vm = vm_with_compiler();
 
-        // worker 脚本设 onmessage 回显（onmessage 语义替换早期回显语义）。
+        // worker 脚本设 addEventListener 回显（注册表交付替换早期 onmessage 属性语义）。
         let id = vm
-            .spawn_worker("self.onmessage = function(e) { self.postMessage(e.data); };")
+            .spawn_worker("self.addEventListener('message', function(e) { self.postMessage(e.data); });")
             .expect("worker 应派生成功");
         assert_eq!(vm.active_workers(), vec![id], "应有唯一活跃 worker");
 
@@ -581,12 +563,12 @@ mod tests {
     fn multiple_workers_isolated() {
         let mut vm = vm_with_compiler();
 
-        // 两 worker 各设 onmessage 回显（onmessage 语义）。
+        // 两 worker 各设 addEventListener 回显（注册表交付语义）。
         let id_a = vm
-            .spawn_worker("self.onmessage = function(e) { self.postMessage(e.data); };")
+            .spawn_worker("self.addEventListener('message', function(e) { self.postMessage(e.data); });")
             .expect("worker A 应派生成功");
         let id_b = vm
-            .spawn_worker("self.onmessage = function(e) { self.postMessage(e.data); };")
+            .spawn_worker("self.addEventListener('message', function(e) { self.postMessage(e.data); });")
             .expect("worker B 应派生成功");
         assert_eq!(vm.active_workers(), vec![id_a, id_b], "应有两个活跃 worker");
 
@@ -647,10 +629,11 @@ mod tests {
         let mut vm = vm_with_compiler();
 
         // worker 脚本：收到消息翻倍后回发。
-        let worker_path = write_worker_script("self.onmessage = function(e) { self.postMessage(e.data * 2); };");
-        // 主脚本：建 Worker、设 onmessage、投递 21。
+        let worker_path =
+            write_worker_script("self.addEventListener('message', function(e) { self.postMessage(e.data * 2); });");
+        // 主脚本：建 Worker、设 addEventListener、投递 21。
         let main_script = format!(
-            "var w = new Worker('{}'); w.onmessage = function(e) {{ globalThis.received = e.data; }}; w.postMessage(21);",
+            "var w = new Worker('{}'); w.addEventListener('message', function(e) {{ globalThis.received = e.data; }}); w.postMessage(21);",
             worker_path.display()
         );
         vm.run(&Arc::new(compile_script(&main_script))).expect("主脚本应运行");
@@ -750,9 +733,9 @@ mod tests {
 
         // worker 脚本：语法错误（编译失败）。
         let worker_path = write_worker_script("function { 语法错误");
-        // 主脚本：建 Worker、设 onerror，记录 e.message 与 e.type 是否为 "error"。
+        // 主脚本：建 Worker、设 addEventListener('error')，记录 e.message 与 e.type 是否为 "error"。
         let main_script = format!(
-            "var w = new Worker('{}'); w.onerror = function(e) {{ globalThis.err = e.message; globalThis.errIsErrorType = (e.type === \"error\"); }};",
+            "var w = new Worker('{}'); w.addEventListener('error', function(e) {{ globalThis.err = e.message; globalThis.errIsErrorType = (e.type === \"error\"); }});",
             worker_path.display()
         );
         vm.run(&Arc::new(compile_script(&main_script))).expect("主脚本应运行");
@@ -795,9 +778,9 @@ mod tests {
 
         // worker 脚本：顶层 throw（执行失败）。
         let worker_path = write_worker_script("throw new Error('boom');");
-        // 主脚本：建 Worker、设 onerror，记录 e.message。
+        // 主脚本：建 Worker、设 addEventListener('error')，记录 e.message。
         let main_script = format!(
-            "var w = new Worker('{}'); w.onerror = function(e) {{ globalThis.err = e.message; }};",
+            "var w = new Worker('{}'); w.addEventListener('error', function(e) {{ globalThis.err = e.message; }});",
             worker_path.display()
         );
         vm.run(&Arc::new(compile_script(&main_script))).expect("主脚本应运行");
@@ -832,17 +815,17 @@ mod tests {
     fn onmessageerror_delivery_helper() {
         let mut vm = vm_with_compiler();
 
-        // 建 Worker 对象、设 onmessageerror handler（记录 e.message 与 e.type）。
+        // 建 Worker 对象、设 addEventListener('messageerror')（记录 e.message 与 e.type）。
         let worker_path = write_worker_script("1");
         let main_script = format!(
-            "var w = new Worker('{}'); w.onmessageerror = function(e) {{ globalThis.me = e.message; globalThis.meIsMessageErrorType = (e.type === \"messageerror\"); }}; globalThis.w = w;",
+            "var w = new Worker('{}'); w.addEventListener('messageerror', function(e) {{ globalThis.me = e.message; globalThis.meIsMessageErrorType = (e.type === \"messageerror\"); }}); globalThis.w = w;",
             worker_path.display()
         );
         vm.run(&Arc::new(compile_script(&main_script))).expect("主脚本应运行");
 
-        // 取 Worker 对象，直接调交付辅助（模拟 rehydrate 失败）。
+        // 取 Worker 对象，直接调交付辅助（模拟 rehydrate 失败，经 dispatchEvent 交付）。
         let worker_obj = global_value_opt(&vm, "w").expect("w 应被设置");
-        vm.deliver_error_event(worker_obj, "onmessageerror", "messageerror", "合成 rehydrate 失败");
+        vm.deliver_error_event(worker_obj, "messageerror", "合成 rehydrate 失败");
 
         // 断言 handler 被调用、message 为错误串、type 为 "messageerror"。
         let me = global_value_opt(&vm, "me").expect("me 应被设置");

crates/oxide_vm/tests/event_target_tests.rs

@@ -0,0 +1,263 @@
+//! EventTarget 验收测试：addEventListener / removeEventListener / dispatchEvent
+//! 三方法、原型链（Worker / MessagePort / BroadcastChannel 经 EventTarget.prototype）、
+//! GC 剪枝。
+//!
+//! 集成测试走公共 API（`eval` 返回脚本完成值字符串），不访问私有字段。
+//! 目标对象一律用 MessagePort（EventTarget 实例）——普通对象原型链上没有
+//! EventTarget.prototype，DOM 语义下 addEventListener 也只存在于 EventTarget 实例。
+
+use std::sync::Arc;
+
+use oxide_compiler::compiler::Compiler;
+use oxide_compiler::DefaultCompilerService;
+use oxide_parser::Allocator;
+use oxide_vm::vm::Vm;
+
+/// 编译并运行脚本，返回完成值字符串（解析 / 编译 / 运行失败时返回错误描述）。
+fn eval(source: &str) -> String {
+    let allocator = Allocator::default();
+    let program = match oxide_parser::parse(&allocator, source) {
+        Ok(p) => p,
+        Err(e) => return format!("parse error: {}", e[0].message),
+    };
+    let module = match Compiler::new().compile(&program) {
+        Ok(m) => m,
+        Err(e) => return format!("compile error: {e}"),
+    };
+    let mut vm = Vm::new();
+    vm.set_compiler_service(Arc::new(DefaultCompilerService));
+    match vm.run(&Arc::new(module)) {
+        // 字符串结果经 lookup_str 提取内容（JsValue Display 只打印 {string}）。
+        Ok(result) => vm.lookup_str(result).unwrap_or_else(|| format!("{result}")),
+        Err(e) => format!("vm error: {e}"),
+    }
+}
+
+/// 建一个注入编译服务的 VM 并运行首段脚本（供 GC 测试中途收集）。
+fn vm_with_script(source: &str) -> Vm {
+    let allocator = Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).expect("parse 应成功");
+    let module = Compiler::new().compile(&program).expect("compile 应成功");
+    let mut vm = Vm::new();
+    vm.set_compiler_service(Arc::new(DefaultCompilerService));
+    vm.run(&Arc::new(module)).expect("run 应成功");
+    vm
+}
+
+/// 在既有 VM 上运行一段脚本，返回完成值字符串。
+fn vm_eval(vm: &mut Vm, source: &str) -> String {
+    let allocator = Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).expect("parse 应成功");
+    let module = Compiler::new().compile(&program).expect("compile 应成功");
+    match vm.run(&Arc::new(module)) {
+        // 字符串结果经 lookup_str 提取内容（JsValue Display 只打印 {string}）。
+        Ok(result) => vm.lookup_str(result).unwrap_or_else(|| format!("{result}")),
+        Err(e) => format!("vm error: {e}"),
+    }
+}
+
+/// 建一个 MessagePort 目标的前缀（每个测试目标独立，避免跨测试串扰）。
+const TARGET: &str = "var mc = new MessageChannel(); var t = mc.port1;";
+
+/// dispatchEvent(new Event('x')) 返回 true（无 preventDefault）。
+#[test]
+fn dispatch_event_returns_true() {
+    assert_eq!(
+        eval(&format!("{TARGET} t.dispatchEvent(new Event('x'));")),
+        "true"
+    );
+}
+
+/// preventDefault() 后 dispatchEvent 返回 false（cancelable 事件）。
+#[test]
+fn dispatch_event_returns_false_after_prevent_default() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} t.addEventListener('x', function(e) {{ e.preventDefault(); }}); \
+                 t.dispatchEvent(new Event('x', {{ cancelable: true }}));"
+            )
+        ),
+        "false"
+    );
+}
+
+/// 非 cancelable 事件 preventDefault 无效，dispatchEvent 仍返回 true。
+#[test]
+fn dispatch_event_non_cancelable_stays_true() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} t.addEventListener('x', function(e) {{ e.preventDefault(); }}); \
+                 t.dispatchEvent(new Event('x'));"
+            )
+        ),
+        "true"
+    );
+}
+
+/// removeEventListener 生效：移除后派发不再调用监听器。
+#[test]
+fn remove_event_listener_works() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} var calls = 0; \
+                 var fn = function(e) {{ calls++; }}; \
+                 t.addEventListener('x', fn); \
+                 t.removeEventListener('x', fn); \
+                 t.dispatchEvent(new Event('x')); \
+                 calls;"
+            )
+        ),
+        "0"
+    );
+}
+
+/// 重复登记（同 type + callback + capture）为 no-op：派发只调用一次。
+#[test]
+fn duplicate_add_event_listener_is_noop() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} var calls = 0; \
+                 var fn = function(e) {{ calls++; }}; \
+                 t.addEventListener('x', fn); \
+                 t.addEventListener('x', fn); \
+                 t.dispatchEvent(new Event('x')); \
+                 calls;"
+            )
+        ),
+        "1"
+    );
+}
+
+/// once 选项：监听器调用一次后自动移除。
+#[test]
+fn once_listener_removed_after_call() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} var calls = 0; \
+                 var fn = function(e) {{ calls++; }}; \
+                 t.addEventListener('x', fn, {{ once: true }}); \
+                 t.dispatchEvent(new Event('x')); \
+                 t.dispatchEvent(new Event('x')); \
+                 calls;"
+            )
+        ),
+        "1"
+    );
+}
+
+/// stopImmediatePropagation 截断后续监听器。
+#[test]
+fn stop_immediate_propagation_truncates() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} var calls = 0; \
+                 t.addEventListener('x', function(e) {{ calls++; e.stopImmediatePropagation(); }}); \
+                 t.addEventListener('x', function(e) {{ calls++; }}); \
+                 t.dispatchEvent(new Event('x')); \
+                 calls;"
+            )
+        ),
+        "1"
+    );
+}
+
+/// 监听器回调的 this 是目标对象、实参是事件（e.type 为类型串）。
+#[test]
+fn listener_receives_target_this_and_event() {
+    assert_eq!(
+        eval(
+            &format!(
+                "{TARGET} var gotThis = null; var gotType = null; \
+                 t.addEventListener('x', function(e) {{ gotThis = (this === t); gotType = e.type; }}); \
+                 t.dispatchEvent(new Event('x')); \
+                 gotThis + ':' + gotType;"
+            )
+        ),
+        "true:x"
+    );
+}
+
+/// MessagePort 原型链经 EventTarget.prototype：port.addEventListener 生效。
+#[test]
+fn port_add_event_listener_works() {
+    assert_eq!(
+        eval(
+            "var mc = new MessageChannel(); var calls = 0; \
+             mc.port1.addEventListener('message', function(e) { calls++; }); \
+             mc.port1.dispatchEvent(new Event('message')); \
+             calls;"
+        ),
+        "1"
+    );
+}
+
+/// BroadcastChannel 原型链经 EventTarget.prototype：channel.addEventListener 生效。
+#[test]
+fn channel_add_event_listener_works() {
+    assert_eq!(
+        eval(
+            "var ch = new BroadcastChannel('t'); var calls = 0; \
+             ch.addEventListener('message', function(e) { calls++; }); \
+             ch.dispatchEvent(new Event('message')); \
+             calls;"
+        ),
+        "1"
+    );
+}
+
+/// Worker.prototype 原型链经 EventTarget.prototype：worker.addEventListener 生效。
+#[test]
+fn worker_add_event_listener_works() {
+    let path = std::env::temp_dir().join(format!("oxide_et_{}.js", std::process::id()));
+    let _ = std::fs::write(&path, "1");
+    let script = format!(
+        "var w = new Worker('{}'); var calls = 0; \
+         w.addEventListener('message', function(e) {{ calls++; }}); \
+         w.dispatchEvent(new Event('message')); \
+         calls;",
+        path.display()
+    );
+    assert_eq!(eval(&script), "1");
+    let _ = std::fs::remove_file(&path);
+}
+
+/// 监听器对象经 GC 后仍有效（目标存活时回调随目标存活，无悬垂）。
+#[test]
+fn listener_survives_gc_while_target_live() {
+    let mut vm = vm_with_script(
+        "var mc = new MessageChannel(); globalThis.t = mc.port1; \
+         globalThis.t.addEventListener('x', function(e) { globalThis.calls = (globalThis.calls || 0) + 1; });",
+    );
+    // 强制完整收集：目标存活（globalThis.t），监听器回调应保活。
+    vm.collect_session_gc();
+    // 收集后派发：监听器仍应被调用（无悬垂）。
+    assert_eq!(
+        vm_eval(&mut vm, "globalThis.t.dispatchEvent(new Event('x')); globalThis.calls;"),
+        "1"
+    );
+}
+
+/// 目标对象被回收后注册表剪枝（GC 后无悬垂指针）。
+#[test]
+fn registry_pruned_after_target_collected() {
+    // t 是局部变量，脚本结束后无引用 → 目标死亡。
+    let mut vm = vm_with_script(
+        "var mc = new MessageChannel(); var t = mc.port1; t.addEventListener('x', function() {});",
+    );
+    // 强制完整收集：注册表应按 mark 位剪枝死目标条目。
+    vm.collect_session_gc();
+    // 剪枝后无悬垂：新建同型目标派发不触发旧监听器（旧条目已剪），无崩溃。
+    assert_eq!(
+        vm_eval(
+            &mut vm,
+            "var mc2 = new MessageChannel(); mc2.port1.dispatchEvent(new Event('x')); 'ok';"
+        ),
+        "ok"
+    );
+}