fix: 脏重建方法 wrapper/构造器/global 槽跨轮复用迁移——FnWrapperKey 四分件键(加 label 消解同名原型 next/return/throw 碰撞)登记表继承止 S2 每轮 wrapper 无界累积，global 槽原位更新堵住旧构造器滞留 UAF 与每轮 +3 槽无界增长

2026-10-25 03:01:12 +08:00 · 2026-09-11 18:06:19 +00:00
parent 4095ad2c1d
commit b17119ce16
12 changed files with 805 additions and 329 deletions
@@ -402,30 +402,41 @@ pub(crate) fn init_async_intrinsics(vm: &mut Vm) {
    let sh = vm.kernel_core.shape_forge().as_ref();
    let fn_proto_val = vm.session.builtin_world().fn_proto_val();

-    // %AsyncFunction% 构造器：proto = Function.prototype，调用抛错（动态创建未实现）。
-    let mut af_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    af_ctor.set_function(true);
-    af_ctor.set_native_arg_count(1);
+    // %AsyncFunction% 占位构造器：proto = Function.prototype，调用抛错（动态
+    // 创建未实现）。选择性重建复用：前轮占位构造器按键迁移（prototype 槽在
+    // 下方 P 槽换入后重指新原型），不再每轮新建对象。
+    let af_ctor_label = sf.intern("AsyncFunctionCtor").0;
+    let af_reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, af_ctor_label, 0, 0);
    // SAFETY: async_function_stub 是 NativeFn 函数项。
-    af_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(async_function_stub as *const ()) }));
+    let af_stub_ptr = unsafe { NativeFnPtr::from_raw(async_function_stub as *const ()) };
+    let (af_ctor_ptr, af_ctor_is_new) = match vm.session.builtin_world().find_fn_wrapper(af_reuse_key, af_stub_ptr, 1) {
+        Some(ptr) => (ptr, false),
+        None => {
+            let mut af_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
+            af_ctor.set_function(true);
+            af_ctor.set_native_arg_count(1);
+            af_ctor.set_native_fn(Some(af_stub_ptr));
+            let name_si = sf.intern("name").0;
+            let ctor_shape = sh.make_shape(af_ctor.shape_id(), name_si);
+            af_ctor.set_shape_id(ctor_shape);
+            let npos = af_ctor.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncFunction").0)));
+            af_ctor.set_data_meta(npos, PropAttributes::new(false, false, true));
+            let proto_si = sf.intern("prototype").0;
+            let ctor_shape2 = sh.make_shape(af_ctor.shape_id(), proto_si);
+            af_ctor.set_shape_id(ctor_shape2);
+            let af_ctor_ptr = Box::into_raw(af_ctor);
+            // 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
+            vm.session.builtin_world().track_fn_wrapper(af_ctor_ptr, af_reuse_key);
+            (af_ctor_ptr, true)
+        }
+    };

    // %AsyncFunction.prototype%：proto = Function.prototype，constructor = %AsyncFunction%。
    let mut af_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    let name_si = sf.intern("name").0;
-    let ctor_shape = sh.make_shape(af_ctor.shape_id(), name_si);
-    af_ctor.set_shape_id(ctor_shape);
-    let npos = af_ctor.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncFunction").0)));
-    af_ctor.set_data_meta(npos, PropAttributes::new(false, false, true));
-    let proto_si = sf.intern("prototype").0;
-    let ctor_shape2 = sh.make_shape(af_ctor.shape_id(), proto_si);
-    af_ctor.set_shape_id(ctor_shape2);
    // af_proto.constructor = %AsyncFunction%（构造器登记进 world 释放表，与 builtin 方法 wrapper 同生命周期）。
    let ctor_si = sf.intern("constructor").0;
    let pshape = sh.make_shape(af_proto.shape_id(), ctor_si);
    af_proto.set_shape_id(pshape);
-    // 登记进释放表：session 收尾统一释放构造器本体与属性区。
-    let af_ctor_ptr = Box::into_raw(af_ctor);
-    vm.session.builtin_world().track_leaked_object(af_ctor_ptr);
    let cpos = af_proto.push_prop(JsValue::from_js_object(af_ctor_ptr));
    af_proto.set_data_meta(cpos, PropAttributes::new(false, false, true));
    // af_proto[Symbol.toStringTag] = "AsyncFunction"（数据属性，w/e/c = false/false/true）。
@@ -438,12 +449,18 @@ pub(crate) fn init_async_intrinsics(vm: &mut Vm) {
    // proto 本体只存在于 P 槽（Arc 副本，原 Box 随函数结束释放）：装入 P 槽后再把
    // 构造器 prototype 属性指向 P 槽实例，使其与动态异步函数使用的 [[Prototype]]
    // 同一对象，保证 `AsyncFunction.prototype === (async () => {}).__proto__`。
+    // 复用构造器 prototype 槽原位改指新 P 原型（旧原型已随 P 换出释放）。
    Vm::swap_intrinsic_proto(&mut vm.async_function_proto, *af_proto);
-    // SAFETY: af_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），对象已建满、本 Vm 独占。
+    // SAFETY: af_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），本 Vm 独占。
    unsafe {
        let ctor_mut = &mut *af_ctor_ptr;
-        let ppos = ctor_mut.push_prop(JsValue::from_js_object(vm.async_function_proto.as_mut_ptr()));
-        ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
+        let proto_val = JsValue::from_js_object(vm.async_function_proto.as_ptr() as *mut JsObject);
+        if af_ctor_is_new {
+            let ppos = ctor_mut.push_prop(proto_val);
+            ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
+        } else if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), sf.intern("prototype").0) {
+            ctor_mut.set_prop_at(pos, proto_val);
+        }
    }
 }

@@ -738,11 +738,14 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {

    // %AsyncGeneratorPrototype%：proto = Object.prototype，方法 next/return/throw。
    let mut ag_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, object_proto_val));
+    // 站点标签：与 Generator 原型的同名方法槽（next/return/throw）区分复用键。
+    let ag_label = sf.intern("AsyncGeneratorPrototype").0;
    oxide_kernel::bind_methods_static!(
        &mut ag_proto,
        sf,
        sh,
        world,
+        ag_label,
        ("next", async_generator_next as *const (), 1),
        ("return", async_generator_return as *const (), 1),
        ("throw", async_generator_throw as *const (), 1),
@@ -755,7 +758,7 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {
    ag_proto.set_data_meta(tag_pos, PropAttributes::new(false, false, true));
    // @@asyncIterator：返回自身（异步生成器是异步可迭代对象，供 for-await-of 消费）。
    let aiter_key = oxide_types::private_key::make_well_known_symbol_key(8);
-    let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_static(
+    let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_labeled_static(
        &mut ag_proto,
        sh,
        sf,
@@ -764,30 +767,43 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {
        unsafe { oxide_types::object::NativeFnPtr::from_raw(async_generator_symbol_async_iterator as *const ()) },
        0,
        world,
+        ag_label,
    );
    Vm::swap_intrinsic_proto(&mut vm.async_generator_proto, *ag_proto);

-    // %AsyncGeneratorFunction.prototype%：proto = Function.prototype，constructor = %AsyncGeneratorFunction%。
-    let mut agf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    agf_ctor.set_function(true);
-    agf_ctor.set_native_arg_count(1);
-    // %AsyncGeneratorFunction% 构造器：动态创建未实现，调用抛 TypeError。
-    agf_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(async_generator_function_stub as *const ()) }));
+    // %AsyncGeneratorFunction.prototype%：proto = Function.prototype，
+    // constructor = %AsyncGeneratorFunction%。占位构造器动态创建未实现，
+    // 调用抛 TypeError。选择性重建复用：前轮占位构造器按键迁移（prototype
+    // 槽在下方 P 槽换入后重指新原型），不再每轮新建对象。
+    let agf_ctor_label = sf.intern("AsyncGeneratorFunctionCtor").0;
+    let agf_reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, agf_ctor_label, 0, 0);
+    // SAFETY: async_generator_function_stub 是 NativeFn 函数项。
+    let agf_stub_ptr = unsafe { NativeFnPtr::from_raw(async_generator_function_stub as *const ()) };
+    let (agf_ctor_ptr, agf_ctor_is_new) = match world.find_fn_wrapper(agf_reuse_key, agf_stub_ptr, 1) {
+        Some(ptr) => (ptr, false),
+        None => {
+            let mut agf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
+            agf_ctor.set_function(true);
+            agf_ctor.set_native_arg_count(1);
+            agf_ctor.set_native_fn(Some(agf_stub_ptr));
+            // prototype/name 属性（构造器形状 [prototype, name]）。
+            let proto_si = sf.intern("prototype").0;
+            let ctor_shape = sh.make_shape(EMPTY_SHAPE_ID, proto_si);
+            agf_ctor.set_shape_id(ctor_shape);
+            let name_si = sf.intern("name").0;
+            let name_shape = sh.make_shape(agf_ctor.shape_id(), name_si);
+            agf_ctor.set_shape_id(name_shape);
+            let agf_ctor_ptr = Box::into_raw(agf_ctor);
+            // 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
+            world.track_fn_wrapper(agf_ctor_ptr, agf_reuse_key);
+            (agf_ctor_ptr, true)
+        }
+    };
    let mut agf_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    // prototype/name 属性（构造器形状 [prototype, name]）。
-    let proto_si = sf.intern("prototype").0;
-    let ctor_shape = sh.make_shape(agf_ctor.shape_id(), proto_si);
-    agf_ctor.set_shape_id(ctor_shape);
-    let name_si = sf.intern("name").0;
-    let name_shape = sh.make_shape(agf_ctor.shape_id(), name_si);
-    agf_ctor.set_shape_id(name_shape);
    // agf_proto.constructor = %AsyncGeneratorFunction%（构造器登记进 world 释放表，与 builtin 方法 wrapper 同生命周期）。
    let ctor_si = sf.intern("constructor").0;
    let ctor2_shape = sh.make_shape(agf_proto.shape_id(), ctor_si);
    agf_proto.set_shape_id(ctor2_shape);
-    // 登记进释放表：session 收尾统一释放构造器本体与属性区。
-    let agf_ctor_ptr = Box::into_raw(agf_ctor);
-    world.track_leaked_object(agf_ctor_ptr);
    let cpos = agf_proto.push_prop(JsValue::from_js_object(agf_ctor_ptr));
    agf_proto.set_data_meta(cpos, PropAttributes::new(false, false, true));
    // agf_proto.prototype = %AsyncGeneratorPrototype%。
@@ -805,15 +821,29 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {

    // proto 本体只存在于 P 槽（Arc 副本，原 Box 随函数结束释放）：装入 P 槽后再写
    // 构造器 prototype/name 属性（按模板序 prototype 在前），prototype 指向 P 槽实例，
-    // 使其与动态异步生成器函数使用的 [[Prototype]] 同一对象。
+    // 使其与动态异步生成器函数使用的 [[Prototype]] 同一对象。复用构造器槽位已填充，
+    // prototype 原位改指新 P 原型（旧原型已随 P 换出释放）。
    Vm::swap_intrinsic_proto(&mut vm.async_generator_function_proto, *agf_proto);
-    // SAFETY: agf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），对象已建满、本 Vm 独占。
+    // SAFETY: agf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），本 Vm 独占。
    unsafe {
        let ctor_mut = &mut *agf_ctor_ptr;
-        let ppos = ctor_mut.push_prop(JsValue::from_js_object(vm.async_generator_function_proto.as_mut_ptr()));
-        ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
-        let npos = ctor_mut.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncGeneratorFunction").0)));
-        ctor_mut.set_data_meta(npos, PropAttributes::new(false, false, true));
+        let proto_val = JsValue::from_js_object(vm.async_generator_function_proto.as_ptr() as *mut JsObject);
+        let name_val = JsValue::perm_string(sf.string_ptr(sf.intern("AsyncGeneratorFunction").0));
+        if agf_ctor_is_new {
+            let ppos = ctor_mut.push_prop(proto_val);
+            ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
+            let npos = ctor_mut.push_prop(name_val);
+            ctor_mut.set_data_meta(npos, PropAttributes::new(false, false, true));
+        } else {
+            let si_prototype = sf.intern("prototype").0;
+            if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_prototype) {
+                ctor_mut.set_prop_at(pos, proto_val);
+            }
+            let si_name = sf.intern("name").0;
+            if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_name) {
+                ctor_mut.set_prop_at(pos, name_val);
+            }
+        }
    }
 }

@@ -2,7 +2,7 @@ use std::sync::Arc;

 use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
-use oxide_types::object::{JsObject, PropAttributes};
+use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
 use oxide_types::value::JsValue;

 use crate::async_disposable::dispose_async;
@@ -91,35 +91,56 @@ pub fn bind_async_disposable_stack(core: &Arc<KernelCore>, session: &KernelSessi
    let ctor_val = if ctor_val.is_object() {
        ctor_val
    } else {
-        // Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
-        let function_proto = world.function_proto.as_ptr() as *mut JsObject;
-        let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
-        ctor.set_function(true);
-        configure_native_constructor(
-            &mut ctor,
-            oxide_builtins::disposable_stack::async_disposable_stack_constructor::<crate::vm::Vm> as *const (),
-            0,
-        );
        let sf = core.perm_interner().as_ref();
        let sh = core.shape_forge().as_ref();
-        let si_prototype = sf.intern("prototype").0;
-        let si_name = sf.intern("name").0;
-        let si_length = sf.intern("length").0;
-        let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
-        let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
-        let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
-        ctor.set_shape_id(ctor_shape3);
-        ctor.ensure_hash_props()
-            .push(JsValue::from_js_object(world.async_disposable_stack_proto.as_ptr() as *mut JsObject));
-        ctor.ensure_hash_props()
-            .push(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncDisposableStack").0)));
-        ctor.ensure_hash_props().push(JsValue::int(0));
-        ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
-        ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
-        ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
-        let ctor_ptr = Box::into_raw(ctor);
-        // 登记进 world 释放表：session 收尾统一释放构造器本体与属性区。
-        world.track_leaked_object(ctor_ptr);
+        let name_si = sf.intern("AsyncDisposableStack").0;
+        // 选择性重建复用：非 P 目标（家族 0）按键查找前轮旧构造器迁移，避免每轮
+        // 新建导致登记表无界累积；槽键取 global 槽名，该命名空间内全局唯一。
+        let ctor_fn =
+            oxide_builtins::disposable_stack::async_disposable_stack_constructor::<crate::vm::Vm> as *const ();
+        // SAFETY: ctor_fn 是转成 *const () 的 NativeFn 函数项指针。
+        let ctor_fn_ptr = unsafe { NativeFnPtr::from_raw(ctor_fn) };
+        let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
+        let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, 0) {
+            Some(ptr) => {
+                // 迁移内引用：prototype 槽改指新 AsyncDisposableStack.prototype
+                // （旧原型已被重建替换释放）。
+                let ctor = unsafe { &mut *ptr };
+                let si_prototype = sf.intern("prototype").0;
+                if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
+                    ctor.set_prop_at(
+                        pos,
+                        JsValue::from_js_object(world.async_disposable_stack_proto.as_ptr() as *mut JsObject),
+                    );
+                }
+                ptr
+            }
+            None => {
+                // Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
+                let function_proto = world.function_proto.as_ptr() as *mut JsObject;
+                let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
+                ctor.set_function(true);
+                configure_native_constructor(&mut ctor, ctor_fn, 0);
+                let si_prototype = sf.intern("prototype").0;
+                let si_name = sf.intern("name").0;
+                let si_length = sf.intern("length").0;
+                let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
+                let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
+                let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
+                ctor.set_shape_id(ctor_shape3);
+                ctor.ensure_hash_props()
+                    .push(JsValue::from_js_object(world.async_disposable_stack_proto.as_ptr() as *mut JsObject));
+                ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
+                ctor.ensure_hash_props().push(JsValue::int(0));
+                ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
+                ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
+                ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
+                let ctor_ptr = Box::into_raw(ctor);
+                // 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
+                world.track_fn_wrapper(ctor_ptr, reuse_key);
+                ctor_ptr
+            }
+        };
        JsValue::from_js_object(ctor_ptr)
    };

@@ -2,7 +2,7 @@ use std::sync::Arc;

 use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
-use oxide_types::object::{JsObject, PropAttributes};
+use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
 use oxide_types::value::JsValue;

 use crate::bindings::{
@@ -109,35 +109,55 @@ pub fn bind_disposable_stack(core: &Arc<KernelCore>, session: &KernelSession, gl
    let ctor_val = if ctor_val.is_object() {
        ctor_val
    } else {
-        // Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
-        let function_proto = world.function_proto.as_ptr() as *mut JsObject;
-        let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
-        ctor.set_function(true);
-        configure_native_constructor(
-            &mut ctor,
-            oxide_builtins::disposable_stack::disposable_stack_constructor::<crate::vm::Vm> as *const (),
-            0,
-        );
        let sf = core.perm_interner().as_ref();
        let sh = core.shape_forge().as_ref();
-        let si_prototype = sf.intern("prototype").0;
-        let si_name = sf.intern("name").0;
-        let si_length = sf.intern("length").0;
-        let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
-        let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
-        let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
-        ctor.set_shape_id(ctor_shape3);
-        ctor.ensure_hash_props()
-            .push(JsValue::from_js_object(world.disposable_stack_proto.as_ptr() as *mut JsObject));
-        ctor.ensure_hash_props()
-            .push(JsValue::perm_string(sf.string_ptr(sf.intern("DisposableStack").0)));
-        ctor.ensure_hash_props().push(JsValue::int(0));
-        ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
-        ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
-        ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
-        let ctor_ptr = Box::into_raw(ctor);
-        // 登记进 world 释放表：session 收尾统一释放构造器本体与属性区。
-        world.track_leaked_object(ctor_ptr);
+        let name_si = sf.intern("DisposableStack").0;
+        // 选择性重建复用：非 P 目标（家族 0）按键查找前轮旧构造器迁移，避免每轮
+        // 新建导致登记表无界累积；槽键取 global 槽名，该命名空间内全局唯一。
+        let ctor_fn = oxide_builtins::disposable_stack::disposable_stack_constructor::<crate::vm::Vm> as *const ();
+        // SAFETY: ctor_fn 是转成 *const () 的 NativeFn 函数项指针。
+        let ctor_fn_ptr = unsafe { NativeFnPtr::from_raw(ctor_fn) };
+        let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
+        let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, 0) {
+            Some(ptr) => {
+                // 迁移内引用：prototype 槽改指新 DisposableStack.prototype
+                // （旧原型已被重建替换释放）。
+                let ctor = unsafe { &mut *ptr };
+                let si_prototype = sf.intern("prototype").0;
+                if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
+                    ctor.set_prop_at(
+                        pos,
+                        JsValue::from_js_object(world.disposable_stack_proto.as_ptr() as *mut JsObject),
+                    );
+                }
+                ptr
+            }
+            None => {
+                // Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
+                let function_proto = world.function_proto.as_ptr() as *mut JsObject;
+                let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
+                ctor.set_function(true);
+                configure_native_constructor(&mut ctor, ctor_fn, 0);
+                let si_prototype = sf.intern("prototype").0;
+                let si_name = sf.intern("name").0;
+                let si_length = sf.intern("length").0;
+                let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
+                let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
+                let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
+                ctor.set_shape_id(ctor_shape3);
+                ctor.ensure_hash_props()
+                    .push(JsValue::from_js_object(world.disposable_stack_proto.as_ptr() as *mut JsObject));
+                ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
+                ctor.ensure_hash_props().push(JsValue::int(0));
+                ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
+                ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
+                ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
+                let ctor_ptr = Box::into_raw(ctor);
+                // 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
+                world.track_fn_wrapper(ctor_ptr, reuse_key);
+                ctor_ptr
+            }
+        };
        JsValue::from_js_object(ctor_ptr)
    };

@@ -12,55 +12,86 @@ fn bind_error_subtype_constructor(
 ) {
    let sf = core.perm_interner().as_ref();
    let sh = core.shape_forge().as_ref();
-    // 子类型构造器 [[Prototype]] 指向 Error 构造器（规范：NativeError 构造器继承 Error
-    // 构造器，而非直接继承 Function.prototype；instanceof 走 @@hasInstance 不受影响）。
-    let error_ctor_ptr = session.builtin_world().error_constructor.as_ptr() as *mut JsObject;
-    let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
-    ctor.set_function(true);
-    // Error 子类型须标记可构造：new TypeError(...) 走 NEW_EXPRESSION 校验。
-    ctor.type_tag = JsObject::OBJ_TYPE_CONSTRUCTOR;
-    // SAFETY: ctor_fn 是调用方转成 *const () 的 NativeFn 函数项指针。
-    ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(ctor_fn) }));
-    ctor.set_native_arg_count(arg_count);
-
-    let si_prototype = sf.intern("prototype").0;
-    let si_name = sf.intern("name").0;
-    let si_length = sf.intern("length").0;
+    let world = session.builtin_world();
    let name_si = sf.intern(name).0;
+    // SAFETY: ctor_fn 是调用方转成 *const () 的 NativeFn 函数项指针。
+    let ctor_fn_ptr = unsafe { NativeFnPtr::from_raw(ctor_fn) };
+    // 选择性重建复用：非 P 目标（家族 0）按键查找前轮旧构造器迁移，避免每轮
+    // 新建导致登记表无界累积；槽键取 global 槽名，该命名空间内全局唯一。
+    let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
+    let si_prototype = sf.intern("prototype").0;
+    let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, arg_count) {
+        Some(ptr) => {
+            // 迁移内引用：prototype 槽改指新子类型原型（旧原型已被重建替换释放）。
+            let ctor = unsafe { &mut *ptr };
+            if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
+                ctor.set_prop_at(pos, JsValue::from_js_object(proto_ptr));
+            }
+            ptr
+        }
+        None => {
+            // 子类型构造器 [[Prototype]] 指向 Error 构造器（规范：NativeError
+            // 构造器继承 Error 构造器，而非直接继承 Function.prototype；instanceof
+            // 走 @@hasInstance 不受影响）。
+            let error_ctor_ptr = world.error_constructor.as_ptr() as *mut JsObject;
+            let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
+            ctor.set_function(true);
+            // Error 子类型须标记可构造：new TypeError(...) 走 NEW_EXPRESSION 校验。
+            ctor.type_tag = JsObject::OBJ_TYPE_CONSTRUCTOR;
+            ctor.set_native_fn(Some(ctor_fn_ptr));
+            ctor.set_native_arg_count(arg_count);

-    let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
-    let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
-    let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
-    ctor.set_shape_id(ctor_shape3);
-    ctor.ensure_hash_props().push(JsValue::from_js_object(proto_ptr));
-    ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
-    ctor.ensure_hash_props().push(JsValue::int(arg_count as i32));
-    // 构造器 prototype 槽按规范 { writable:false, enumerable:false, configurable:false }。
-    ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
-    // 构造器 name 槽按规范 { writable:false, enumerable:false, configurable:true }。
-    ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
-    // 构造器 length 按规范为不可写不可枚举（Function.length 属性描述符约定）。
-    ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
+            let si_name = sf.intern("name").0;
+            let si_length = sf.intern("length").0;

-    let ctor_ptr = Box::into_raw(ctor);
-    // 登记进 world 释放表：session 收尾统一释放构造器本体与属性区。
-    session.builtin_world().track_leaked_object(ctor_ptr);
+            let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
+            let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
+            let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
+            ctor.set_shape_id(ctor_shape3);
+            ctor.ensure_hash_props().push(JsValue::from_js_object(proto_ptr));
+            ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
+            ctor.ensure_hash_props().push(JsValue::int(arg_count as i32));
+            // 构造器 prototype 槽按规范 { writable:false, enumerable:false, configurable:false }。
+            ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
+            // 构造器 name 槽按规范 { writable:false, enumerable:false, configurable:true }。
+            ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
+            // 构造器 length 按规范为不可写不可枚举（Function.length 属性描述符约定）。
+            ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));

+            let ctor_ptr = Box::into_raw(ctor);
+            // 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
+            world.track_fn_wrapper(ctor_ptr, reuse_key);
+            ctor_ptr
+        }
+    };
+    let ctor_val = JsValue::from_js_object(ctor_ptr);
+
+    // 原型上的 constructor 既有槽原位更新，无槽时开新槽（重建原型无既有槽）；
+    // 非枚举数据属性（与 Error.prototype.constructor 一致）。
    let proto = unsafe { &mut *proto_ptr };
-    let proto_ctor_shape = sh.make_shape(proto.shape_id(), sf.intern("constructor").0);
-    proto.set_shape_id(proto_ctor_shape);
-    proto.ensure_hash_props().push(JsValue::from_js_object(ctor_ptr));
-    // 原型上的 constructor 按规范为非枚举数据属性（与 Error.prototype.constructor 一致）。
-    let ctor_pos = proto.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    proto.set_data_meta(ctor_pos, PropAttributes::new(true, false, true));
+    let si_constructor = sf.intern("constructor").0;
+    if let Some(pos) = sh.lookup_position(proto.shape_id(), si_constructor) {
+        proto.set_prop_at(pos, ctor_val);
+    } else {
+        let proto_ctor_shape = sh.make_shape(proto.shape_id(), si_constructor);
+        proto.set_shape_id(proto_ctor_shape);
+        proto.ensure_hash_props().push(ctor_val);
+        let ctor_pos = proto.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
+        proto.set_data_meta(ctor_pos, PropAttributes::new(true, false, true));
+    }

-    let global_shape = sh.make_shape(global.shape_id(), name_si);
-    global.set_shape_id(global_shape);
-    global.ensure_hash_props().push(JsValue::from_js_object(ctor_ptr));
-    // 全局子类型构造器槽位非枚举（规范全局构造器描述符约定）。
-    let global_pos = global.prop_vec_len().saturating_sub(1) as u32;
-    global.set_data_meta(global_pos, PropAttributes::new(true, false, true));
-    global.bump_generation();
+    // 全局子类型构造器槽位既有槽原位更新（旧家族构造器指针不得滞留在属性 vec），
+    // 无槽时开新槽；描述符非枚举（规范全局构造器描述符约定）。
+    if let Some(pos) = sh.lookup_position(global.shape_id(), name_si) {
+        global.set_prop_at(pos, ctor_val);
+    } else {
+        let global_shape = sh.make_shape(global.shape_id(), name_si);
+        global.set_shape_id(global_shape);
+        global.ensure_hash_props().push(ctor_val);
+        let global_pos = global.prop_vec_len().saturating_sub(1) as u32;
+        global.set_data_meta(global_pos, PropAttributes::new(true, false, true));
+        global.bump_generation();
+    }
 }

 /// 把 Error 及各子类型（TypeError/ReferenceError/...）构造器与原型方法绑定到 global。
@@ -83,15 +114,20 @@ pub fn bind_error(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
        core.shape_forge().as_ref(),
    );

+    // 全局 Error 槽位既有槽原位更新（旧家族构造器指针不得滞留在属性 vec），
+    // 无槽时开新槽；描述符非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
    let si_err = core.perm_interner().intern("Error").0;
-    let err_shape = core.shape_forge().make_shape(global.shape_id(), si_err);
    let err_val = JsValue::from_js_object(session.builtin_world().error_constructor.as_ptr() as *mut JsObject);
-    global.set_shape_id(err_shape);
-    global.ensure_hash_props().push(err_val);
-    // 全局 Error 构造器槽位非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
-    let err_pos = global.prop_vec_len().saturating_sub(1) as u32;
-    global.set_data_meta(err_pos, PropAttributes::new(true, false, true));
-    global.bump_generation();
+    if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si_err) {
+        global.set_prop_at(pos, err_val);
+    } else {
+        let err_shape = core.shape_forge().make_shape(global.shape_id(), si_err);
+        global.set_shape_id(err_shape);
+        global.ensure_hash_props().push(err_val);
+        let err_pos = global.prop_vec_len().saturating_sub(1) as u32;
+        global.set_data_meta(err_pos, PropAttributes::new(true, false, true));
+        global.bump_generation();
+    }

    bind_error_subtype_constructor(
        core,
@@ -77,13 +77,18 @@ pub fn bind_math(core: &Arc<KernelCore>, session: &KernelSession, global: &mut J
        math.set_data_meta(pos, PropAttributes::new(false, false, false));
    }

+    // 全局 Math 槽位既有槽原位更新（旧对象指针不得滞留在属性 vec），无槽时
+    // 开新槽；描述符非枚举（规范全局命名空间对象属性均 enumerable:false）。
    let si_m = core.perm_interner().intern("Math").0;
-    let m_shape = core.shape_forge().make_shape(global.shape_id(), si_m);
    let m_val = JsValue::from_js_object(session.builtin_world().math_object.as_ptr() as *mut JsObject);
-    global.set_shape_id(m_shape);
-    global.ensure_hash_props().push(m_val);
-    // 全局 Math 槽位非枚举（规范全局命名空间对象属性均 enumerable:false）。
-    let pos = global.prop_vec_len().saturating_sub(1) as u32;
-    global.set_data_meta(pos, PropAttributes::new(true, false, true));
-    global.bump_generation();
+    if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si_m) {
+        global.set_prop_at(pos, m_val);
+    } else {
+        let m_shape = core.shape_forge().make_shape(global.shape_id(), si_m);
+        global.set_shape_id(m_shape);
+        global.ensure_hash_props().push(m_val);
+        let pos = global.prop_vec_len().saturating_sub(1) as u32;
+        global.set_data_meta(pos, PropAttributes::new(true, false, true));
+        global.bump_generation();
+    }
 }
@@ -73,13 +73,18 @@ pub fn bind_string(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
        0,
    );

+    // 全局 String 槽位既有槽原位更新（旧家族构造器指针不得滞留在属性 vec），
+    // 无槽时开新槽；描述符非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
    let si_str = core.perm_interner().intern("String").0;
-    let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str);
    let str_val = JsValue::from_js_object(session.builtin_world().string_constructor.as_ptr() as *mut JsObject);
-    global.set_shape_id(str_shape);
-    global.ensure_hash_props().push(str_val);
-    // 全局构造器槽位非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
-    let pos = global.prop_vec_len().saturating_sub(1) as u32;
-    global.set_data_meta(pos, PropAttributes::new(true, false, true));
-    global.bump_generation();
+    if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si_str) {
+        global.set_prop_at(pos, str_val);
+    } else {
+        let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str);
+        global.set_shape_id(str_shape);
+        global.ensure_hash_props().push(str_val);
+        let pos = global.prop_vec_len().saturating_sub(1) as u32;
+        global.set_data_meta(pos, PropAttributes::new(true, false, true));
+        global.bump_generation();
+    }
 }
@@ -71,19 +71,26 @@ macro_rules! bind_constructor {
    }};
    ($core:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal, hash: $hash:literal) => {{
        let si = $core.perm_interner().intern($name).0;
-        let shape = $core.shape_forge().make_shape($global.shape_id(), si);
        let val = $crate::JsValue::from_js_object($ctor_ptr);
-        $global.set_shape_id(shape);
-        if $hash {
-            $global.ensure_hash_props().push(val);
-            $global.bump_generation();
+        if let Some(pos) = $core.shape_forge().lookup_position($global.shape_id(), si) {
+            // 既有槽（重建后保留的 global）：原位更新槽值，不追加新槽——旧家族
+            // 构造器指针不得滞留属性 vec，shape 链不得继续增长。
+            $global.set_prop_at(pos, val);
        } else {
-            $global.push_prop(val);
+            let shape = $core.shape_forge().make_shape($global.shape_id(), si);
+            $global.set_shape_id(shape);
+            if $hash {
+                $global.ensure_hash_props().push(val);
+            } else {
+                $global.push_prop(val);
+            }
+            // 全局构造器槽位：规范描述符 { writable:true, enumerable:false,
+            // configurable:true }，不设 meta 时默认全枚举会泄漏进
+            // Object.keys(globalThis) / for-in。
+            let global_pos = $global.prop_vec_len().saturating_sub(1) as u32;
+            $global.set_data_meta(global_pos, oxide_types::object::PropAttributes::new(true, false, true));
+            $global.bump_generation();
        }
-        // 全局构造器槽位：规范描述符 { writable:true, enumerable:false, configurable:true }，
-        // 不设 meta 时默认全枚举会泄漏进 Object.keys(globalThis) / for-in。
-        let global_pos = $global.prop_vec_len().saturating_sub(1) as u32;
-        $global.set_data_meta(global_pos, oxide_types::object::PropAttributes::new(true, false, true));
        let ctor = unsafe { &mut *$ctor_ptr };
        let ptr: *const () = ($ctor_fn as fn(&mut $crate::vm::Vm, &[u8]) -> oxide_runtime_api::NativeResult) as *const ();
        ctor.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(ptr) }));
@@ -137,36 +144,48 @@ pub(crate) fn bind_accessor_getter(
    let shape_forge = core.shape_forge().as_ref();
    let string_forge = core.perm_interner().as_ref();
    let world = session.builtin_world();
-    let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
-
-    let getter_name = format!("get {name}");
-    let mut getter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    getter.set_function(true);
-    // SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。
-    getter.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) }));
-    getter.set_native_arg_count(0);
-
-    let si_name = string_forge.intern("name").0;
-    let name_shape = shape_forge.make_shape(getter.shape_id(), si_name);
-    getter.set_shape_id(name_shape);
-    getter
-        .ensure_hash_props()
-        .push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(&getter_name).0)));
-    let name_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    getter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
-
-    let si_length = string_forge.intern("length").0;
-    let length_shape = shape_forge.make_shape(getter.shape_id(), si_length);
-    getter.set_shape_id(length_shape);
-    getter.ensure_hash_props().push(JsValue::int(0));
-    let length_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    getter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
-
-    let getter_ptr = Box::into_raw(getter);
-    world.track_leaked_object(getter_ptr);
-    let getter_val = JsValue::from_js_object(getter_ptr);

    let si = string_forge.intern(name).0;
+    let getter_name = format!("get {name}");
+    let si_label = string_forge.intern(&getter_name).0;
+    // SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。
+    let getter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) };
+    // 选择性重建复用：同家族同槽旧 getter 迁移到新 proto 的访问器槽（proto
+    // 槽已由重建收尾重指），不再新建对象。
+    let reuse_key =
+        oxide_kernel::builtin::FnWrapperKey::new(world.wrapper_family_of(proto as *const JsObject), 0, si, si_label);
+    let getter_ptr = match world.find_fn_wrapper(reuse_key, getter_fn_ptr, 0) {
+        Some(ptr) => ptr,
+        None => {
+            let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
+            let mut getter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
+            getter.set_function(true);
+            getter.set_native_fn(Some(getter_fn_ptr));
+            getter.set_native_arg_count(0);
+
+            let si_name = string_forge.intern("name").0;
+            let name_shape = shape_forge.make_shape(getter.shape_id(), si_name);
+            getter.set_shape_id(name_shape);
+            getter
+                .ensure_hash_props()
+                .push(JsValue::perm_string(string_forge.string_ptr(si_label)));
+            let name_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
+            getter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
+
+            let si_length = string_forge.intern("length").0;
+            let length_shape = shape_forge.make_shape(getter.shape_id(), si_length);
+            getter.set_shape_id(length_shape);
+            getter.ensure_hash_props().push(JsValue::int(0));
+            let length_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
+            getter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
+
+            let getter_ptr = Box::into_raw(getter);
+            world.track_fn_wrapper(getter_ptr, reuse_key);
+            getter_ptr
+        }
+    };
+    let getter_val = JsValue::from_js_object(getter_ptr);
+
    let new_shape = shape_forge.make_shape(proto.shape_id(), si);
    proto.set_shape_id(new_shape);
    let pos = proto.push_prop(JsValue::undefined());
@@ -193,51 +212,50 @@ pub(crate) fn bind_accessor_getset(
    let shape_forge = core.shape_forge().as_ref();
    let string_forge = core.perm_interner().as_ref();
    let world = session.builtin_world();
-    let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
-
-    let mut getter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    getter.set_function(true);
-    // SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。
-    getter.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) }));
-    getter.set_native_arg_count(0);
-    // 给函数对象开 name/length 槽位（描述符均 { writable:false, enumerable:false, configurable:true }）。
-    let si_name = string_forge.intern("name").0;
-    let name_shape = shape_forge.make_shape(getter.shape_id(), si_name);
-    getter.set_shape_id(name_shape);
-    getter
-        .ensure_hash_props()
-        .push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(getter_name).0)));
-    let name_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    getter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
+    let family = world.wrapper_family_of(proto as *const JsObject);
    let si_length = string_forge.intern("length").0;
-    let length_shape = shape_forge.make_shape(getter.shape_id(), si_length);
-    getter.set_shape_id(length_shape);
-    getter.ensure_hash_props().push(JsValue::int(0));
-    let length_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    getter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
-    let getter_ptr = Box::into_raw(getter);
-    world.track_leaked_object(getter_ptr);
-    let getter_val = JsValue::from_js_object(getter_ptr);
+    let si_name = string_forge.intern("name").0;

-    let mut setter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    setter.set_function(true);
-    // SAFETY: setter_fn 是转成 *const () 的 NativeFn 函数项指针。
-    setter.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(setter_fn) }));
-    setter.set_native_arg_count(1);
-    let name_shape = shape_forge.make_shape(setter.shape_id(), si_name);
-    setter.set_shape_id(name_shape);
-    setter
-        .ensure_hash_props()
-        .push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(setter_name).0)));
-    let name_pos = setter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    setter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
-    let length_shape = shape_forge.make_shape(setter.shape_id(), si_length);
-    setter.set_shape_id(length_shape);
-    setter.ensure_hash_props().push(JsValue::int(1));
-    let length_pos = setter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
-    setter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
-    let setter_ptr = Box::into_raw(setter);
-    world.track_leaked_object(setter_ptr);
+    // 选择性重建复用：同家族同槽旧 getter/setter 迁移到新 proto 的访问器槽
+    // （proto 槽已由重建收尾重指），不再新建对象。
+    let build = |si_label: u32,
+                 fn_ptr_native: oxide_types::object::NativeFnPtr,
+                 arg_count: u8,
+                 length_val: i32|
+     -> *mut JsObject {
+        let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(family, 0, key, si_label);
+        if let Some(ptr) = world.find_fn_wrapper(reuse_key, fn_ptr_native, arg_count) {
+            return ptr;
+        }
+        let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
+        let mut func = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
+        func.set_function(true);
+        func.set_native_fn(Some(fn_ptr_native));
+        func.set_native_arg_count(arg_count);
+        // 给函数对象开 name/length 槽位（描述符均 { writable:false, enumerable:false, configurable:true }）。
+        let name_shape = shape_forge.make_shape(func.shape_id(), si_name);
+        func.set_shape_id(name_shape);
+        func.ensure_hash_props()
+            .push(JsValue::perm_string(string_forge.string_ptr(si_label)));
+        let name_pos = func.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
+        func.set_data_meta(name_pos, PropAttributes::new(false, false, true));
+        let length_shape = shape_forge.make_shape(func.shape_id(), si_length);
+        func.set_shape_id(length_shape);
+        func.ensure_hash_props().push(JsValue::int(length_val));
+        let length_pos = func.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
+        func.set_data_meta(length_pos, PropAttributes::new(false, false, true));
+        let func_ptr = Box::into_raw(func);
+        world.track_fn_wrapper(func_ptr, reuse_key);
+        func_ptr
+    };
+    // SAFETY: getter_fn / setter_fn 是转成 *const () 的 NativeFn 函数项指针。
+    let getter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) };
+    let setter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(setter_fn) };
+    let si_getter = string_forge.intern(getter_name).0;
+    let si_setter = string_forge.intern(setter_name).0;
+    let getter_ptr = build(si_getter, getter_fn_ptr, 0, 0);
+    let setter_ptr = build(si_setter, setter_fn_ptr, 1, 1);
+    let getter_val = JsValue::from_js_object(getter_ptr);
    let setter_val = JsValue::from_js_object(setter_ptr);

    // 访问器属性槽：enumerable=false、configurable=true（get/set 函数对象已持有）。
@@ -573,13 +591,20 @@ fn sync_iterator_function_prototype(core: &Arc<KernelCore>, session: &KernelSess
    iterator.set_prop_at(proto_pos, new_proto);
 }

+/// 在目标对象（global 或命名空间对象）上绑定一个具名槽：既有槽（选择性
+/// 重建后保留的目标）原位更新槽值，无槽时开新槽。内置全局值统一非枚举：
+/// 描述符 { writable:true, enumerable:false, configurable:true }，与构造器/
+/// 命名空间对象（Math/JSON/Reflect/Temporal 等）规范一致。
 pub(crate) fn bind_global_value(core: &Arc<KernelCore>, global: &mut JsObject, name: &str, value: JsValue) {
    let si = core.perm_interner().intern(name).0;
+    if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si) {
+        // 原位更新：旧对象指针不得滞留在属性 vec，shape 链不得继续增长。
+        global.set_prop_at(pos, value);
+        return;
+    }
    let shape = core.shape_forge().make_shape(global.shape_id(), si);
    global.set_shape_id(shape);
    global.ensure_hash_props().push(value);
-    // 内置全局值统一非枚举：描述符 { writable:true, enumerable:false, configurable:true }，
-    // 与构造器/命名空间对象（Math/JSON/Reflect/Temporal 等）规范一致。
    let pos = global.prop_vec_len().saturating_sub(1) as u32;
    global.set_data_meta(pos, PropAttributes::new(true, false, true));
    global.bump_generation();
@@ -604,28 +629,46 @@ fn bind_error_subtype_global(

    // fallback 自建路径与 bind_error 的 Box 自建路径保持同一形态：[[Prototype]] 指向
    // Error 构造器（NativeError 构造器继承 Error 构造器），prototype/name 描述符按规范。
-    let error_ctor_ptr = session.builtin_world().error_constructor.as_ptr() as *mut JsObject;
-    let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
-    ctor.set_function(true);
-    configure_native_constructor(&mut ctor, ctor_fn, arg_count);
-
+    // 家族重建后新原型无既有槽：按复用键查找前轮旧构造器迁移，避免每轮新建。
+    let world = session.builtin_world();
    let sf = core.perm_interner().as_ref();
    let sh = core.shape_forge().as_ref();
    let si_prototype = sf.intern("prototype").0;
-    let si_name = sf.intern("name").0;
    let name_si = sf.intern(name).0;
-    let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
-    let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
-    ctor.set_shape_id(ctor_shape2);
-    ctor.ensure_hash_props()
-        .push(JsValue::from_js_object(proto.as_ptr() as *mut JsObject));
-    ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
-    // prototype/name 描述符与 Box 自建路径一致：{f,f,f} / {f,f,t}。
-    ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
-    ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
+    // SAFETY: ctor_fn 是转成 *const () 的 NativeFn 函数项指针。
+    let ctor_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(ctor_fn) };
+    let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
+    let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, arg_count) {
+        Some(ptr) => {
+            // 迁移内引用：prototype 槽改指新子类型原型（旧原型已被重建替换）。
+            let ctor = unsafe { &mut *ptr };
+            if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
+                ctor.set_prop_at(pos, JsValue::from_js_object(proto.as_ptr() as *mut JsObject));
+            }
+            ptr
+        }
+        None => {
+            let error_ctor_ptr = world.error_constructor.as_ptr() as *mut JsObject;
+            let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
+            ctor.set_function(true);
+            configure_native_constructor(&mut ctor, ctor_fn, arg_count);

-    let ctor_ptr = Box::into_raw(ctor);
-    session.builtin_world().track_leaked_object(ctor_ptr);
+            let si_name = sf.intern("name").0;
+            let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
+            let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
+            ctor.set_shape_id(ctor_shape2);
+            ctor.ensure_hash_props()
+                .push(JsValue::from_js_object(proto.as_ptr() as *mut JsObject));
+            ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
+            // prototype/name 描述符与 Box 自建路径一致：{f,f,f} / {f,f,t}。
+            ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
+            ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
+
+            let ctor_ptr = Box::into_raw(ctor);
+            world.track_fn_wrapper(ctor_ptr, reuse_key);
+            ctor_ptr
+        }
+    };
    bind_existing_global(core, global, name, JsValue::from_js_object(ctor_ptr));
 }

@@ -733,11 +733,14 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
    let iterator_proto_val =
        JsValue::from_js_object(vm.session.builtin_world().iterator_proto.as_ptr() as *mut JsObject);
    let mut gen_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, iterator_proto_val));
+    // 站点标签：与 AsyncGenerator 原型的同名方法槽（next/return/throw）区分复用键。
+    let gen_label = sf.intern("GeneratorPrototype").0;
    oxide_kernel::bind_methods_static!(
        &mut gen_proto,
        sf,
        sh,
        world,
+        gen_label,
        ("next", generator_next as *const (), 1),
        ("return", generator_return as *const (), 1),
        ("throw", generator_throw as *const (), 1),
@@ -750,7 +753,7 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
    gen_proto.set_data_meta(tag_pos, oxide_types::object::PropAttributes::new(false, false, true));
    // @@iterator：返回自身（生成器是可迭代对象）。
    let iter_key = oxide_types::private_key::make_well_known_symbol_key(0);
-    let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_static(
+    let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_labeled_static(
        &mut gen_proto,
        sh,
        sf,
@@ -759,30 +762,43 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
        unsafe { oxide_types::object::NativeFnPtr::from_raw(generator_symbol_iterator as *const ()) },
        0,
        world,
+        gen_label,
    );
    Vm::swap_intrinsic_proto(&mut vm.generator_proto, *gen_proto);

    // %GeneratorFunction.prototype%：proto = Function.prototype，constructor = %GeneratorFunction%。
-    let mut gf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    gf_ctor.set_function(true);
-    gf_ctor.set_native_arg_count(1);
    let mut gf_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
-    // %GeneratorFunction% 构造器：动态生成器函数创建未实现，调用抛 TypeError。
-    gf_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(generator_function_stub as *const ()) }));
-    // prototype/name 属性（构造器形状 [prototype, name]）。
-    let proto_si = sf.intern("prototype").0;
-    let ctor_shape = sh.make_shape(gf_ctor.shape_id(), proto_si);
-    gf_ctor.set_shape_id(ctor_shape);
-    let name_si = sf.intern("name").0;
-    let name_shape = sh.make_shape(gf_ctor.shape_id(), name_si);
-    gf_ctor.set_shape_id(name_shape);
+    // %GeneratorFunction% 占位构造器：动态生成器函数创建未实现，调用抛
+    // TypeError。选择性重建复用：前轮占位构造器按键迁移（prototype 槽在
+    // 下方 P 槽换入后重指新原型），不再每轮新建对象。
+    let gf_ctor_label = sf.intern("GeneratorFunctionCtor").0;
+    let gf_reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, gf_ctor_label, 0, 0);
+    // SAFETY: generator_function_stub 是 NativeFn 函数项。
+    let gf_stub_ptr = unsafe { NativeFnPtr::from_raw(generator_function_stub as *const ()) };
+    let (gf_ctor_ptr, gf_ctor_is_new) = match world.find_fn_wrapper(gf_reuse_key, gf_stub_ptr, 1) {
+        Some(ptr) => (ptr, false),
+        None => {
+            let mut gf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
+            gf_ctor.set_function(true);
+            gf_ctor.set_native_arg_count(1);
+            gf_ctor.set_native_fn(Some(gf_stub_ptr));
+            // prototype/name 属性（构造器形状 [prototype, name]）。
+            let proto_si = sf.intern("prototype").0;
+            let ctor_shape = sh.make_shape(EMPTY_SHAPE_ID, proto_si);
+            gf_ctor.set_shape_id(ctor_shape);
+            let name_si = sf.intern("name").0;
+            let name_shape = sh.make_shape(gf_ctor.shape_id(), name_si);
+            gf_ctor.set_shape_id(name_shape);
+            let gf_ctor_ptr = Box::into_raw(gf_ctor);
+            // 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
+            world.track_fn_wrapper(gf_ctor_ptr, gf_reuse_key);
+            (gf_ctor_ptr, true)
+        }
+    };
    // gf_proto.constructor = gf_ctor（构造器登记进 world 释放表，与 builtin 方法 wrapper 同生命周期）。
    let ctor_si = sf.intern("constructor").0;
    let ctor2_shape = sh.make_shape(gf_proto.shape_id(), ctor_si);
    gf_proto.set_shape_id(ctor2_shape);
-    // 登记进释放表：session 收尾统一释放构造器本体与属性区。
-    let gf_ctor_ptr = Box::into_raw(gf_ctor);
-    world.track_leaked_object(gf_ctor_ptr);
    let cpos = gf_proto.push_prop(JsValue::from_js_object(gf_ctor_ptr));
    gf_proto.set_data_meta(cpos, oxide_types::object::PropAttributes::new(false, false, true));
    // gf_proto.prototype = %GeneratorPrototype%（默认原型，default-proto 测试读取）。
@@ -800,15 +816,29 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {

    // proto 本体只存在于 P 槽（Arc 副本，原 Box 随函数结束释放）：装入 P 槽后再写
    // 构造器 prototype/name 属性（按模板序 prototype 在前），prototype 指向 P 槽实例，
-    // 使其与动态生成器函数使用的 [[Prototype]] 同一对象。
+    // 使其与动态生成器函数使用的 [[Prototype]] 同一对象。复用构造器槽位已填充，
+    // prototype 原位改指新 P 原型（旧原型已随 P 换出释放）。
    Vm::swap_intrinsic_proto(&mut vm.generator_function_proto, *gf_proto);
-    // SAFETY: gf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），对象已建满、本 Vm 独占。
+    // SAFETY: gf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），本 Vm 独占。
    unsafe {
        let ctor_mut = &mut *gf_ctor_ptr;
-        let ppos = ctor_mut.push_prop(JsValue::from_js_object(vm.generator_function_proto.as_mut_ptr()));
-        ctor_mut.set_data_meta(ppos, oxide_types::object::PropAttributes::new(false, false, false));
-        let npos = ctor_mut.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("GeneratorFunction").0)));
-        ctor_mut.set_data_meta(npos, oxide_types::object::PropAttributes::new(false, false, true));
+        let proto_val = JsValue::from_js_object(vm.generator_function_proto.as_ptr() as *mut JsObject);
+        let name_val = JsValue::perm_string(sf.string_ptr(sf.intern("GeneratorFunction").0));
+        if gf_ctor_is_new {
+            let ppos = ctor_mut.push_prop(proto_val);
+            ctor_mut.set_data_meta(ppos, oxide_types::object::PropAttributes::new(false, false, false));
+            let npos = ctor_mut.push_prop(name_val);
+            ctor_mut.set_data_meta(npos, oxide_types::object::PropAttributes::new(false, false, true));
+        } else {
+            let si_prototype = sf.intern("prototype").0;
+            if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_prototype) {
+                ctor_mut.set_prop_at(pos, proto_val);
+            }
+            let si_name = sf.intern("name").0;
+            if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_name) {
+                ctor_mut.set_prop_at(pos, name_val);
+            }
+        }
    }
 }

@@ -827,6 +827,93 @@ mod tests {
        assert!(!vm.session.is_dirty_since_snapshot());
    }

+    /// P 原型上方法槽的 wrapper 对象原始指针（rebuild 跨轮复用验证用）。
+    fn method_wrapper_ptr(vm: &Vm, proto_ptr: *const JsObject, name: &str) -> *const JsObject {
+        let si = vm.kernel_core.perm_interner().intern(name).0;
+        // SAFETY: proto_ptr 是本 session 的 P 原型，安全点内无并发读者。
+        let proto = unsafe { &*proto_ptr };
+        let pos = vm
+            .kernel_core
+            .shape_forge()
+            .lookup_position(proto.shape_id(), si)
+            .unwrap_or_else(|| panic!("{name} 槽位应存在"));
+        let val = proto.get_prop_at(pos);
+        assert!(val.is_object(), "{name} 槽位应为 wrapper 对象: {val:?}");
+        val.as_js_object_ptr()
+    }
+
+    /// global 属性槽数（槽位原位更新跨轮不追加验证用）。
+    fn global_slot_count(vm: &Vm) -> usize {
+        let g = vm.session.global_object.as_ptr() as *mut JsObject;
+        // SAFETY: global 是本 session 对象，安全点内无并发读者。
+        unsafe { (*g).prop_vec_len() }
+    }
+
+    /// 选择性重建 wrapper 复用与 global 槽原位更新：每轮「原型脏写 + full_reset」
+    /// 后存活方法 wrapper 应为同一对象（同 raw 指针、同 shape），释放表计数与
+    /// global 属性槽数跨轮不增长，重建后方法行为正确。
+    #[test]
+    fn full_reset_rebuild_reuses_method_wrappers_across_rounds() {
+        let mut vm = Vm::new();
+        let _ = run_source(&mut vm, "0");
+        let push_before = method_wrapper_ptr(&vm, vm.session.builtin_world().array_proto.as_ptr(), "push");
+        let push_shape_before = unsafe { &*push_before }.shape_id();
+        let registry_before = vm.session.builtin_world().leaked_object_count();
+        let slots_before = global_slot_count(&vm);
+
+        for i in 0..3u32 {
+            // 新键写才 bump 原型世代；四家族逐轮全脏，function 家族重建同时
+            // 覆盖 wrapper proto 槽重指路径。
+            let source = format!(
+                "Object.prototype['w{i}'] = 1; Array.prototype['w{i}'] = 2; String.prototype['w{i}'] = 3; \
+                 Function.prototype['w{i}'] = 4; 0"
+            );
+            let _ = run_source(&mut vm, &source);
+            vm.full_reset();
+        }
+
+        let push_after = method_wrapper_ptr(&vm, vm.session.builtin_world().array_proto.as_ptr(), "push");
+        assert!(std::ptr::eq(push_before, push_after), "存活方法 wrapper 应复用（同 raw 指针）");
+        assert_eq!(push_shape_before, unsafe { &*push_after }.shape_id(), "wrapper shape 应稳定");
+        let registry_after = vm.session.builtin_world().leaked_object_count();
+        assert!(
+            registry_after <= registry_before,
+            "释放表计数跨轮不应增长: {registry_before} -> {registry_after}"
+        );
+        let slots_after = global_slot_count(&vm);
+        assert!(slots_after <= slots_before, "global 槽数跨轮不应增长: {slots_before} -> {slots_after}");
+        assert_eq!(run_source(&mut vm, "[1, 2].push(3)"), JsValue::int(3));
+        assert_eq!(run_source(&mut vm, "String.prototype.charCodeAt.call('A', 0)"), JsValue::int(65));
+    }
+
+    /// global 槽位原位更新锚点：错误/资源栈家族脏重建（子类型构造器经 Box 自建
+    /// 路径）多轮后 global 属性槽数不增长、Error 槽指向新构造器。
+    #[test]
+    fn full_reset_rebuild_keeps_global_slot_count_flat() {
+        let mut vm = Vm::new();
+        let _ = run_source(&mut vm, "0");
+        let slots_before = global_slot_count(&vm);
+
+        for i in 0..3u32 {
+            // 新键写脏错误家族（子类型原型重建触发构造器 Box 路径）与对象家族。
+            let source = format!(
+                "Error.prototype['e{i}'] = 1; TypeError.prototype['e{i}'] = 2; Object.prototype['e{i}'] = 3; 0"
+            );
+            let _ = run_source(&mut vm, &source);
+            vm.full_reset();
+        }
+
+        let slots_after = global_slot_count(&vm);
+        assert!(slots_after <= slots_before, "global 槽数跨轮不应增长: {slots_before} -> {slots_after}");
+        // Error 槽应指向本轮重建的构造器（非滞留旧指针）。
+        assert!(std::ptr::eq(
+            global_prop(&vm, "Error").as_js_object_ptr(),
+            vm.session.builtin_world().error_constructor.as_ptr() as *mut JsObject
+        ));
+        assert!(global_prop(&vm, "TypeError").is_object());
+        assert_eq!(run_source(&mut vm, "new TypeError('x') instanceof TypeError"), JsValue::bool(true));
+    }
+
    fn vm_with_low_threshold() -> Vm {
        let mut cfg = KernelConfig::minimal();
        cfg.set_session_gc_threshold(1);