fix: 补齐代理读取组与完整性级别语义

Cargo.lock

@@ -1160,7 +1160,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_builtins"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "chrono",
  "fast-float",
@@ -1185,7 +1185,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_bytecode"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "num-bigint",
  "oxide_log",
@@ -1193,7 +1193,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cfg"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_emit",
@@ -1204,7 +1204,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cli"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "ansi_term",
  "bumpalo",
@@ -1228,7 +1228,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_code_cache"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "lru",
  "oxide_bytecode",
@@ -1237,7 +1237,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_compiler"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1258,7 +1258,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_dce"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1272,7 +1272,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_emit"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "num-bigint",
  "oxc_allocator",
@@ -1288,7 +1288,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_engine"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1300,7 +1300,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_fold"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "num-bigint",
  "oxide_bytecode",
@@ -1312,7 +1312,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_ir"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_log",
@@ -1321,7 +1321,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_kernel"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1335,7 +1335,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_liveness"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1347,7 +1347,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_log"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "tracing",
  "tracing-appender",
@@ -1356,11 +1356,11 @@ dependencies = [
 
 [[package]]
 name = "oxide_net"
-version = "0.20.9"
+version = "0.20.10"
 
 [[package]]
 name = "oxide_parser"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxc_allocator",
  "oxc_ast",
@@ -1375,7 +1375,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_regalloc"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1391,7 +1391,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_runtime_api"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -1404,7 +1404,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_test262"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1424,7 +1424,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_types"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1437,7 +1437,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_vm"
-version = "0.20.9"
+version = "0.20.10"
 dependencies = [
  "bumpalo",
  "chrono",

Cargo.toml

@@ -25,7 +25,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.20.9"
+version = "0.20.10"
 edition = "2021"
 license = "MIT"
 rust-version = "1.80"

crates/oxide_builtins/src/object.rs

@@ -203,15 +203,20 @@ fn symbol_key_to_value(key: u32) -> JsValue {
 /// 代理感知的自身键收集（规范 [[OwnPropertyKeys]] 完整形态）：普通对象经
 /// walk_own_keys 加 walk_own_symbol_keys（整数键升序、字符串键插入序、Symbol
 /// 键插入序）；代理经 ownKeys trap——缺失落穿 target 的自身键，存在时以 trap
-/// 结果为主、target 键中不在 trap 的追加末尾（trap 序优先），target 上没有
-/// 的键丢弃（无存储槽可定位，描述符按缺失处理）。
+/// 结果为准（ToList 去重，重复抛 TypeError，非字符串/符号元素抛 TypeError），
+/// target 不可配置键须全部在 trap 结果中，target 不可扩展时 trap 结果须与
+/// target 键集完全一致；target 上不有的键以哨兵存储下标返回（无槽位，描述符
+/// 按缺失处理）。
 ///
 /// # 步骤
 /// 1. 非代理：walk_own_keys 加 walk_own_symbol_keys，存储对象即自身。
 /// 2. 代理：先递归落穿 target（target 自身为代理时再路由）取 target 键。
 /// 3. ownKeys trap 存在时 ToList 其结果（数组直读元素区、非数组按 length
-///    读整数索引区），逐元素 ToPropertyKey 去重。
-/// 4. 合并：trap 键在前（存储下标按 target 键定位），target 键补尾。
+///    读整数索引区），逐元素先 ToPropertyKey 再校验字符串/符号类型（规范
+///    步 7），重复键抛 TypeError（规范步 8）。
+/// 4. 不变量检查：target 不可配置键须在 trap 结果中；target 不可扩展时
+///    键集完全一致（缺失键与多余键均抛 TypeError）。
+/// 5. 返 trap 结果列表（trap 序），target 上有的键定位存储下标。
 ///
 /// # 边界与前提
 /// - `obj` 须为存活对象；代理的 target 由构造器校验为非空对象指针。
@@ -221,9 +226,19 @@ fn symbol_key_to_value(key: u32) -> JsValue {
 ///
 /// # 返回
 /// (键列表, 存储对象)：消费方读 meta/值一律经存储对象，不读代理本体。
+///
+/// # 错误语义
+/// - `Err` 携异常值：trap 抛错经 uncaught 侧通道还原原值重抛保身份；
+///   不变量与元素类型失败为 TypeError 值。
 pub type OwnKeys<'a> = (Vec<(u32, u32)>, &'a JsObject);
 
-pub fn own_keys_proxy_aware<'a, H: VmHost>(vm: &mut H, obj: &'a JsObject) -> Result<OwnKeys<'a>, String> {
+/// ownKeys 代理路径统一错误出口：优先从 uncaught 侧通道还原原始异常值
+/// （保 trap 抛出原值的身份），侧通道为空时按格式化文本构造异常。
+fn own_keys_trap_exc<H: VmHost>(vm: &mut H, msg: String) -> JsValue {
+    vm.take_uncaught_value().unwrap_or_else(|| crate::error::create_from_text(vm, &msg))
+}
+
+pub fn own_keys_proxy_aware<'a, H: VmHost>(vm: &mut H, obj: &'a JsObject) -> Result<OwnKeys<'a>, JsValue> {
     if !obj.is_proxy_obj() {
         let mut keys = walk_own_keys(vm, obj);
         keys.extend(walk_own_symbol_keys(vm, obj));
@@ -234,33 +249,44 @@ pub fn own_keys_proxy_aware<'a, H: VmHost>(vm: &mut H, obj: &'a JsObject) -> Res
     let target_obj = unsafe { &*target.as_js_object_ptr() };
     // 落穿：target 自身为代理时递归再路由，普通对象取其自身键。
     let (target_keys, storage) = own_keys_proxy_aware(vm, target_obj)?;
-    let trap_result = vm.proxy_call_trap(obj, vm.perm_intern("ownKeys"), &[target])?;
+    let trap_result = match vm.proxy_call_trap(obj, vm.perm_intern("ownKeys"), &[target]) {
+        Ok(r) => r,
+        Err(msg) => return Err(own_keys_trap_exc(vm, msg)),
+    };
     let Some(result) = trap_result else {
         return Ok((target_keys, storage));
     };
     if !result.is_object() {
-        return Err(oxide_runtime_api::format_error_message(
-            "TypeError",
-            "Proxy ownKeys trap returned a non-object",
-        ));
+        return Err(crate::error::create_type_error(vm, "Proxy ownKeys trap returned a non-object"));
     }
     // SAFETY: result 是非空对象指针。
     let result_obj = unsafe { &*result.as_js_object_ptr() };
     // ToList：数组直读元素区（hole 视为不存在）；非数组按 length 属性读整数
-    // 索引区。
+    // 索引区；逐元素先 ToPropertyKey 再校验元素须为字符串或符号（规范步 7），
+    // 重复键抛 TypeError（规范步 8）。
     let mut trap_keys: Vec<u32> = Vec::new();
     if result_obj.is_array() {
         for i in 0..result_obj.array_prop_count {
             if result_obj.prop_meta_at(i).is_some_and(|m| m.is_hole()) {
                 continue;
             }
-            let si = vm.to_property_key_si(result_obj.get_prop_at(i))?;
-            if !trap_keys.contains(&si) {
-                trap_keys.push(si);
+            let raw = result_obj.get_prop_at(i);
+            let si = vm.to_property_key_si(raw).map_err(|msg| own_keys_trap_exc(vm, msg))?;
+            if !raw.is_string() && !raw.is_symbol() {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "Proxy ownKeys trap returned a key that is not a string or symbol",
+                ));
             }
+            if trap_keys.contains(&si) {
+                return Err(crate::error::create_type_error(vm, "Proxy ownKeys trap returned duplicate entries"));
+            }
+            trap_keys.push(si);
         }
     } else {
-        let length_val = vm.ordinary_get(result_obj, vm.perm_intern("length"), result)?;
+        let length_val = vm
+            .ordinary_get(result_obj, vm.perm_intern("length"), result)
+            .map_err(|msg| own_keys_trap_exc(vm, msg))?;
         let len = oxide_runtime_api::to_length(length_val);
         for i in 0..len {
             // 大索引（2^30 以上）走字符串键形态（规范数字串）。
@@ -269,24 +295,69 @@ pub fn own_keys_proxy_aware<'a, H: VmHost>(vm: &mut H, obj: &'a JsObject) -> Res
             } else {
                 vm.perm_intern(&i.to_string())
             };
-            let val = vm.ordinary_get(result_obj, key_si, result)?;
-            let si = vm.to_property_key_si(val)?;
-            if !trap_keys.contains(&si) {
-                trap_keys.push(si);
+            let val = vm.ordinary_get(result_obj, key_si, result).map_err(|msg| own_keys_trap_exc(vm, msg))?;
+            let si = vm.to_property_key_si(val).map_err(|msg| own_keys_trap_exc(vm, msg))?;
+            if !val.is_string() && !val.is_symbol() {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "Proxy ownKeys trap returned a key that is not a string or symbol",
+                ));
+            }
+            if trap_keys.contains(&si) {
+                return Err(crate::error::create_type_error(vm, "Proxy ownKeys trap returned duplicate entries"));
+            }
+            trap_keys.push(si);
+        }
+    }
+    // 规范步 11-22：target 自身键按可配置性分两档——不可配置键无论 target
+    // 是否可扩展都须在 trap 结果中（缺失抛 TypeError）；target 可扩展时余键
+    // 不受限，不可扩展时 target 全部键须齐全且 trap 结果不得含 target 之外
+    // 的键（两侧缺失均抛 TypeError）。
+    let mut non_configurable: Vec<u32> = Vec::new();
+    let mut configurable: Vec<u32> = Vec::new();
+    for (si, store) in &target_keys {
+        let non_cfg = storage
+            .prop_meta_at(*store)
+            .map(|m| !m.attributes.configurable())
+            .unwrap_or(false);
+        if non_cfg {
+            non_configurable.push(*si);
+        } else {
+            configurable.push(*si);
+        }
+    }
+    for si in &non_configurable {
+        if !trap_keys.contains(si) {
+            return Err(crate::error::create_type_error(
+                vm,
+                "Proxy ownKeys trap omitted a non-configurable target key",
+            ));
+        }
+    }
+    if !proxy_is_extensible(vm, target_obj).map_err(|msg| own_keys_trap_exc(vm, msg))? {
+        for si in &configurable {
+            if !trap_keys.contains(si) {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "Proxy ownKeys trap omitted a key of a non-extensible target",
+                ));
+            }
+        }
+        for si in &trap_keys {
+            if !target_keys.iter().any(|(k, _)| k == si) {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "Proxy ownKeys trap returned a key not present on a non-extensible target",
+                ));
             }
         }
     }
-    // 合并：trap 序优先，target 键补尾；target 上没有的键丢弃。
-    let mut keys: Vec<(u32, u32)> = Vec::with_capacity(trap_keys.len() + target_keys.len());
+    // 返 trap 结果列表（trap 序）：target 上有的键定位存储下标，target 上不
+    // 有的键用哨兵下标（无槽位，meta 读恒 None，消费方按键路由描述符读）。
+    let mut keys: Vec<(u32, u32)> = Vec::with_capacity(trap_keys.len());
     for si in &trap_keys {
-        if let Some(store) = target_keys.iter().find(|(k, _)| k == si).map(|(_, s)| *s) {
-            keys.push((*si, store));
-        }
-    }
-    for (si, store) in target_keys {
-        if !trap_keys.contains(&si) {
-            keys.push((si, store));
-        }
+        let store = target_keys.iter().find(|(k, _)| k == si).map(|(_, s)| *s).unwrap_or(u32::MAX);
+        keys.push((*si, store));
     }
     Ok((keys, storage))
 }
@@ -377,7 +448,7 @@ pub fn object_get_own_property_symbols<H: VmHost>(vm: &mut H, args: &[u8]) -> Na
     // 代理经 ownKeys trap 路由（缺失落穿 target）；本入口只取 Symbol 键。
     let (keys, _storage) = match own_keys_proxy_aware(vm, obj) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
     let symbols: Vec<JsValue> = keys
         .into_iter()
@@ -797,7 +868,7 @@ pub fn object_keys<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     // Symbol 键在收集器内与字符串键同序，须在此过滤。
     let (keys, storage) = match own_keys_proxy_aware(vm, obj) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
     let owned_keys: Vec<(u32, u32)> = keys
         .into_iter()
@@ -910,25 +981,29 @@ pub fn object_assign<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         if let Err(exc) = ensure_deferred_own_keys(vm, unsafe { &*source_ptr }) {
             return NativeResult::Err(exc);
         }
-        let source_keys: Vec<(u32, u32)> = {
-            let source = unsafe { &*source_ptr };
-            // 源为代理时经 ownKeys trap 路由（缺失落穿 target）；meta 读经存储对象。
-            let (keys, storage) = match own_keys_proxy_aware(vm, source) {
-                Ok(k) => k,
-                Err(err) => return NativeResult::Err(crate::error::create_from_text(vm, &err)),
-            };
-            keys.into_iter()
-                // CopyDataProperties：只拷贝可枚举自身属性（无显式 meta 视为可枚举）。
-                .filter(|(_si, offset)| {
-                    storage
-                        .prop_meta_at(*offset)
-                        .map(|m| m.attributes.enumerable())
-                        .unwrap_or(PropAttributes::DEFAULT_DATA.enumerable())
-                })
-                .collect()
+        let source = unsafe { &*source_ptr };
+        // 源为代理时经 ownKeys trap 路由（缺失落穿 target）；trap 结果可含
+        // target 上不有的键（哨兵下标，无槽位），须按键路由描述符读。
+        let (source_keys, _storage) = match own_keys_proxy_aware(vm, source) {
+            Ok(k) => k,
+            Err(exc) => return NativeResult::Err(exc),
         };
+        let enum_si = vm.perm_intern("enumerable");
         for (si, _offset) in source_keys {
-            let source = unsafe { &*source_ptr };
+            // CopyDataProperties：desc = ? from.[[GetOwnProperty]](nextKey)，
+            // desc 缺失（代理 target 上不有的键）或不可枚举均跳过，不拷贝。
+            let desc = match own_descriptor_of(vm, source, si) {
+                Ok(d) => d,
+                Err(exc) => return NativeResult::Err(exc),
+            };
+            let Some(desc_val) = desc else { continue };
+            let enumerable = match desc_field_bool(vm, desc_val, enum_si) {
+                Ok(e) => e,
+                Err(exc) => return NativeResult::Err(exc),
+            };
+            if !enumerable {
+                continue;
+            }
             // ordinary_get 取值（receiver = 源对象）：数据属性等价直读，访问器属性
             // 触发 getter；getter 抛错按规范中断整个 assign。
             let val = match vm.ordinary_get(source, si, source_val) {
@@ -1277,10 +1352,7 @@ fn define_all_from_properties<H: VmHost>(
         let props = unsafe { &*props_ptr };
         // 描述符对象为代理时经 ownKeys trap 路由（缺失落穿 target）；meta 读经
         // 存储对象。
-        let (keys, storage) = match own_keys_proxy_aware(vm, props) {
-            Ok(k) => k,
-            Err(msg) => return Err(DefineDescFailure::Engine(msg)),
-        };
+        let (keys, storage) = own_keys_proxy_aware(vm, props)?;
         // 先物化可枚举自身键（meta 读经存储对象），再逐键经 ordinary_get 取
         // 描述符值（触发访问器 getter，异常原值传播）。
         let enumerable: Vec<u32> = keys
@@ -1362,9 +1434,13 @@ pub fn object_define_property<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResul
 fn own_descriptor_of<H: VmHost>(vm: &mut H, obj: &JsObject, key_si: u32) -> Result<Option<JsValue>, JsValue> {
     // Proxy [[GetOwnProperty]]：getOwnPropertyDescriptor trap 以（target、P）
     // 调用；trap 缺失落穿 target 的自身描述符（target 自身为代理时经递归再
-    // 路由）；trap 返 undefined 表示无属性；返非对象按规范抛 TypeError。
+    // 路由）；trap 返 undefined 表示无属性（target 自身属性不可配置或 target
+    // 不可扩展时抛 TypeError）；trap 返非对象按规范抛 TypeError；trap 返对象
+    // 时与 target 自身描述符做不变量交叉检查（target 不可扩展时）。
     if obj.is_proxy_obj() {
         let target = crate::proxy::proxy_state_ref(obj).expect("状态盒").target;
+        // SAFETY: target 由构造器校验为非空对象指针。
+        let target_obj = unsafe { &*target.as_js_object_ptr() };
         let key = key_si_to_js_key(vm, key_si);
         let trap_result = match vm.proxy_call_trap(obj, vm.perm_intern("getOwnPropertyDescriptor"), &[target, key]) {
             Ok(r) => r,
@@ -1377,15 +1453,33 @@ fn own_descriptor_of<H: VmHost>(vm: &mut H, obj: &JsObject, key_si: u32) -> Resu
         };
         if let Some(r) = trap_result {
             if r.is_undefined() {
+                // 规范步 10：targetDesc 缺失直接返 undefined；targetDesc 不可
+                // 配置或 target 不可扩展均抛 TypeError。
+                let target_desc = own_descriptor_of(vm, target_obj, key_si)?;
+                if let Some(td) = target_desc {
+                    if !desc_field_bool(vm, td, vm.perm_intern("configurable"))? {
+                        return Err(crate::error::create_type_error(
+                            vm,
+                            "getOwnPropertyDescriptor trap returned undefined for a non-configurable target property",
+                        ));
+                    }
+                }
+                if !proxy_is_extensible(vm, target_obj).map_err(|msg| crate::error::create_from_text(vm, &msg))? {
+                    return Err(crate::error::create_type_error(
+                        vm,
+                        "getOwnPropertyDescriptor trap returned undefined for a non-extensible target",
+                    ));
+                }
                 return Ok(None);
             }
             if !r.is_object() {
                 return Err(crate::error::create_type_error(vm, "getOwnPropertyDescriptor trap returned a non-object"));
             }
+            proxy_gopd_invariant_check(vm, target_obj, key_si, r)?;
             return Ok(Some(r));
         }
         // SAFETY: target 由构造器校验为非空对象指针。
-        return own_descriptor_of(vm, unsafe { &*target.as_js_object_ptr() }, key_si);
+        return own_descriptor_of(vm, target_obj, key_si);
     }
     // deferred namespace 求值触发（[[GetOwnProperty]]，symbol-like 键内部 no-op）。
     // 触发失败时 uncaught 侧通道已还原为原错误值，原值重抛保身份。
@@ -1469,6 +1563,149 @@ fn own_descriptor_of<H: VmHost>(vm: &mut H, obj: &JsObject, key_si: u32) -> Resu
     Ok(Some(JsValue::from_js_object(desc)))
 }
 
+/// ToPropertyDescriptor 布尔字段读：字段缺失按 false（规范默认值），存在时
+/// 经 ToBoolean 投影。
+fn desc_field_bool<H: VmHost>(vm: &mut H, desc: JsValue, prop_si: u32) -> Result<bool, JsValue> {
+    match own_field(vm, desc, prop_si)? {
+        Some(v) => Ok(oxide_runtime_api::to_boolean(v)),
+        None => Ok(false),
+    }
+}
+
+/// [[IsExtensible]]（代理感知）：代理经 isExtensible trap 路由（实参 target，
+/// 结果经 ToBoolean 投影，trap 报告须与 target 实际可扩展状态一致，不一致抛
+/// TypeError），trap 缺失落穿 target；普通对象读自身标志。
+fn proxy_is_extensible<H: VmHost>(vm: &mut H, obj: &JsObject) -> Result<bool, String> {
+    if !obj.is_proxy_obj() {
+        return Ok(obj.is_extensible());
+    }
+    let target = crate::proxy::proxy_state_ref(obj).expect("状态盒").target;
+    // SAFETY: target 由构造器校验为非空对象指针。
+    let target_obj = unsafe { &*target.as_js_object_ptr() };
+    let trap_result = vm.proxy_call_trap(obj, vm.perm_intern("isExtensible"), &[target])?;
+    let Some(r) = trap_result else {
+        return proxy_is_extensible(vm, target_obj);
+    };
+    let result = oxide_runtime_api::to_boolean(r);
+    if result != proxy_is_extensible(vm, target_obj)? {
+        return Err(oxide_runtime_api::format_error_message(
+            "TypeError",
+            "Proxy isExtensible trap result is inconsistent with target",
+        ));
+    }
+    Ok(result)
+}
+
+/// Proxy [[GetOwnProperty]] trap 返回值的不变量检查（规范 [[GetOwnProperty]]
+/// 步 11-16 形态）：target 不可扩展时经 `IsCompatiblePropertyDescriptor` 全量
+/// 交叉检查（target 自身属性必须存在、不得报告可配置、enumerable 须一致、
+/// 访问器 get/set 须一致、数据描述符不得由可写放宽为不可写、形态须一致）；
+/// 结果描述符不可配置时 target 自身属性必须存在且不可配置，且数据描述符不得
+/// 由可写放宽为不可写（与可扩展性无关）。违反抛 TypeError。
+fn proxy_gopd_invariant_check<H: VmHost>(
+    vm: &mut H, target: &JsObject, key_si: u32, result_desc: JsValue,
+) -> Result<(), JsValue> {
+    let cfg_si = vm.perm_intern("configurable");
+    let enum_si = vm.perm_intern("enumerable");
+    let get_si = vm.perm_intern("get");
+    let set_si = vm.perm_intern("set");
+    let writable_si = vm.perm_intern("writable");
+    let extensible = proxy_is_extensible(vm, target).map_err(|msg| crate::error::create_from_text(vm, &msg))?;
+    let target_desc = own_descriptor_of(vm, target, key_si)?;
+    // IsCompatiblePropertyDescriptor：仅 target 不可扩展时执行。
+    if !extensible {
+        let Some(td) = target_desc else {
+            return Err(crate::error::create_type_error(
+                vm,
+                "getOwnPropertyDescriptor trap reported a property that does not exist on a non-extensible target",
+            ));
+        };
+        if desc_field_bool(vm, result_desc, cfg_si)? {
+            return Err(crate::error::create_type_error(
+                vm,
+                "getOwnPropertyDescriptor trap reported a configurable descriptor for a non-extensible target property",
+            ));
+        }
+        if desc_field_bool(vm, result_desc, enum_si)? != desc_field_bool(vm, td, enum_si)? {
+            return Err(crate::error::create_type_error(
+                vm,
+                "getOwnPropertyDescriptor trap reported a different enumerable flag for a non-configurable target property",
+            ));
+        }
+        let result_get = own_field(vm, result_desc, get_si)?;
+        let target_get = own_field(vm, td, get_si)?;
+        if target_get.is_some() {
+            if result_get.is_none() || result_get != target_get {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "getOwnPropertyDescriptor trap reported a different getter for a non-configurable target accessor",
+                ));
+            }
+            let target_set = own_field(vm, td, set_si)?;
+            let result_set = own_field(vm, result_desc, set_si)?;
+            if target_set.is_some() {
+                if result_set.is_none() || result_set != target_set {
+                    return Err(crate::error::create_type_error(
+                        vm,
+                        "getOwnPropertyDescriptor trap reported a different setter for a non-configurable target accessor",
+                    ));
+                }
+            } else if result_set.is_some() {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "getOwnPropertyDescriptor trap reported a setter for a target accessor without setter",
+                ));
+            }
+        } else {
+            if result_get.is_some() {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "getOwnPropertyDescriptor trap reported a getter for a non-configurable target data property",
+                ));
+            }
+            if own_field(vm, result_desc, set_si)?.is_some() {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "getOwnPropertyDescriptor trap reported a setter for a non-configurable target data property",
+                ));
+            }
+            if !desc_field_bool(vm, result_desc, writable_si)? && desc_field_bool(vm, td, writable_si)? {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "getOwnPropertyDescriptor trap reported a non-writable descriptor for a writable target property",
+                ));
+            }
+        }
+    }
+    // 结果描述符不可配置：target 自身属性必须存在且不可配置（与可扩展性无关）；
+    // 数据描述符不得由可写放宽为不可写。
+    if !desc_field_bool(vm, result_desc, cfg_si)? {
+        match target_desc {
+            None => {
+                return Err(crate::error::create_type_error(
+                    vm,
+                    "getOwnPropertyDescriptor trap reported a non-configurable descriptor for a property that does not exist on the target",
+                ));
+            }
+            Some(td) => {
+                if desc_field_bool(vm, td, cfg_si)? {
+                    return Err(crate::error::create_type_error(
+                        vm,
+                        "getOwnPropertyDescriptor trap reported a non-configurable descriptor for a configurable target property",
+                    ));
+                }
+                if !desc_field_bool(vm, result_desc, writable_si)? && desc_field_bool(vm, td, writable_si)? {
+                    return Err(crate::error::create_type_error(
+                        vm,
+                        "getOwnPropertyDescriptor trap reported a non-writable descriptor for a writable target property",
+                    ));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
 /// 分配空描述符对象（proto = %Object.prototype%）。
 fn alloc_desc_object<H: VmHost>(vm: &mut H) -> *mut JsObject {
     let desc_proto = vm.builtin_proto(ProtoKind::ObjectProto);
@@ -1540,7 +1777,7 @@ pub fn object_get_own_property_descriptors<H: VmHost>(vm: &mut H, args: &[u8]) -
     // 代理经 ownKeys trap 路由（缺失落穿 target）。
     let (keys, _storage) = match own_keys_proxy_aware(vm, obj) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
 
     // 结果对象：proto = %Object.prototype%。
@@ -1667,8 +1904,95 @@ fn seal_own_prop_meta(obj: &mut JsObject, store: u32) {
     }
 }
 
+/// 代理 [[PreventExtensions]]（规范 ProxyPreventExtensions）：preventExtensions
+/// trap 以（target）调用，结果经 ToBoolean 投影后须与 target 实际可扩展状态
+/// 一致（不一致抛 TypeError）；trap 缺失落穿 target 的普通 preventExtensions
+/// （置不可扩展标志，返 true）。
+fn proxy_prevent_extensions<H: VmHost>(vm: &mut H, obj: &JsObject) -> Result<bool, JsValue> {
+    let target = crate::proxy::proxy_state_ref(obj).expect("状态盒").target;
+    // SAFETY: target 由构造器校验为非空对象指针。
+    let target_obj = unsafe { &*target.as_js_object_ptr() };
+    let trap_result =
+        match vm.proxy_call_trap(obj, vm.perm_intern("preventExtensions"), &[target]) {
+            Ok(r) => r,
+            Err(msg) => return Err(own_keys_trap_exc(vm, msg)),
+        };
+    let Some(r) = trap_result else {
+        // OrdinaryPreventExtensions(target)：置不可扩展标志。
+        // SAFETY: target 由构造器校验为非空对象指针。
+        unsafe { &mut *target.as_js_object_ptr() }.set_extensible(false);
+        return Ok(true);
+    };
+    let result = oxide_runtime_api::to_boolean(r);
+    let target_extensible =
+        proxy_is_extensible(vm, target_obj).map_err(|msg| crate::error::create_from_text(vm, &msg))?;
+    if result != target_extensible {
+        return Err(crate::error::create_type_error(
+            vm,
+            "Proxy preventExtensions trap result is inconsistent with target",
+        ));
+    }
+    Ok(result)
+}
+
+/// 代理完整性级别（规范 SetIntegrityLevel）：[[PreventExtensions]]（代理感知）
+/// 后 [[OwnPropertyKeys]]（代理感知），逐键 DefinePropertyOrThrow（经
+/// defineProperty trap 路由，trap 缺失落穿 target）。seal 仅置 configurable:
+/// false；freeze 对数据属性额外置 writable: false（规范步 7b 先读 currentDesc
+/// 区分数据/访问器，访问器不写 writable 字段）。
+fn proxy_set_integrity_level<H: VmHost>(
+    vm: &mut H, obj_ptr: *mut JsObject, frozen: bool,
+) -> Result<(), JsValue> {
+    // SAFETY: obj_ptr 为存活对象指针。
+    let obj = unsafe { &*obj_ptr };
+    proxy_prevent_extensions(vm, obj)?;
+    let (keys, _storage) = own_keys_proxy_aware(vm, obj)?;
+    let cfg_si = vm.perm_intern("configurable");
+    let writable_si = vm.perm_intern("writable");
+    let get_si = vm.perm_intern("get");
+    let set_si = vm.perm_intern("set");
+    for (si, _pos) in keys {
+        // freeze 先读 currentDesc 区分数据与访问器（规范步 7b）；seal 的 desc
+        // 恒为 {Configurable: false}，无需读描述符。
+        let is_accessor = if frozen {
+            match own_descriptor_of(vm, obj, si)? {
+                Some(desc) => {
+                    own_field(vm, desc, get_si)?.is_some() || own_field(vm, desc, set_si)?.is_some()
+                }
+                None => false,
+            }
+        } else {
+            false
+        };
+        let desc = alloc_desc_object(vm);
+        let sh_ptr = vm.shape_forge_ptr() as *const ShapeForge;
+        // SAFETY: desc 为本函数刚分配的 epoch 对象；sh 为 kernel 永久引用。
+        let d: &mut JsObject = unsafe { &mut *desc };
+        let sh = unsafe { &*sh_ptr };
+        push_desc_prop(d, sh, cfg_si, JsValue::bool(false));
+        if frozen && !is_accessor {
+            push_desc_prop(d, sh, writable_si, JsValue::bool(false));
+        }
+        match define_from_descriptor(vm, obj_ptr, si, JsValue::from_js_object(desc)) {
+            Ok(()) => {}
+            Err(DefineDescFailure::User(exc)) => return Err(exc),
+            Err(DefineDescFailure::Engine(msg)) => {
+                // 定义期用户代码（Proxy trap）抛出的原始异常值原值重抛。
+                if let Some(exc) = vm.take_uncaught_value() {
+                    return Err(exc);
+                }
+                return Err(crate::error::create_define_failure(vm, &msg));
+            }
+        }
+    }
+    Ok(())
+}
+
 /// `Object.freeze(obj)`：冻结对象（不可扩展 + 全部属性不可配置/不可写），返回原对象。
 ///
+/// 代理按规范 SetIntegrityLevel 走通用完整性路径（preventExtensions + ownKeys +
+///   defineProperty 均代理感知），不经 freeze trap（freeze trap 仅 Reflect 通道使用）。
+///
 /// # 副作用
 /// - 逐属性写 meta 使 `has_prop_meta()` 恒 true，IC 直写路径自动失效，后续
 ///   写/define 一律回落 ordinary_set / define 检查（writable/configurable 判定）
@@ -1682,6 +2006,12 @@ pub fn object_freeze<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         return NativeResult::Ok(val);
     }
     let obj_ptr = val.as_js_object_ptr();
+    if unsafe { &*obj_ptr }.is_proxy_obj() {
+        return match proxy_set_integrity_level(vm, obj_ptr, true) {
+            Ok(()) => NativeResult::Ok(val),
+            Err(exc) => NativeResult::Err(exc),
+        };
+    }
     // [[OwnPropertyKeys]] 触发（deferred namespace 先求值，cyclic 抛错）。
     if let Err(exc) = ensure_deferred_own_keys(vm, unsafe { &*obj_ptr }) {
         return NativeResult::Err(exc);
@@ -1723,6 +2053,9 @@ pub fn object_freeze<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
 
 /// `Object.seal(obj)`：密封对象（不可扩展 + 全部属性不可配置），返回原对象。
 ///
+/// 代理按规范 SetIntegrityLevel 走通用完整性路径（preventExtensions + ownKeys +
+///   defineProperty 均代理感知），不经 seal trap（seal trap 仅 Reflect 通道使用）。
+///
 /// # 副作用
 /// - 逐属性写 meta 使 `has_prop_meta()` 恒 true，IC 直写路径自动失效，后续
 ///   define 回落 non-configurable 检查（已有属性写仍可正常进行）
@@ -1736,6 +2069,12 @@ pub fn object_seal<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         return NativeResult::Ok(val);
     }
     let obj_ptr = val.as_js_object_ptr();
+    if unsafe { &*obj_ptr }.is_proxy_obj() {
+        return match proxy_set_integrity_level(vm, obj_ptr, false) {
+            Ok(()) => NativeResult::Ok(val),
+            Err(exc) => NativeResult::Err(exc),
+        };
+    }
     // [[OwnPropertyKeys]] 触发（deferred namespace 先求值，cyclic 抛错）。
     if let Err(exc) = ensure_deferred_own_keys(vm, unsafe { &*obj_ptr }) {
         return NativeResult::Err(exc);
@@ -1894,7 +2233,7 @@ pub fn object_get_own_property_names<H: VmHost>(vm: &mut H, args: &[u8]) -> Nati
     // getOwnPropertySymbols，须在此过滤。
     let (keys, _storage) = match own_keys_proxy_aware(vm, obj) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
     let keys = keys.into_iter().filter(|(si, _)| !is_symbol_key(*si)).collect::<Vec<_>>();
     let n = keys.len();
@@ -2366,9 +2705,8 @@ pub fn object_proto_to_string<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResul
 /// # 步骤
 /// 1. 先 ToPropertyKey 求键（spec 顺序：键先于 ToObject）。
 /// 2. ToObject 装箱 this（null/undefined 抛 TypeError，原始值装箱后查 own 槽）。
-///
-/// # 边界与前提
-/// - TypedArray 界内整数键经统一数值键门预支恒 true，不查形状槽。
+/// 3. 经 `? [[GetOwnProperty]]` 判定（代理感知：trap 路由与落穿、TA 数值键门、
+///    未初始化命名空间导出抛 ReferenceError）。
 pub fn object_proto_has_own_property<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
         return NativeResult::Ok(JsValue::bool(false));
@@ -2388,25 +2726,13 @@ pub fn object_proto_has_own_property<H: VmHost>(vm: &mut H, args: &[u8]) -> Nati
         Err(msg) => return NativeResult::Err(crate::error::create_type_error(vm, &msg)),
     };
     let obj = unsafe { &*obj_val.as_js_object_ptr() };
-    // 统一数值键门（exotic [[HasOwnProperty]]）：界内整数键恒存在；数字无效
-    // 与非数字串键落下方槽位判定（命名空间检查在门臂之后，TA 非命名空间
-    // 不触达）。
-    if obj.is_typed_array_obj()
-        && matches!(
-            crate::typed_array::ta_index_gate(vm, obj, key_si),
-            crate::typed_array::TaIndexGate::NumericValid(_)
-        )
-    {
-        return NativeResult::Ok(JsValue::bool(true));
+    // HasOwnProperty 经 `? [[GetOwnProperty]]`（代理感知：trap 路由与落穿、
+    // TA 数值键门、未初始化命名空间导出抛 ReferenceError）。
+    match own_descriptor_of(vm, obj, key_si) {
+        Ok(Some(_)) => NativeResult::Ok(JsValue::bool(true)),
+        Ok(None) => NativeResult::Ok(JsValue::bool(false)),
+        Err(exc) => NativeResult::Err(exc),
     }
-    if vm.get_own_property_slot(obj, key_si).is_none() {
-        return NativeResult::Ok(JsValue::bool(false));
-    }
-    // HasOwnProperty 经 `? [[GetOwnProperty]]`：未初始化导出抛 ReferenceError。
-    if let Err(msg) = namespace_export_get(obj, key_si) {
-        return NativeResult::Err(crate::error::create_reference_error(vm, msg));
-    }
-    NativeResult::Ok(JsValue::bool(true))
 }
 
 /// `Object.prototype.propertyIsEnumerable(key)`：指定自身属性是否可枚举。
@@ -2414,10 +2740,8 @@ pub fn object_proto_has_own_property<H: VmHost>(vm: &mut H, args: &[u8]) -> Nati
 /// # 步骤
 /// 1. 先 ToPropertyKey 求键。
 /// 2. ToObject 装箱 this（null/undefined 抛 TypeError）。
-///
-/// # 边界与前提
-/// - TypedArray 界内整数键经统一数值键门预支恒 true（enumerable 恒真），
-///   不读 meta。
+/// 3. 先经 `? [[GetOwnProperty]]`（代理感知）取描述符，缺失返 false，
+///    存在时读 enumerable 位（TA 界内整数键经数值键门恒 true）。
 pub fn object_proto_property_is_enumerable<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
         return NativeResult::Ok(JsValue::bool(false));
@@ -2437,28 +2761,19 @@ pub fn object_proto_property_is_enumerable<H: VmHost>(vm: &mut H, args: &[u8]) -
         Err(msg) => return NativeResult::Err(crate::error::create_type_error(vm, &msg)),
     };
     let obj = unsafe { &*obj_val.as_js_object_ptr() };
-    // 统一数值键门（exotic PropertyIsEnumerable）：界内整数键恒可枚举；
-    // 数字无效与非数字串键落下方 meta 读取。
-    if obj.is_typed_array_obj()
-        && matches!(
-            crate::typed_array::ta_index_gate(vm, obj, key_si),
-            crate::typed_array::TaIndexGate::NumericValid(_)
-        )
-    {
-        return NativeResult::Ok(JsValue::bool(true));
+    // PropertyIsEnumerable 先经 `? [[GetOwnProperty]]`（代理感知）再取
+    // enumerable 位。
+    match own_descriptor_of(vm, obj, key_si) {
+        Ok(Some(desc)) => {
+            let enumerable = match desc_field_bool(vm, desc, vm.perm_intern("enumerable")) {
+                Ok(b) => b,
+                Err(exc) => return NativeResult::Err(exc),
+            };
+            NativeResult::Ok(JsValue::bool(enumerable))
+        }
+        Ok(None) => NativeResult::Ok(JsValue::bool(false)),
+        Err(exc) => NativeResult::Err(exc),
     }
-    let Some(pos) = vm.get_own_property_slot(obj, key_si) else {
-        return NativeResult::Ok(JsValue::bool(false));
-    };
-    // PropertyIsEnumerable 同样先经 `? [[GetOwnProperty]]` 再取 enumerable 位。
-    if let Err(msg) = namespace_export_get(obj, key_si) {
-        return NativeResult::Err(crate::error::create_reference_error(vm, msg));
-    }
-    let enumerable = obj
-        .prop_meta_at(pos)
-        .map(|meta| meta.attributes.enumerable())
-        .unwrap_or(PropAttributes::DEFAULT_DATA.enumerable());
-    NativeResult::Ok(JsValue::bool(enumerable))
 }
 
 /// `Object.prototype.__defineGetter__(key, getter)`：把 key 定义为访问器属性，
@@ -2529,7 +2844,7 @@ pub fn object_entries<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     // （accessor 的 this 指向存储对象）。
     let (keys, storage) = match own_keys_proxy_aware(vm, obj) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
     let owned_keys: Vec<(u32, u32)> = keys
         .into_iter()
@@ -2719,7 +3034,7 @@ pub fn object_values<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     // （accessor 的 this 指向存储对象）。
     let (keys, storage) = match own_keys_proxy_aware(vm, obj) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
     let owned_keys: Vec<(u32, u32)> = keys
         .into_iter()

crates/oxide_builtins/src/reflect.rs

@@ -264,7 +264,7 @@ pub fn reflect_own_keys<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     // 字符串键同序（整数键升序、字符串键插入序、Symbol 键插入序）。
     let (mut keys, storage) = match crate::object::own_keys_proxy_aware(vm, target) {
         Ok(k) => k,
-        Err(msg) => return NativeResult::Err(crate::error::create_from_text(vm, &msg)),
+        Err(exc) => return NativeResult::Err(exc),
     };
     // 数组 length 是虚拟自身属性（无 shape 槽、不在形状链）：注入字符串组首
     // （创建序第一枚字符串键），存储下标哨兵 u32::MAX = 无槽位（消费端只读

crates/oxide_builtins/src/regexp.rs

@@ -517,14 +517,16 @@ pub fn regexp_constructor<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         }
     }
 
-    // lastIndex 作实例自身属性写入（缺省描述符，与既有构造器口径一致）。
+    // lastIndex 作实例自身属性写入（规范 22.2.7.1：writable:true /
+    // enumerable:false / configurable:false）。
     {
         let li_si = vm.perm_intern("lastIndex");
         let shape_id = vm.make_shape(unsafe { (*this_ptr).shape_id() }, li_si);
         unsafe {
             let obj = &mut *this_ptr;
             obj.set_shape_id(shape_id);
-            obj.push_prop(JsValue::int(0));
+            let li_pos = obj.push_prop(JsValue::int(0));
+            obj.set_data_meta(li_pos, oxide_types::object::PropAttributes::new(true, false, false));
             obj.type_tag = JsObject::OBJ_TYPE_REGEXP;
             // source/flags 存实例字段：原型访问器从本字段读取，不作为自身属性枚举。
             obj.set_regexp_source(vm.new_string_units_owned(pattern_units));

crates/oxide_vm/src/dispatch/call.rs

@@ -789,10 +789,18 @@ impl Vm {
         let key_val = self.regs[b];
         let prop_name_si = self.property_key_si(key_val)?;
         let super_obj = unsafe { &*super_base.as_js_object_ptr() };
+        let pc_before = self.pc;
         let val = self.ordinary_get_with_target(super_obj, prop_name_si, self.regs[a], rd as u8)?;
-        if self.accessor_frame_target_reg.take().is_none() {
-            self.regs[rd] = val;
+        if self.accessor_frame_target_reg.take().is_some() {
+            // getter 帧已入栈：结果由帧续行交付，此处不写结果寄存器。
+            return Ok(true);
         }
+        if self.pc != pc_before {
+            // 读路径在途抛错已展开到 catch/finally 入口：pc 由处理器接管，
+            // 结果寄存器不得再写（regs[0] 持在途异常）。
+            return Ok(true);
+        }
+        self.regs[rd] = val;
         Ok(false)
     }
 

crates/oxide_vm/src/dispatch/property.rs

@@ -370,11 +370,21 @@ impl Vm {
         // 命中会绕过 get trap 直读代理自身属性槽（恒 miss 守卫的读入口侧）。
         if obj.is_proxy_obj() {
             let prop_name_si = self.property_key_si(self.regs[b])?;
+            // 先消费扩展字：代理分支不写回 IC（槽恒零），getter 帧的返回地址
+            // 与展开后的 catch 入口都以 pc 接管，调用后不得再推进。
+            let _ = ic_helper::read_ic_slot0(&self.bytecode, &mut self.pc);
+            let pc_before = self.pc;
             let val = self.ordinary_get_with_target(obj, prop_name_si, val, a as u8)?;
-            if self.accessor_frame_target_reg.take().is_none() {
-                self.regs[a] = val;
+            if self.accessor_frame_target_reg.take().is_some() {
+                // getter 帧已入栈：结果由帧续行交付，此处不写结果寄存器。
+                return Ok(());
             }
-            self.pc += IC_EXT_WORDS;
+            if self.pc != pc_before {
+                // 读路径在途抛错已展开到 catch/finally 入口：pc 由处理器接管，
+                // 结果寄存器不得再写（regs[0] 持在途异常）。
+                return Ok(());
+            }
+            self.regs[a] = val;
             return Ok(());
         }
         // 入口快判：键寄存器恒为 perm 串，指针相等即键为 "length"；
@@ -390,10 +400,18 @@ impl Vm {
         if obj.has_prop_meta() {
             // meta 对象整对象走慢路径，此时才解析键。
             let prop_name_si = self.property_key_si(self.regs[b])?;
+            let pc_before = self.pc;
             let val = self.ordinary_get_with_target(obj, prop_name_si, val, a as u8)?;
-            if self.accessor_frame_target_reg.take().is_none() {
-                self.regs[a] = val;
+            if self.accessor_frame_target_reg.take().is_some() {
+                // getter 帧已入栈：结果由帧续行交付，此处不写结果寄存器。
+                return Ok(());
             }
+            if self.pc != pc_before {
+                // 读路径在途抛错已展开到 catch/finally 入口：pc 由处理器接管，
+                // 结果寄存器不得再写（regs[0] 持在途异常）。
+                return Ok(());
+            }
+            self.regs[a] = val;
             return Ok(());
         }
 
@@ -570,10 +588,18 @@ impl Vm {
             return Ok(());
         };
         let obj = unsafe { &*obj_ptr };
+        let pc_before = self.pc;
         let val = self.ordinary_get_with_target(obj, prop_name_si, self.regs[rd], a as u8)?;
-        if self.accessor_frame_target_reg.take().is_none() {
-            self.regs[a] = val;
+        if self.accessor_frame_target_reg.take().is_some() {
+            // getter 帧已入栈：结果由帧续行交付，此处不写结果寄存器。
+            return Ok(());
         }
+        if self.pc != pc_before {
+            // 读路径在途抛错已展开到 catch/finally 入口：pc 由处理器接管，
+            // 结果寄存器不得再写（regs[0] 持在途异常）。
+            return Ok(());
+        }
+        self.regs[a] = val;
         Ok(())
     }
 
@@ -645,10 +671,18 @@ impl Vm {
             return Ok(());
         };
         let obj = unsafe { &*obj_ptr };
+        let pc_before = self.pc;
         let val = self.ordinary_get_with_target(obj, prop_name_si, receiver, b as u8)?;
-        if self.accessor_frame_target_reg.take().is_none() {
-            self.regs[b] = val;
+        if self.accessor_frame_target_reg.take().is_some() {
+            // getter 帧已入栈：结果由帧续行交付，此处不写结果寄存器。
+            return Ok(());
         }
+        if self.pc != pc_before {
+            // 读路径在途抛错已展开到 catch/finally 入口：pc 由处理器接管，
+            // 结果寄存器不得再写（regs[0] 持在途异常）。
+            return Ok(());
+        }
+        self.regs[b] = val;
         Ok(())
     }
 

crates/oxide_vm/src/vm/dynamic.rs

@@ -98,9 +98,7 @@ impl Vm {
         table.immutables.resize(table.modules.len(), OnceLock::new());
         table.si_tables.resize(table.modules.len(), OnceLock::new());
 
-        // 动态函数对象置 DYNAMIC 旗：`prototype` 属性按规范不可配置
-        // （区别于普通函数的可配置面）。
-        let func_val = self.create_function_object(base, self.current_gen, FunctionFlags(FunctionFlags::DYNAMIC));
+        let func_val = self.create_function_object(base, self.current_gen, FunctionFlags::none());
         let func_obj = unsafe { &mut *func_val.as_js_object_ptr() };
         let length_si = self.kernel_core.perm_interner().intern("length").0;
         let name_si = self.kernel_core.perm_interner().intern("name").0;

crates/oxide_vm/src/vm_dispatch_misc.rs

@@ -565,6 +565,36 @@ impl Vm {
         let mut seen = std::collections::HashSet::new();
         let mut current = obj_val;
 
+        // 代理 for-in：[[OwnPropertyKeys]] 经 ownKeys trap 路由（缺失落穿
+        // target），[[GetOwnProperty]] 可枚举过滤经存储对象（代理本体无原型
+        // 链可走，规范枚举面即自身键）。
+        if current.is_object() {
+            let arr = unsafe { &*current.as_js_object_ptr() };
+            if arr.is_proxy_obj() {
+                let (keys, storage) = match oxide_builtins::object::own_keys_proxy_aware(self, arr) {
+                    Ok(k) => k,
+                    Err(exc) => return self.raise_captured(exc),
+                };
+                for (si, store) in keys {
+                    if is_symbol_key(si) {
+                        continue;
+                    }
+                    let enumerable = storage
+                        .prop_meta_at(store)
+                        .map(|m| m.attributes.enumerable())
+                        .unwrap_or(PropAttributes::DEFAULT_DATA.enumerable());
+                    if !enumerable {
+                        continue;
+                    }
+                    let key_val = oxide_builtins::object::key_si_to_js_value(self, si);
+                    keys_vec.push((key_val, si));
+                }
+                let iter = Box::into_raw(Box::new(ForInIter { keys: keys_vec, index: 0 }));
+                self.iters.push_for_in(iter);
+                return Ok(());
+            }
+        }
+
         // 数组把整型下标元素存在 prop_vec，而 prop_vec 不属于 shape 链。
         // 单独枚举它们（ES：数组下标是可枚举字符串键，按升序排在其它自有键之前）。
         // hole（删除标记）跳过——for-in 不枚举数组稀疏空洞。

crates/oxide_vm/src/vm_props.rs

@@ -108,34 +108,45 @@ impl Vm {
         &mut self, obj: &JsObject, prop_name_si: u32, receiver: JsValue, target_reg: Option<u8>,
     ) -> Result<JsValue, String> {
         vm_trace!("ordinary_get_inner: shape={} prop_si={}", obj.shape_id(), prop_name_si);
-        // Proxy [[Get]]：get trap 权威（target、P、Receiver），trap 定义时其返回值
-        // 即读结果；trap 缺失落穿 target 的 [[Get]]（receiver 不变）。target 本身
-        // 可为代理（嵌套代理），逐层递归应用同一语义直至非代理对象，再落普通读
-        // 路径从该对象继续。
-        let obj = if obj.is_proxy_obj() {
-            let mut current = obj;
-            loop {
-                let target = oxide_builtins::proxy::proxy_state_ref(current).expect("状态盒").target;
-                let key = oxide_builtins::object::key_si_to_js_value(self, prop_name_si);
-                match crate::proxy::call_trap(self, current, self.perm_intern("get"), &[target, key, receiver])? {
-                    Some(v) => return Ok(v),
-                    None => {
-                        // SAFETY: target 由构造器校验为非空对象指针。
-                        let target_obj = unsafe { &*target.as_js_object_ptr() };
-                        if !target_obj.is_proxy_obj() {
-                            break target_obj;
-                        }
-                        current = target_obj;
-                    }
-                }
-            }
-        } else {
-            obj
-        };
         let length_si = self.length_si;
         let mut current = Some(obj);
         let mut depth = 0usize;
         while let Some(obj) = current {
+            // Proxy [[Get]]：链上任意层（入口对象或原型链）为代理时，get trap
+            // 权威（target、P、Receiver），trap 定义时其返回值即读结果；trap 缺失
+            // 落穿 target 的 [[Get]]（receiver 不变）。target 本身可为代理（嵌套
+            // 代理），逐层递归应用同一语义直至非代理对象，再落普通读路径从该对象
+            // 继续。
+            if obj.is_proxy_obj() {
+                let mut chain = obj;
+                loop {
+                    let target = oxide_builtins::proxy::proxy_state_ref(chain).expect("状态盒").target;
+                    let key = oxide_builtins::object::key_si_to_js_key(self, prop_name_si);
+                    match crate::proxy::call_trap(self, chain, self.perm_intern("get"), &[target, key, receiver]) {
+                        Ok(Some(v)) => {
+                            // 不变量检查：target 自身属性不可配置时，不可写数据属性
+                            // 的 trap 结果须与 target 值 SameValue，无 getter 的访问器
+                            // 属性要求 trap 结果为 undefined。违反抛 TypeError：字节码
+                            // 上下文就地展开到外围 catch（pc 已交处理器、regs[0] 持在途
+                            // 异常），builtin 上下文返回格式化 Err 由调用边界恢复。
+                            // 检查失败须立即返回，调用方不得再写结果寄存器或推进 pc。
+                            self.proxy_get_invariant_check(target, prop_name_si, v, self.native_call_depth != 0)?;
+                            return Ok(v);
+                        }
+                        Ok(None) => {
+                            // SAFETY: target 由构造器校验为非空对象指针。
+                            let target_obj = unsafe { &*target.as_js_object_ptr() };
+                            if !target_obj.is_proxy_obj() {
+                                current = Some(target_obj);
+                                break;
+                            }
+                            chain = target_obj;
+                        }
+                        Err(e) => return self.proxy_trap_call_failure(e).map(|_| JsValue::undefined()),
+                    }
+                }
+                continue;
+            }
             // 模块命名空间 exotic [[Get]]：条目表是权威状态，预注册但未初始化的
             // 导出读抛 ReferenceError；非 live ns（无表）落普通属性路径零行为变化。
             if obj.is_module_namespace() {
@@ -875,6 +886,9 @@ impl Vm {
     ) -> Option<(JsValue, bool, PropAttributes, JsValue, JsValue)> {
         // SAFETY: target 由构造器校验为非空对象指针。
         let target_obj = unsafe { &*target.as_js_object_ptr() };
+        // target 自身为代理时其存储恒空：沿代理链落到终极 target 读自身
+        // 描述符（不变量检查与属性补全均按终极 target 口径）。
+        let target_obj = Self::ultimate_proxy_target(target_obj);
         let pos = self.get_own_property_slot(target_obj, prop_name_si)?;
         let meta = target_obj.prop_meta_at(pos)?;
         Some((target_obj.get_prop_at(pos), meta.is_accessor, meta.attributes, meta.get, meta.set))
@@ -909,6 +923,35 @@ impl Vm {
         Ok(())
     }
 
+    /// Proxy [[Get]] trap 返回值的不变量检查（规范 [[Get]] 步 9 形态）：target
+    /// 自身属性不可配置时，不可写数据属性要求 trap 结果与 target 值
+    /// SameValue，无 getter 的访问器属性要求 trap 结果为 undefined；违反抛
+    /// TypeError（builtin 上下文物化原值入 uncaught 侧通道，调用边界原值
+    /// 重抛，字节码上下文就地抛可捕获异常并展开）。
+    fn proxy_get_invariant_check(
+        &mut self, target: JsValue, prop_name_si: u32, trap_result: JsValue, builtin: bool,
+    ) -> Result<(), String> {
+        let Some((target_val, is_accessor, attrs, get, _)) = self.proxy_target_desc(target, prop_name_si) else {
+            return Ok(());
+        };
+        if !attrs.configurable() {
+            if is_accessor {
+                if get.is_undefined() && !trap_result.is_undefined() {
+                    return self.proxy_invariant_failure(
+                        builtin,
+                        "Proxy get trap returned a value for a non-configurable target accessor without getter",
+                    );
+                }
+            } else if !attrs.writable() && !oxide_runtime_api::same_value(trap_result, target_val) {
+                return self.proxy_invariant_failure(
+                    builtin,
+                    "Proxy get trap returned a different value for a non-writable target property",
+                );
+            }
+        }
+        Ok(())
+    }
+
     /// Proxy trap 不变量检查违反的两态出口：builtin 上下文物化 TypeError
     /// 写入 uncaught 侧通道（调用边界 `take_uncaught_value` 原值重抛），
     /// 字节码上下文就地抛可捕获异常并展开。
@@ -1119,12 +1162,13 @@ impl Vm {
     }
 
     /// Proxy receiver 的 `[[DefineOwnProperty]]`（defineProperty trap）：trap
-    /// 以（target、P、部分描述符 {value: V}）调用；报 true 时读 target 自身
-    /// 描述符补全部分描述符（数据形态取 target 的 writable/enumerable/
-    /// configurable）、做不变量检查后写 target；报 false 或 target 不可扩展
-    /// 的新属性定义返 `Ok(false)`（`[[Set]]` 投影为 false）。
+    /// 以（target、P、部分描述符 {value: V}）调用；报 true 时按
+    /// `receiver_configurable` 补全属性（可配置按完整描述符全真、不可配置
+    /// 保留 target 既有属性）、做不变量检查后写 target；trap 缺失落穿 target
+    /// 的普通定义，同口径补全；报 false 或 target 不可扩展的新属性定义返
+    /// `Ok(false)`（`[[Set]]` 投影为 false）。
     fn proxy_define_on_receiver(
-        &mut self, receiver_proxy: &JsObject, prop_name_si: u32, val: JsValue,
+        &mut self, receiver_proxy: &JsObject, prop_name_si: u32, val: JsValue, receiver_configurable: bool,
     ) -> Result<bool, String> {
         let target = oxide_builtins::proxy::proxy_state_ref(receiver_proxy).expect("状态盒").target;
         let key = oxide_builtins::object::key_si_to_js_key(self, prop_name_si);
@@ -1140,12 +1184,7 @@ impl Vm {
         };
         if let Some(r) = trap_result {
             if crate::proxy::trap_bool_result(r, "defineProperty")? {
-                // 补全部分描述符：数据 targetDesc 取其 writable/enumerable/
-                // configurable；targetDesc 缺失按新建数据属性（全真）。
-                let completed = self
-                    .proxy_target_desc(target, prop_name_si)
-                    .map(|(_, _, attrs, _, _)| attrs)
-                    .unwrap_or(oxide_types::object::PropAttributes::DEFAULT_DATA);
+                let completed = self.receiver_set_completed_attrs(target, prop_name_si, receiver_configurable);
                 self.proxy_define_invariant_check(
                     target,
                     prop_name_si,
@@ -1157,9 +1196,9 @@ impl Vm {
             }
             return Ok(false);
         }
-        // trap 缺失：落穿 target 的普通定义（完整数据描述符）。
-        let full = oxide_types::object::PropAttributes::DEFAULT_DATA;
-        self.define_on_target_bool(target, prop_name_si, val, full)
+        // trap 缺失：落穿 target 的普通定义（同口径补全）。
+        let completed = self.receiver_set_completed_attrs(target, prop_name_si, receiver_configurable);
+        self.define_on_target_bool(target, prop_name_si, val, completed)
     }
 
     /// CreateDataProperty(Receiver, P, V)（Receiver 为代理）：defineProperty
@@ -1224,11 +1263,39 @@ impl Vm {
                     }
                     return Ok(false);
                 }
-                self.proxy_define_on_receiver(receiver_proxy, prop_name_si, val)
+                // receiverDesc 为可写数据属性（规范步 7）：可配置按完整描述符
+                // 重定义，不可配置按部分描述符 {value: V} 保留既有属性。
+                let receiver_configurable = self.read_desc_configurable(desc);
+                self.proxy_define_on_receiver(receiver_proxy, prop_name_si, val, receiver_configurable)
             }
         }
     }
 
+    /// 读描述符对象的 configurable 字段（缺省视为 false：缺字段时无法确认
+    /// 可配置，按不可配置分支保留既有属性，与部分描述符语义一致）。
+    fn read_desc_configurable(&self, desc: JsValue) -> bool {
+        // SAFETY: desc 为值携带的非空对象指针。
+        let desc_obj = unsafe { &*desc.as_js_object_ptr() };
+        self.resolve_property(desc_obj, self.perm_intern("configurable"))
+            .map(oxide_runtime_api::to_boolean)
+            .unwrap_or(false)
+    }
+
+    /// `[[Set]]` receiver 定义补全属性：可配置 receiverDesc 按完整描述符
+    /// 重定义（全真，规范步 7.b）；不可配置 receiverDesc 保留 target 既有
+    /// 属性（规范步 7.c 部分描述符 {value: V}），target 缺该属性时按新建
+    /// 数据属性（全真）。
+    fn receiver_set_completed_attrs(
+        &self, target: JsValue, prop_name_si: u32, receiver_configurable: bool,
+    ) -> PropAttributes {
+        if receiver_configurable {
+            return oxide_types::object::PropAttributes::DEFAULT_DATA;
+        }
+        self.proxy_target_desc(target, prop_name_si)
+            .map(|(_, _, attrs, _, _)| attrs)
+            .unwrap_or(oxide_types::object::PropAttributes::DEFAULT_DATA)
+    }
+
     /// TypedArray 界内规范键在 `receiver` ≠ TA 时的 [[Set]] 语义：
     ///
     /// # 步骤

crates/oxide_vm/src/vm_support.rs

@@ -40,9 +40,6 @@ impl FunctionFlags {
     pub(crate) const CLASS_CONSTRUCTOR: u8 = 0b010;
     /// 派生构造器标志位（bit2）。
     pub(crate) const DERIVED_CONSTRUCTOR: u8 = 0b100;
-    /// 动态函数标志位（bit3）：经 Function 构造器创建的函数对象，其
-    /// `prototype` 属性不可配置。
-    pub(crate) const DYNAMIC: u8 = 0b1000;
 
     /// 无标志（普通函数）。
     pub(crate) const fn none() -> Self {
@@ -78,11 +75,6 @@ impl FunctionFlags {
     pub(crate) const fn is_derived_constructor(self) -> bool {
         self.0 & Self::DERIVED_CONSTRUCTOR != 0
     }
-
-    /// 是否动态函数（经 Function 构造器创建）。
-    pub(crate) const fn is_dynamic(self) -> bool {
-        self.0 & Self::DYNAMIC != 0
-    }
 }
 
 /// 模块级装载缓存条目三件套：已转换常量池、BigInt 自持存储、si 侧表。
@@ -903,21 +895,16 @@ impl Vm {
                 prototype.bump_generation();
             }
 
-            // 函数自身 `prototype` 属性：生成器与动态函数（Function 构造器产物）
-            // writable:true / enumerable:false / configurable:false；普通函数与
-            // 构造器 writable:true / enumerable:false / configurable:true。显式
-            // 落元数据——缺元数据按默认描述符（可枚举）判定，`prototype` 会泄漏
-            // 进 keys / for-in / 聚合枚举。
+            // 函数自身 `prototype` 属性：writable:true / enumerable:false /
+            // configurable:false（规范 10.2.1 口径，生成器与动态函数同口径）。
+            // 显式落元数据——缺元数据按默认描述符（可枚举）判定，`prototype`
+            // 会泄漏进 keys / for-in / 聚合枚举。
             let prototype_si = self.kernel_core.perm_interner().intern("prototype").0;
             let func = unsafe { &mut *obj_ptr };
             let prototype_shape = self.kernel_core.shape_forge().make_shape(func.shape_id(), prototype_si);
             func.set_shape_id(prototype_shape);
             let prototype_pos = func.push_prop(prototype_val);
-            if is_generator || is_async_generator || flags.is_dynamic() {
-                func.set_data_meta(prototype_pos, PropAttributes::new(true, false, false));
-            } else {
-                func.set_data_meta(prototype_pos, PropAttributes::new(true, false, true));
-            }
+            func.set_data_meta(prototype_pos, PropAttributes::new(true, false, false));
             func.bump_generation();
         }
 

crates/oxide_vm/tests/builtins_arraybuffer_state_tests.rs

@@ -1273,9 +1273,10 @@ fn sab_new_target_proto_and_fallback() {
          var d = Reflect.construct(SharedArrayBuffer, [4], D); \
          if (Object.getPrototypeOf(d) !== SharedArrayBuffer.prototype) { return false; } \
          var E = function () {}; \
-         Object.defineProperty(E, 'prototype', { get: function () { throw new RangeError('x'); } }); \
+         var e_proxy = new Proxy(E, { get: function (t, k) { \
+             if (k === 'prototype') { throw new RangeError('x'); } return t[k]; } }); \
          var threw = false; \
-         try { Reflect.construct(SharedArrayBuffer, [1], E); } catch (e) { threw = e instanceof RangeError; } \
+         try { Reflect.construct(SharedArrayBuffer, [1], e_proxy); } catch (e) { threw = e instanceof RangeError; } \
          return threw; })()",
     )
     .unwrap();

crates/oxide_vm/tests/builtins_function_tests.rs

@@ -483,9 +483,9 @@ fn function_prototype_new_throws_catchable_type_error() {
 
 #[test]
 fn dynamic_function_prototype_descriptor_not_configurable() {
-    // 动态函数（Function 构造器产物）的 prototype 属性为
-    // {writable:true, enumerable:false, configurable:false}，delete 失败且值不变；
-    // 普通函数的 prototype 属性保持可配置，不回归。
+    // 动态函数（Function 构造器产物）与普通函数的 prototype 属性均为
+    // {writable:true, enumerable:false, configurable:false}（规范 10.2.1 口径），
+    // delete 失败且值不变。
     let mut vm = Vm::new();
     vm.set_compiler_service(Arc::new(DefaultCompilerService));
     let result = eval(
@@ -505,7 +505,14 @@ fn dynamic_function_prototype_descriptor_not_configurable() {
         "function g() {} var d = Object.getOwnPropertyDescriptor(g, 'prototype'); d.writable + ',' + d.enumerable + ',' + d.configurable",
     )
     .unwrap();
-    assert_eq!(vm.lookup_str(result).unwrap_or_default(), "true,false,true");
+    assert_eq!(vm.lookup_str(result).unwrap_or_default(), "true,false,false");
+    // 普通函数同口径：delete 失败且值不变。
+    let result = eval(
+        &mut vm,
+        "function h() {} var p = h.prototype; delete h.prototype; h.prototype === p",
+    )
+    .unwrap();
+    assert!(result.as_bool());
 }
 
 #[test]

crates/oxide_vm/tests/builtins_regexp_tests.rs

@@ -267,11 +267,21 @@ fn regexp_exec_negative_last_index_clamped_to_zero() {
 
 #[test]
 fn regexp_exec_last_index_set_once_on_success() {
-    // 成功路径 lastIndex 恰好 Set 一次（写回在核内单点）：计数 setter 只被观察一次。
-    let source = "(() => { var re = /a/g; var n = 0; Object.defineProperty(re, 'lastIndex', { configurable: true, set() { n += 1; }, get() { return 0; } }); re.exec('a'); return String(n); })()";
+    // 成功路径 lastIndex 写回匹配末尾（核内单点写回的可观测口径）；
+    // 失败路径置 0（lastIndex 规范不可配置，无法以访问器计数观察）。
     let mut vm = Vm::new();
-    let result = eval(&mut vm, source).unwrap();
-    assert_eq!(to_str(&vm, result), "1");
+    let result = eval(
+        &mut vm,
+        "(() => { var re = /a/g; var m = re.exec('a'); return m[0] + ':' + re.lastIndex; })()",
+    )
+    .unwrap();
+    assert_eq!(to_str(&vm, result), "a:1");
+    let result = eval(
+        &mut vm,
+        "(() => { var re = /a/g; var r = re.exec('b'); return r === null && re.lastIndex === 0; })()",
+    )
+    .unwrap();
+    assert!(result.as_bool());
 }
 
 // --- test() lastIndex 规范语义（sticky 锚定 / 越界短路 / 不追踪不写回）---
@@ -747,10 +757,10 @@ fn symbol_search_lastindex_init_and_restore() {
     .unwrap();
     assert_eq!(to_str(&vm, result), "0/3");
     // 严格 SameValue 口径：-0 与 +0 不同值，初始化 Set 0 与恢复 Set -0
-    // 各触发一次写。
+    // 各触发一次写（lastIndex 规范不可配置，计数经代理 set trap 观察）。
     let result = eval(
         &mut vm,
-        "(() => { var r = /b/; var sets = 0; var store = -0; Object.defineProperty(r, 'lastIndex', { configurable: true, set(v) { sets += 1; store = v; }, get() { return store; } }); r.exec = function() { return null; }; r[Symbol.search](''); return sets; })()",
+        "(() => { var r = /b/; var sets = 0; var store = -0; var p = new Proxy(r, { set(t, k, v) { if (k === 'lastIndex') { sets += 1; store = v; } t[k] = v; return true; }, get(t, k) { if (k === 'lastIndex') { return store; } return t[k]; } }); p.exec = function() { return null; }; p[Symbol.search](''); return sets; })()",
     )
     .unwrap();
     assert!(result.as_int() == 2);

crates/oxide_vm/tests/builtins_typed_array_tests.rs

@@ -2303,14 +2303,14 @@ fn typed_array_ctor_plain_call_all_forms_throw() {
 
 #[test]
 fn typed_array_ctor_gpf_getter_throws_propagates() {
-    // newTarget.prototype 访问器抛值原值传播（buffer 形 + length 形）：
-    // 构造器体内 GpFC 自重读，不依赖通用构造机制的原型读。
+    // newTarget.prototype 读取抛值原值传播（buffer 形 + length 形）：
+    // 构造器体内 GpFC 自重读，不依赖通用构造机制的原型读。普通函数 prototype
+    // 规范不可配置，抛错形态经代理 get trap 表达。
     let mut vm = Vm::new();
     let result = eval(
         &mut vm,
-        "(function () { var nt = function () {}; \
-         Object.defineProperty(nt, 'prototype', { \
-           get: function () { throw new RangeError('gpf'); } }); \
+        "(function () { var nt = new Proxy(function () {}, { \
+          get: function (t, k) { if (k === 'prototype') { throw new RangeError('gpf'); } return t[k]; } }); \
          var ab = new ArrayBuffer(4); var t1, t2; \
          try { Reflect.construct(Int8Array, [ab], nt); } \
          catch (e) { t1 = e instanceof RangeError && e.message === 'gpf'; } \

crates/oxide_vm/tests/new_target_tests.rs

@@ -159,14 +159,15 @@ fn throwing_proto_ctor(source_tail: &str) -> String {
 
 #[test]
 fn gpfc_new_expression_bytecode_ctor_propagates_getter_throw() {
-    // 字节码构造器 prototype 为访问器且 getter 抛错：new 表达式须原值上抛（getter 触发）。
+    // newTarget 为代理且 get trap 读 prototype 抛错：new 表达式须原值上抛
+    // （getter 触发；普通函数 prototype 规范不可配置，抛错形态经代理表达）。
     let mut vm = Vm::new();
     let result = eval(
         &mut vm,
         "var F = function(){}; var calls = 0; \
-         Object.defineProperty(F, 'prototype', { configurable: true, \
-         get: function() { calls++; throw new Error('boom'); } }); \
-         try { new F(); } catch (e) { e.message + ':' + calls }",
+         var p = new Proxy(F, { get: function(t, k) { \
+         if (k === 'prototype') { calls++; throw new Error('boom'); } return t[k]; } }); \
+         try { new p(); } catch (e) { e.message + ':' + calls }",
     )
     .unwrap();
     assert_eq!(vm.lookup_str(result).unwrap(), "boom:1");
@@ -179,9 +180,9 @@ fn gpfc_new_expression_spread_bytecode_ctor_propagates_getter_throw() {
     let result = eval(
         &mut vm,
         "var F = function(){}; var calls = 0; \
-         Object.defineProperty(F, 'prototype', { configurable: true, \
-         get: function() { calls++; throw new Error('boom'); } }); \
-         try { new F(...[]); } catch (e) { e.message + ':' + calls }",
+         var p = new Proxy(F, { get: function(t, k) { \
+         if (k === 'prototype') { calls++; throw new Error('boom'); } return t[k]; } }); \
+         try { new p(...[]); } catch (e) { e.message + ':' + calls }",
     )
     .unwrap();
     assert_eq!(vm.lookup_str(result).unwrap(), "boom:1");