feat: ErrorEvent 载荷盒加 GC 加构造器加原型加 onerror 整合

crates/oxide_vm/src/bindings/bind_event.rs

@@ -1,10 +1,12 @@
 //! Event 体系绑定：就地填充 `event_constructor` / `event_proto` 两枚 P 字段
 //! 占位（构造器本体、原型方法、原型 getter 与 Event 常量），并绑全局 `Event`；
 //! 就地填充 `message_event_constructor` / `message_event_proto` 两枚 P 字段
-//! 占位（构造器本体与原型 getter），并绑全局 `MessageEvent`。
+//! 占位（构造器本体与原型 getter），并绑全局 `MessageEvent`；就地填充
+//! `error_event_constructor` / `error_event_proto` 两枚 P 字段占位（构造器
+//! 本体与原型 getter），并绑全局 `ErrorEvent`。
 //!
-//! 九枚 P 字段中其余四枚（ErrorEvent / CustomEvent 两对）由后续子任务就地
-//! 填充，本函数不读不写。
+//! 九枚 P 字段中其余两枚（CustomEvent 一对）由后续子任务就地填充，本函数
+//! 不读不写。
 
 use std::sync::Arc;
 
@@ -14,11 +16,12 @@ use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::{JsObject, PropAttributes};
 use oxide_types::value::JsValue;
 
-/// 把 Event 与 MessageEvent 构造器及原型方法绑定到 global。
+/// 把 Event / MessageEvent / ErrorEvent 构造器及原型方法绑定到 global。
 ///
-/// `event_constructor` / `event_proto` 与 `message_event_constructor` /
-/// `message_event_proto` 四枚 P 字段是空对象占位，本函数就地填充（不新建
-/// 对象——P 字段本身就是槽位，快照/脏检查/收尾枚举已覆盖）。
+/// `event_constructor` / `event_proto`、`message_event_constructor` /
+/// `message_event_proto` 与 `error_event_constructor` / `error_event_proto`
+/// 六枚 P 字段是空对象占位，本函数就地填充（不新建对象——P 字段本身就是
+/// 槽位，快照/脏检查/收尾枚举已覆盖）。
 ///
 /// # 幂等
 /// 本函数从三条路径到达：`init_kernel_builtins`（占位是空对象）、
@@ -239,6 +242,75 @@ pub fn bind_event(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
         }
     }
 
+    // ---- 填 ErrorEvent 构造器与原型占位 ----
+    let ee_ctor_ptr = world.error_event_constructor.as_ptr() as *mut JsObject;
+    let ee_ctor = unsafe { &mut *ee_ctor_ptr };
+    let ee_proto_ptr = world.error_event_proto.as_ptr() as *mut JsObject;
+    let ee_proto = unsafe { &mut *ee_proto_ptr };
+
+    // 构造器：function 标志、prototype 槽、name 槽、[[Prototype]] →
+    // Function.prototype（幂等，裸写槽）。
+    ee_ctor.set_function(true);
+    if sh.lookup_position(ee_ctor.shape_id(), si_prototype).is_none() {
+        let shape = sh.make_shape(ee_ctor.shape_id(), si_prototype);
+        ee_ctor.set_shape_id(shape);
+        let pos = ee_ctor.push_prop(JsValue::from_js_object(ee_proto_ptr));
+        ee_ctor.set_data_meta(pos, PropAttributes::new(false, false, false));
+        ee_ctor.bump_generation();
+    }
+    if sh.lookup_position(ee_ctor.shape_id(), si_name).is_none() {
+        let shape = sh.make_shape(ee_ctor.shape_id(), si_name);
+        ee_ctor.set_shape_id(shape);
+        ee_ctor
+            .ensure_hash_props()
+            .push(JsValue::perm_string(sf.string_ptr(sf.intern("ErrorEvent").0)));
+        let pos = ee_ctor.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
+        ee_ctor.set_data_meta(pos, PropAttributes::new(false, false, true));
+        ee_ctor.bump_generation();
+    }
+    let _ = ee_ctor.set_proto(fn_proto_val);
+
+    configure_native_constructor(
+        ee_ctor,
+        oxide_builtins::event::error_event_constructor::<crate::vm::Vm> as *const (),
+        2,
+    );
+    bind_constructor!(
+        core,
+        global,
+        "ErrorEvent",
+        ee_ctor_ptr,
+        oxide_builtins::event::error_event_constructor::<crate::vm::Vm>,
+        2,
+        hash: true
+    );
+
+    // 原型：constructor 槽、[[Prototype]] → Event.prototype、五个 getter
+    // （message / filename / lineno / colno / error，每 getter 先
+    // lookup_position 守卫）。
+    if sh.lookup_position(ee_proto.shape_id(), si_constructor).is_none() {
+        let shape = sh.make_shape(ee_proto.shape_id(), si_constructor);
+        ee_proto.set_shape_id(shape);
+        let pos = ee_proto.push_prop(JsValue::from_js_object(ee_ctor_ptr));
+        ee_proto.set_data_meta(pos, PropAttributes::new(true, false, true));
+        ee_proto.bump_generation();
+    }
+    let _ = ee_proto.set_proto(event_proto_val);
+
+    let ee_getter_fns: [(&str, *const ()); 5] = [
+        ("message", oxide_builtins::event::error_event_message_getter::<crate::vm::Vm> as *const ()),
+        ("filename", oxide_builtins::event::error_event_filename_getter::<crate::vm::Vm> as *const ()),
+        ("lineno", oxide_builtins::event::error_event_lineno_getter::<crate::vm::Vm> as *const ()),
+        ("colno", oxide_builtins::event::error_event_colno_getter::<crate::vm::Vm> as *const ()),
+        ("error", oxide_builtins::event::error_event_error_getter::<crate::vm::Vm> as *const ()),
+    ];
+    for (name, fn_ptr) in ee_getter_fns {
+        let si = sf.intern(name).0;
+        if sh.lookup_position(ee_proto.shape_id(), si).is_none() {
+            bind_accessor_getter(core, session, ee_proto, name, fn_ptr);
+        }
+    }
+
     // ---- 填 EventTarget 原型占位（无构造器，仅暴露原型与三方法）----
     // 幂等：三方法经 lookup_position 守卫，[[Prototype]] 裸写槽幂等。
     let et_proto_ptr = world.event_target_proto.as_ptr() as *mut JsObject;

crates/oxide_vm/src/bindings/mod.rs

@@ -26,7 +26,8 @@ pub mod bind_date;
 pub mod bind_disposable_stack;
 /// Error 家族构造器与原型的 native 方法绑定（含各子类型构造器创建）。
 pub mod bind_error;
-/// Event 体系绑定入口（当前为空占位，九枚 P 字段由后续任务就地填充）。
+/// Event 体系绑定入口（Event / MessageEvent / ErrorEvent 构造器与原型就地
+/// 填充，CustomEvent 一对由后续任务填充）。
 pub mod bind_event;
 /// Function 构造器与原型的 native 方法绑定。
 pub mod bind_function;

crates/oxide_vm/src/native_box_dispatch.rs

@@ -248,9 +248,16 @@ pub(crate) fn ops_for(family: NativeBoxFamily) -> NativeBoxOps {
             string_edges: None,
             cell_edges: None,
         },
-        // ErrorEvent / CustomEvent 载荷盒由后续子任务填充；本两臂当前无引用
-        // 边，仅 size/drop 链消费。
-        NativeBoxFamily::ErrorEvent | NativeBoxFamily::CustomEvent => NativeBoxOps {
+        // ErrorEvent 派生类载荷盒：基类 type / target / current_target 边加
+        // message / filename / error 边。
+        NativeBoxFamily::ErrorEvent => NativeBoxOps {
+            object_edges: Some(event::error_event_native_edges),
+            string_edges: None,
+            cell_edges: None,
+        },
+        // CustomEvent 载荷盒由后续子任务填充；本臂当前无引用边，仅 size/drop
+        // 链消费。
+        NativeBoxFamily::CustomEvent => NativeBoxOps {
             object_edges: None,
             string_edges: None,
             cell_edges: None,

crates/oxide_vm/src/session_gc.rs

@@ -134,6 +134,7 @@ impl SessionGc {
         bytes += broadcast_channel::broadcast_channel_native_size(obj);
         bytes += event::event_native_size(obj);
         bytes += event::message_event_native_size(obj);
+        bytes += event::error_event_native_size(obj);
         bytes += crate::arguments_gc::arguments_native_size(obj);
 
         bytes
@@ -378,12 +379,13 @@ impl SessionGc {
             }
         }
         // 事件系载荷盒（Event / MessageEvent / ErrorEvent / CustomEvent）字符串
-        // 边标记：按标签取对应边函数；ErrorEvent / CustomEvent 载荷盒由后续子
-        // 任务填充，当前取空边。
+        // 边标记：按标签取对应边函数；CustomEvent 载荷盒由后续子任务填充，
+        // 当前取空边。
         if event::is_event_family_obj(obj) {
             let edges = match obj.type_tag {
                 JsObject::OBJ_TYPE_EVENT => event::event_native_edges(obj),
                 JsObject::OBJ_TYPE_MESSAGE_EVENT => event::message_event_native_edges(obj),
+                JsObject::OBJ_TYPE_ERROR_EVENT => event::error_event_native_edges(obj),
                 _ => Vec::new(),
             };
             for value in edges {
@@ -593,6 +595,7 @@ impl SessionGc {
             freed_bytes += broadcast_channel::drop_broadcast_channel_native(obj);
             freed_bytes += event::drop_event_native(obj);
             freed_bytes += event::drop_message_event_native(obj);
+            freed_bytes += event::drop_error_event_native(obj);
             freed_bytes += crate::arguments_gc::drop_arguments_native(obj);
 
             freed_bytes

crates/oxide_vm/src/worker/bindings.rs

@@ -316,41 +316,32 @@ pub(crate) fn message_event_constructor(vm: &mut Vm, args: &[u8]) -> NativeResul
     NativeResult::Ok(JsValue::from_js_object(ptr))
 }
 
-/// 错误事件构造辅助（临时形态）：建真实 Event 盒（`type` 字段）加 `data` /
-/// `message` 普通属性。
+/// 错误事件构造辅助：建真实 ErrorEvent 盒（`message` 为错误串、`filename`
+/// 空串、`lineno` 与 `colno` 为 0、`error` 为 null）。
 ///
-/// 错误路径（`deliver_error_event`）经本辅助建错误事件：`data` 为 undefined、
-/// `message` 为错误串，供 onerror 处理器读取。
+/// 错误路径（`deliver_error_event`）经本辅助建真实 ErrorEvent，
+/// `e instanceof ErrorEvent` 与 `e instanceof Event` 均成立，`e.message`
+/// 经原型 getter 读盒字段。
 ///
 /// # 步骤
 /// 1. 读 `type`（`args[1]`）与 `message`（`args[2]`）。
-/// 2. 经 `create_event_box` 建真实 Event 盒（`type` 取 `type_val` 的字符串
-///    形态，`[[Prototype]]` → `Event.prototype`），使 `dispatchEvent` 品牌守卫
-///    通过。
-/// 3. define `data` 属性（undefined，可枚举）与 `message` 属性（错误消息串，
-///    可枚举）。
-/// 4. 返回对象。
+/// 2. 委托 `create_error_event_box` 建真实 ErrorEvent 盒（`[[Prototype]]` →
+///    `ErrorEvent.prototype`），使 `dispatchEvent` 品牌守卫通过。
+/// 3. 返回对象。
 ///
 /// # 边界与前提
 /// - `type` 是事件类型串（`"error"`/`"messageerror"`）。
-/// - `message` 是错误消息串。
+/// - `message` 是错误消息串（GC 边，经盒边入 mark）。
 ///
 /// # 副作用
-/// - 新建一个 Event 盒对象（经 `alloc_object` 入对象表）。
+/// - 新建一个 ErrorEvent 盒对象（经 `alloc_object` 入对象表）。
 pub(crate) fn build_error_event(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let type_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let message_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
 
-    // 建真实 Event 盒（type 取 type_val 的字符串形态）。
+    // 建真实 ErrorEvent 盒（type 与 message 取实参的字符串形态）。
     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, JsValue::undefined(), PropAttributes::DEFAULT_DATA);
-    let si_message = vm.perm_intern("message");
-    let _ = vm.define_data_property(event_obj, si_message, message_val, PropAttributes::DEFAULT_DATA);
-
+    let message_text = vm.lookup_str(message_val).unwrap_or_default();
+    let ptr = oxide_builtins::event::create_error_event_box(vm, &message_text, &type_text);
     NativeResult::Ok(JsValue::from_js_object(ptr))
 }

crates/oxide_vm/src/worker/mod.rs

@@ -396,7 +396,7 @@ impl Vm {
     /// 交付错误事件：建事件、经 `dispatchEvent` 交付（注册表查监听器）。
     ///
     /// # 步骤
-    /// 1. 建错误事件（`type` = `event_type`、`message` = `message`、`data` = undefined）。
+    /// 1. 建错误事件（`type` = `event_type`、`message` = `message`）。
     /// 2. 经 `dispatch_event_on` 交付到 `worker_obj`，后 `drain_microtasks`。
     ///
     /// # 边界与前提
@@ -437,8 +437,9 @@ impl Vm {
         }
     }
 
-    /// 错误路径建事件对象（临时形态）：建真实 Event 盒（`type` 字段）加
-    /// `data` / `message` 普通属性，委托 `build_error_event` 构造辅助。
+    /// 错误路径建事件对象：建真实 ErrorEvent（`message` 为错误串、`filename`
+    /// 空串、`lineno` 与 `colno` 为 0、`error` 为 null），委托
+    /// `build_error_event` 构造辅助。
     ///
     /// # 步骤
     /// 1. `type` 与 `message` 串物化为 session 串。
@@ -449,7 +450,7 @@ impl Vm {
     /// 新建的事件对象值（构造失败时返回错误对象值）。
     ///
     /// # 副作用
-    /// - 新建一个 Event 盒对象（经 `alloc_object` 入对象表）。
+    /// - 新建一个 ErrorEvent 盒对象（经 `alloc_object` 入对象表）。
     fn build_error_event(&mut self, type_str: &str, message: &str) -> JsValue {
         let type_val = self.new_string(type_str);
         let message_val = self.new_string(message);
@@ -829,6 +830,49 @@ mod tests {
         let _ = std::fs::remove_file(&worker_path);
     }
 
+    /// 端到端：worker 脚本编译失败，主线程 onerror 收到真实 ErrorEvent
+    /// （e instanceof ErrorEvent 与 e instanceof Event 均真）。
+    #[test]
+    fn worker_e2e_onerror_is_error_event() {
+        let mut vm = vm_with_compiler();
+
+        // worker 脚本：语法错误（编译失败）。
+        let worker_path = write_worker_script("function { 语法错误");
+        // 主脚本：建 Worker、设 addEventListener('error')，记录 instanceof 结果。
+        let main_script = format!(
+            "var w = new Worker('{}'); w.addEventListener('error', function(e) {{ globalThis.isEE = e instanceof ErrorEvent; globalThis.isE = e instanceof Event; }});",
+            worker_path.display()
+        );
+        vm.run(&Arc::new(compile_script(&main_script))).expect("主脚本应运行");
+
+        // 事件循环轮询至 globalThis.isEE 被设置（带截止，防 flaky）。
+        let deadline = Instant::now() + Duration::from_secs(5);
+        loop {
+            vm.deliver_worker_messages();
+            vm.cleanup_disconnected_workers();
+            if global_value_opt(&vm, "isEE").is_some() {
+                break;
+            }
+            if Instant::now() >= deadline {
+                panic!("5 秒内 onerror 未被调用");
+            }
+            std::thread::sleep(Duration::from_millis(10));
+        }
+        assert_eq!(
+            global_value_opt(&vm, "isEE"),
+            Some(JsValue::bool(true)),
+            "事件应 instanceof ErrorEvent"
+        );
+        assert_eq!(
+            global_value_opt(&vm, "isE"),
+            Some(JsValue::bool(true)),
+            "事件应 instanceof Event"
+        );
+
+        vm.shutdown_workers();
+        let _ = std::fs::remove_file(&worker_path);
+    }
+
     /// onmessageerror 交付辅助：无自然触发，直接单测交付辅助（handler 被调用、
     /// 事件 type 为 "messageerror"）。不钉触发可达性（当前架构不可达）。
     #[test]