fix: tagged template 语义修正——cooked undefined/this绑定/site缓存/冻结 + groupBy getter 异常传播 + defineGetter setter 保留

crates/oxide_builtins/src/map.rs

@@ -394,7 +394,7 @@ pub fn map_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let sym_iter_si = oxide_types::private_key::make_well_known_symbol_key(0);
     let iter_method = match unsafe { vm.ordinary_get(&*items_ptr, sym_iter_si, items_val) } {
         Ok(m) => m,
-        Err(e) => return NativeResult::Err(crate::error::create_type_error(vm, &e)),
+        Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
     };
     if !crate::iterator::is_callable(iter_method) {
         return NativeResult::Err(crate::error::create_type_error(vm, "Map.groupBy: items[Symbol.iterator] is not callable"));
@@ -413,19 +413,19 @@ pub fn map_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let next_si = vm.kernel_core().perm_interner().intern("next").0;
     let next_fn = match vm.ordinary_get(iter_obj, next_si, iter_val) {
         Ok(f) => f,
-        Err(e) => return NativeResult::Err(crate::error::create_type_error(vm, &e)),
+        Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
     };
     // 读取 Map.set / Map.get 方法。
     let map_ref = unsafe { &*map_obj };
     let set_si = vm.kernel_core().perm_interner().intern("set").0;
     let adder = match vm.ordinary_get(map_ref, set_si, map_val) {
         Ok(v) => v,
-        Err(e) => return NativeResult::Err(crate::error::create_type_error(vm, &e)),
+        Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
     };
     let get_si = vm.kernel_core().perm_interner().intern("get").0;
     let getter = match vm.ordinary_get(map_ref, get_si, map_val) {
         Ok(v) => v,
-        Err(e) => return NativeResult::Err(crate::error::create_type_error(vm, &e)),
+        Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
     };
     if !crate::iterator::is_callable(adder) || !crate::iterator::is_callable(getter) {
         return NativeResult::Err(crate::error::create_type_error(vm, "Map.groupBy: Map.set/get is not callable"));
@@ -446,7 +446,7 @@ pub fn map_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         let done_si = vm.kernel_core().perm_interner().intern("done").0;
         let done = match vm.ordinary_get(nr, done_si, next_result) {
             Ok(v) => oxide_runtime_api::to_boolean(v),
-            Err(_) => false,
+            Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
         };
         if done {
             break;
@@ -454,7 +454,7 @@ pub fn map_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         let value_si = vm.kernel_core().perm_interner().intern("value").0;
         let element = match vm.ordinary_get(nr, value_si, next_result) {
             Ok(v) => v,
-            Err(_) => JsValue::undefined(),
+            Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
         };
         // 调用 callbackFn(element, counter)：counter 对数组 items 即元素下标 k。
         let group_key = match vm.call_function_sync(callback_val, JsValue::undefined(), &[element, JsValue::int(counter)]) {

crates/oxide_builtins/src/object.rs

@@ -712,6 +712,26 @@ pub fn object_get_own_property_descriptor<H: VmHost>(vm: &mut H, args: &[u8]) ->
     let obj_ptr = obj_val.as_js_object_ptr();
     let key = vm.property_key_si(vm.reg(args[2]));
     let obj = unsafe { &*obj_ptr };
+
+    // 数组 length 是虚拟属性（无 shape 槽，ordinary_get 直接返回逻辑长度）：
+    // 描述符 {value: len, writable: !frozen, enumerable: false, configurable: false}。
+    // 冻结数组（含模板对象）writable=false；普通数组 writable=true。
+    let length_si = vm.kernel_core().perm_interner().intern("length").0;
+    if obj.is_array() && key == length_si {
+        let desc_proto = vm.session().builtin_world().object_proto.as_ptr() as *mut JsObject;
+        let desc = vm.alloc_object(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(desc_proto)));
+        let sh = vm.kernel_core().shape_forge().as_ref() as *const ShapeForge;
+        let sf = vm.kernel_core().perm_interner().as_ref() as *const PermInterner;
+        let d: &mut JsObject = unsafe { &mut *desc };
+        let sh = unsafe { &*sh };
+        let sf = unsafe { &*sf };
+        push_desc_prop(d, sh, sf.intern("value").0, obj.logical_len_value());
+        push_desc_prop(d, sh, sf.intern("writable").0, JsValue::bool(!obj.is_frozen()));
+        push_desc_prop(d, sh, sf.intern("enumerable").0, JsValue::bool(false));
+        push_desc_prop(d, sh, sf.intern("configurable").0, JsValue::bool(false));
+        return NativeResult::Ok(JsValue::from_js_object(desc));
+    }
+
     let Some(offset) = vm.get_own_property_slot(obj, key) else {
         return NativeResult::Ok(JsValue::undefined());
     };
@@ -1275,7 +1295,15 @@ pub fn object_proto_define_getter<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeR
     };
     let obj = unsafe { &mut *obj_val.as_js_object_ptr() };
     let attrs = PropAttributes::new(false, true, true);
-    if let Err(e) = vm.define_accessor_property(obj, key_si, getter, JsValue::undefined(), attrs) {
+    // DefinePropertyOrThrow 的 desc 无 [[Set]] 键：覆盖既有访问器时保留其 setter
+    // （define_accessor_property 是全量替换，set 缺省须显式传现有值）。
+    let existing_set = vm
+        .get_own_property_slot(obj, key_si)
+        .and_then(|pos| obj.prop_meta_at(pos))
+        .filter(|m| m.is_accessor)
+        .map(|m| m.set)
+        .unwrap_or(JsValue::undefined());
+    if let Err(e) = vm.define_accessor_property(obj, key_si, getter, existing_set, attrs) {
         return NativeResult::Err(crate::error::create_type_error(vm, &e));
     }
     NativeResult::Ok(JsValue::undefined())
@@ -1347,7 +1375,7 @@ pub fn object_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let sym_iter_si = make_well_known_symbol_key(0);
     let iter_method = match unsafe { vm.ordinary_get(&*items_ptr, sym_iter_si, items_val) } {
         Ok(m) => m,
-        Err(e) => return NativeResult::Err(crate::error::create_type_error(vm, &e)),
+        Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
     };
     if !is_callable(iter_method) {
         return NativeResult::Err(crate::error::create_type_error(vm, "Object.groupBy: items[Symbol.iterator] is not callable"));
@@ -1366,7 +1394,7 @@ pub fn object_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let next_si = vm.kernel_core().perm_interner().intern("next").0;
     let next_fn = match vm.ordinary_get(iter_obj, next_si, iter_val) {
         Ok(f) => f,
-        Err(e) => return NativeResult::Err(crate::error::create_type_error(vm, &e)),
+        Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
     };
     // 创建结果对象（OrdinaryObjectCreate(null)，与 Object.create(null) 同款）。
     let result = vm.alloc_object(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()));
@@ -1387,7 +1415,7 @@ pub fn object_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         let done_si = vm.kernel_core().perm_interner().intern("done").0;
         let done = match vm.ordinary_get(nr, done_si, next_result) {
             Ok(v) => oxide_runtime_api::to_boolean(v),
-            Err(_) => false,
+            Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
         };
         if done {
             break;
@@ -1395,7 +1423,7 @@ pub fn object_group_by<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         let value_si = vm.kernel_core().perm_interner().intern("value").0;
         let element = match vm.ordinary_get(nr, value_si, next_result) {
             Ok(v) => v,
-            Err(_) => JsValue::undefined(),
+            Err(e) => return NativeResult::Err(crate::iterator::engine_error(vm, &e)),
         };
         // 调用 callbackFn(element, counter)：counter 对数组 items 即元素下标 k。
         let key = match vm.call_function_sync(callback_val, JsValue::undefined(), &[element, JsValue::int(counter)]) {

crates/oxide_bytecode/src/opcode.rs

@@ -335,6 +335,14 @@ define_opcodes! {
         def = Some(SlotSpec::Slot(Slot::Rd)), uses = [SlotSpec::TemplateExprs],
         pure = true, jump = false, term = false, ic = false,
 
+    // ── 标签模板对象 (0x97) ──
+    // GetTemplateObject：按 site 缓存模板对象（同一编译树同 site 恒返回同一对象），
+    // 首次构建时冻结 cooked/raw 数组并设置规范描述符。ext 布局见
+    // `Inst::get_template_object`；无寄存器 use（quasis 全为常量池下标）。
+    GET_TEMPLATE_OBJECT = 0x97 => "GET_TEMPLATE_OBJECT",
+        def = Some(SlotSpec::Slot(Slot::Rd)), uses = [],
+        pure = false, jump = false, term = false, ic = false,
+
     // ── 小语言特性 (0x39-0x3B) ──
     DELETE_PROP_STATIC = 0x39 => "DELETE_PROP_STATIC",
         def = None, uses = [SlotSpec::Slot(Slot::Rd)],

crates/oxide_emit/src/emit.rs

@@ -230,6 +230,10 @@ pub struct CompileCtx {
     pub(crate) module_self_import_specs: HashSet<String>,
     /// 自导入别名：导出名 → 本地绑定槽寄存器（export 语句执行时回写绑定值）。
     pub(crate) module_self_aliases: HashMap<String, u32>,
+    /// 标签模板 site 计数器：本编译树内全局唯一（子 ctx 继承父值继续递增）。
+    /// 运行时与模块 flat_id 组成模板对象缓存键，保证同一编译树同 site 恒返回
+    /// 同一对象、不同编译树（eval 每次编译）互不共享。
+    pub(crate) next_template_site: u32,
 }
 
 /// 函数体编译上下文：决定 `this`/`super` 绑定与参数前导（prologue）形态。
@@ -337,6 +341,7 @@ impl CompileCtx {
             module_dep_ns_regs: HashMap::new(),
             module_self_import_specs: HashSet::new(),
             module_self_aliases: HashMap::new(),
+            next_template_site: 0,
         }
     }
 
@@ -1059,6 +1064,9 @@ impl Emitter {
         ctx.scopes.private_element_kinds = parent_ctx.scopes.private_element_kinds.clone();
         ctx.scopes.private_brand_id = parent_ctx.scopes.private_brand_id;
         ctx.scopes.next_private_name_id = parent_ctx.scopes.next_private_name_id;
+        // 标签模板 site 序号继承：整棵编译树全局唯一（跨嵌套函数递增），
+        // 运行时以 (flat_id, site_no) 缓存模板对象，跨函数不冲突。
+        ctx.next_template_site = parent_ctx.next_template_site;
 
         // 传递 enclosing_this_reg：嵌套箭头函数捕获正确的 `this`。
         ctx.enclosing_this_reg = parent_ctx.enclosing_this_reg;

crates/oxide_emit/src/expr/template/tagged.rs

@@ -1,107 +1,73 @@
-//! 标签模板表达式 emit：`emit_tagged_template_expression` 构造 template object 并调用标签函数。
+//! 标签模板表达式 emit：`emit_tagged_template_expression` 按 GetTemplateObject 语义
+//! 经 GET_TEMPLATE_OBJECT 指令取（缓存）模板对象并调用标签函数。
 
 use crate::{CompileCtx, Emitter};
 use oxide_bytecode::module::Constant;
 use oxide_bytecode::opcode::OpCode;
 use oxide_ir::inst::Inst;
 use oxide_ir::operand::Operand;
+use oxide_parser::Expression;
 impl Emitter {
     pub(crate) fn emit_tagged_template_expression(
         &self, tt: &oxide_parser::TaggedTemplateExpression, ctx: &mut CompileCtx,
     ) -> Result<u32, String> {
-        let quasis = &tt.quasi.quasis;
-        let expressions = &tt.quasi.expressions;
+        // 标签求值 + receiver 绑定：成员表达式标签保留对象作 this（与 call.rs 同款
+        // 约定），其余标签 this = undefined。
+        let (tag_reg, this_reg) = self.emit_tagged_tag(&tt.tag, ctx)?;
 
-        let tag_reg = self.emit_expression(&tt.tag, ctx)?;
-
-        let cooked_temp = ctx.alloc_reg();
-        ctx.inst(Inst::new(
-            OpCode::NEW_ARRAY,
-            Operand::Reg(cooked_temp),
-            Operand::Imm(quasis.len() as u16),
-            Operand::None,
-        ));
-        for (i, quasi) in quasis.iter().enumerate() {
-            let s = quasi.value.cooked.as_ref().map(|c| c.to_string()).unwrap_or_default();
-            let const_idx = ctx.add_constant(Constant::String(s));
-            let str_reg = ctx.alloc_reg();
-            ctx.inst(Inst::load_const(Operand::Reg(str_reg), const_idx));
-            let idx_const = ctx.add_constant(Constant::Int(i as i32));
-            let idx_reg = ctx.alloc_reg();
-            ctx.inst(Inst::load_const(Operand::Reg(idx_reg), idx_const));
-            ctx.inst(Inst::new(
-                OpCode::SET_ELEM,
-                Operand::Reg(cooked_temp),
-                Operand::Reg(idx_reg),
-                Operand::Reg(str_reg),
-            ));
+        // 模板对象：GetTemplateObject 语义（cooked/raw 数组 + raw 属性，冻结 +
+        // 按 site 缓存）由 GET_TEMPLATE_OBJECT 指令在运行时统一构建/复用。
+        // cooked 为 None（非法转义）→ 元素 undefined；raw 恒为字符串。
+        let mut cooked_words: Vec<u32> = Vec::with_capacity(tt.quasi.quasis.len());
+        let mut raw_idxs: Vec<u16> = Vec::with_capacity(tt.quasi.quasis.len());
+        for quasi in &tt.quasi.quasis {
+            match quasi.value.cooked.as_ref() {
+                Some(c) => {
+                    let idx = ctx.add_constant(Constant::String(c.to_string()));
+                    cooked_words.push(idx as u32);
+                }
+                None => cooked_words.push(0x8000_0000),
+            }
+            let raw_idx = ctx.add_constant(Constant::String(quasi.value.raw.to_string()));
+            raw_idxs.push(raw_idx);
         }
-
-        let raw_temp = ctx.alloc_reg();
-        ctx.inst(Inst::new(
-            OpCode::NEW_ARRAY,
-            Operand::Reg(raw_temp),
-            Operand::Imm(quasis.len() as u16),
-            Operand::None,
-        ));
-        for (i, quasi) in quasis.iter().enumerate() {
-            let raw = quasi.value.raw.to_string();
-            let const_idx = ctx.add_constant(Constant::String(raw));
-            let str_reg = ctx.alloc_reg();
-            ctx.inst(Inst::load_const(Operand::Reg(str_reg), const_idx));
-            let idx_const = ctx.add_constant(Constant::Int(i as i32));
-            let idx_reg = ctx.alloc_reg();
-            ctx.inst(Inst::load_const(Operand::Reg(idx_reg), idx_const));
-            ctx.inst(Inst::new(
-                OpCode::SET_ELEM,
-                Operand::Reg(raw_temp),
-                Operand::Reg(idx_reg),
-                Operand::Reg(str_reg),
-            ));
-        }
-
-        // 模板对象：按 GetTemplateObject 语义把 raw 数组挂到 cooked 数组的 "raw"
-        // 属性，使标签函数首参为标准模板对象（cooked 数组 + raw 属性）。
-        // String.raw / 模板标签测试依赖 template.raw 存在。
-        let raw_key_idx = ctx.add_constant(Constant::String("raw".to_string()));
-        let raw_key_reg = ctx.alloc_reg();
-        ctx.inst(Inst::load_const(Operand::Reg(raw_key_reg), raw_key_idx));
-        ctx.inst(Inst::new(
-            OpCode::SET_PROP,
-            Operand::Reg(cooked_temp),
-            Operand::Reg(raw_temp),
-            Operand::Reg(raw_key_reg),
+        let site_no = ctx.next_template_site;
+        ctx.next_template_site += 1;
+        let template_reg = ctx.alloc_reg();
+        ctx.inst(Inst::get_template_object(
+            Operand::Reg(template_reg),
+            site_no,
+            &cooked_words,
+            &raw_idxs,
         ));
 
+        // 表达式实参：求值顺序在模板对象之后（规范 TaggedTemplate 求值序：
+        // 标签引用 → GetTemplateObject → 实参表达式）。
         let mut expr_temps = Vec::new();
-        for expr in expressions {
+        for expr in &tt.quasi.expressions {
             expr_temps.push(self.emit_expression(expr, ctx)?);
         }
 
         let cooked_slot = ctx.alloc_reg();
         let mut expr_slots = Vec::new();
-        for _ in expressions {
+        for _ in &tt.quasi.expressions {
             expr_slots.push(ctx.alloc_reg());
         }
 
         ctx.inst(Inst::new(
             OpCode::LOAD_VAR,
             Operand::Reg(cooked_slot),
-            Operand::Reg(cooked_temp),
+            Operand::Reg(template_reg),
             Operand::None,
         ));
         for (slot, temp) in expr_slots.iter().zip(expr_temps.iter()) {
             ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(*slot), Operand::Reg(*temp), Operand::None));
         }
 
-        let undef_idx = ctx.add_constant(Constant::Undefined);
-        let undef_reg = ctx.alloc_reg();
-        ctx.inst(Inst::load_const(Operand::Reg(undef_reg), undef_idx));
-
-        let arg_count = 1 + expressions.len();
+        let arg_count = 1 + tt.quasi.expressions.len();
         ctx.inst(Inst::call(
             Operand::Reg(tag_reg),
-            Operand::Reg(undef_reg),
+            Operand::Reg(this_reg),
             Operand::Reg(cooked_slot),
             arg_count as u8,
         ));
@@ -110,4 +76,101 @@ impl Emitter {
         ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg), Operand::None, Operand::None));
         Ok(result_reg)
     }
-}
+
+    /// 标签表达式的 `(callee, this)` 对：成员表达式（静态/计算/私有字段）保留
+    /// 对象作 receiver（GetThisValue(tagRef)），其余标签 this = undefined。
+    /// 与 call.rs 的 `emit_call_expression` 同款求值模式。
+    fn emit_tagged_tag(&self, tag: &Expression, ctx: &mut CompileCtx) -> Result<(u32, u32), String> {
+        let undefined_reg = {
+            let idx = ctx.add_constant(Constant::Undefined);
+            let r = ctx.alloc_reg();
+            ctx.inst(Inst::load_const(Operand::Reg(r), idx));
+            r
+        };
+        let pair = match tag {
+            Expression::StaticMemberExpression(member) => {
+                if matches!(&member.object, Expression::Super(_)) {
+                    if !ctx.in_instance_method && !ctx.in_static_method && !ctx.in_derived_constructor {
+                        return Err("super property only supported in class methods".into());
+                    }
+                    let prop_name = member.property.name.as_str();
+                    let key_reg = ctx.alloc_reg();
+                    let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
+                    ctx.inst(Inst::load_const(Operand::Reg(key_reg), idx));
+                    let this_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(this_reg), Operand::This, Operand::None));
+                    let callee_reg = ctx.alloc_reg();
+                    let op = if ctx.in_static_method {
+                        OpCode::SUPER_STATIC_GET_PROP
+                    } else {
+                        OpCode::SUPER_GET_PROP
+                    };
+                    ctx.inst(Inst::new(op, Operand::Reg(callee_reg), Operand::Reg(this_reg), Operand::Reg(key_reg)));
+                    (callee_reg, this_reg)
+                } else {
+                    let obj_reg = self.emit_expression(&member.object, ctx)?;
+                    let callee_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(
+                        OpCode::LOAD_VAR,
+                        Operand::Reg(callee_reg),
+                        Operand::Reg(obj_reg),
+                        Operand::None,
+                    ));
+                    let prop_name = member.property.name.as_str();
+                    let key_reg = ctx.alloc_reg();
+                    let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
+                    ctx.inst(Inst::load_const(Operand::Reg(key_reg), idx));
+                    ctx.inst(Inst::ic_get(Operand::Reg(callee_reg), Operand::Reg(key_reg)));
+                    (callee_reg, obj_reg)
+                }
+            }
+            Expression::ComputedMemberExpression(member) => {
+                let obj_reg = self.emit_expression(&member.object, ctx)?;
+                if let Some(key) = crate::expr::member::computed_const_key(&member.expression) {
+                    let key_reg = ctx.alloc_reg();
+                    let idx = ctx.add_constant(Constant::String(key));
+                    ctx.inst(Inst::load_const(Operand::Reg(key_reg), idx));
+                    let callee_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(
+                        OpCode::LOAD_VAR,
+                        Operand::Reg(callee_reg),
+                        Operand::Reg(obj_reg),
+                        Operand::None,
+                    ));
+                    ctx.inst(Inst::ic_get(Operand::Reg(callee_reg), Operand::Reg(key_reg)));
+                    (callee_reg, obj_reg)
+                } else {
+                    let key_reg = self.emit_expression(&member.expression, ctx)?;
+                    let callee_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(
+                        OpCode::GET_PROP_DYNAMIC,
+                        Operand::Reg(obj_reg),
+                        Operand::Reg(key_reg),
+                        Operand::Reg(callee_reg),
+                    ));
+                    (callee_reg, obj_reg)
+                }
+            }
+            Expression::PrivateFieldExpression(member) => {
+                let obj_reg = self.emit_expression(&member.object, ctx)?;
+                let name = member.field.name.as_str();
+                let (brand_reg, brand_id) = self.private_access_brand(obj_reg, name, ctx)?;
+                let key_reg = self.emit_private_id_reg(name, ctx)?;
+                let callee_reg = ctx.alloc_reg();
+                ctx.inst(Inst::get_private(
+                    Operand::Reg(callee_reg),
+                    Operand::Reg(obj_reg),
+                    Operand::Reg(key_reg),
+                    brand_reg,
+                    brand_id,
+                ));
+                (callee_reg, obj_reg)
+            }
+            _ => {
+                let tag_reg = self.emit_expression(tag, ctx)?;
+                (tag_reg, undefined_reg)
+            }
+        };
+        Ok(pair)
+    }
+}

crates/oxide_ir/src/inst.rs

@@ -293,6 +293,32 @@ impl Inst {
         }
     }
 
+    /// GET_TEMPLATE_OBJECT：构建/取缓存模板对象（GetTemplateObject 语义）。
+    ///
+    /// # ext 布局
+    /// - `ext[0]`：quasis 段数 n；
+    /// - `ext[1..=2n]`：每段交错两个字——cooked 字（`0x8000_0000` 高位标记
+    ///   cooked 为 None（非法转义 → 元素为 undefined），低 31 位是常量池下标）
+    ///   与 raw 字（常量池下标）；
+    /// - `ext[2n+1]`：site 序号（编译树内全局唯一，与模块 flat_id 组成缓存键）。
+    pub fn get_template_object(dst: Operand, site_no: u32, cooked_idx: &[u32], raw_idx: &[u16]) -> Self {
+        let n = cooked_idx.len();
+        let mut ext = SmallVec::with_capacity(2 + 2 * n);
+        ext.push(n as u32);
+        for i in 0..n {
+            ext.push(cooked_idx[i]);
+            ext.push(raw_idx[i] as u32);
+        }
+        ext.push(site_no);
+        Self {
+            op: OpCode::GET_TEMPLATE_OBJECT,
+            rd: dst,
+            a: Operand::None,
+            b: Operand::None,
+            ext,
+        }
+    }
+
     // ── RegAlloc 辅助指令 ──
 
     /// 寄存器复制 rd = a（RegAlloc 区间拆分时搬值）。

crates/oxide_vm/src/vm.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::arc_with_non_send_sync)]
 
-use std::collections::VecDeque;
+use std::collections::{HashMap, VecDeque};
 use std::sync::{Arc, OnceLock};
 
 use num_traits::Zero;
@@ -375,6 +375,7 @@ pub(crate) struct InlineSyncState {
     pub(crate) inline_args_base: u32,
     pub(crate) inline_args_count: u16,
     pub(crate) accessor_frame_target_reg: Option<u8>,
+    pub(crate) active_flat_id: u32,
 }
 
 /// 基于寄存器的 JS 虚拟机：持有执行状态、寄存器文件、调用栈与 session 内存。
@@ -522,6 +523,15 @@ pub struct Vm {
     /// 分组保存 inline cache 与指令计数器。
     pub(crate) profiling: ProfilingState,
     pub(crate) cell_stack: Vec<Vec<*mut Cell>>,
+    /// 标签模板对象缓存（GetTemplateObject）：键 = (模块 flat_id, site 序号)。
+    /// 同一编译树同 site 恒返回同一对象；每次 `run()` 清空（flat_id 复用防误命中）。
+    /// 值为 GC 根（for_each_value/rewrite_values 遍历）。
+    pub(crate) template_objects: HashMap<(u32, u32), JsValue>,
+    /// 当前活动字节码所属模块的 flat_id（顶层 0；帧切换时随 bytecode 换）。
+    /// GET_TEMPLATE_OBJECT 据其区分不同编译树（eval 每次编译独立 site）。
+    pub(crate) active_flat_id: u32,
+    /// 帧切换时暂存调用方 flat_id 的栈（与 saved_bytecode_stack 同步 push/pop）。
+    pub(crate) saved_flat_id_stack: Vec<u32>,
 }
 
 impl Drop for Vm {
@@ -791,6 +801,10 @@ impl Vm {
         f(self.async_context.unwrap_or(JsValue::undefined()));
         f(self.async_gen_context.unwrap_or(JsValue::undefined()));
         f(self.inline_callee.unwrap_or(JsValue::undefined()));
+        // 标签模板对象缓存：命中的模板对象是 GC 根（未根 → sweep 搬移/回收悬垂）。
+        for &cached in self.template_objects.values() {
+            f(cached);
+        }
         for &entry in &self.iters.for_of_iters {
             f(entry.iterator);
             f(entry.last_result);
@@ -843,6 +857,9 @@ impl Vm {
         self.exception_value = self.exception_value.map(&mut rewrite);
         self.pending_exception = self.pending_exception.map(&mut rewrite);
         self.last_uncaught_value = self.last_uncaught_value.map(&mut rewrite);
+        for cached in self.template_objects.values_mut() {
+            *cached = rewrite(*cached);
+        }
         self.pending_completion = self.pending_completion.map(|completion| match completion {
             Completion::Return {
                 value,
@@ -1393,6 +1410,9 @@ impl Vm {
 
         self.saved_bytecode_stack.push(std::mem::take(&mut self.bytecode));
         self.saved_immutables_stack.push(self.active_immutables);
+        // 记录调用方 flat_id，进入被调模块（标签模板 site 缓存按模块隔离）。
+        self.saved_flat_id_stack.push(self.active_flat_id);
+        self.active_flat_id = sub_idx as u32;
 
         let function_name = self.sub_modules[sub_idx]
             .function_name
@@ -1889,6 +1909,10 @@ impl Vm {
                     self.dispatch_template_str(rd)?;
                 }
 
+                OpCode::GET_TEMPLATE_OBJECT => {
+                    self.dispatch_get_template_object(rd)?;
+                }
+
                 OpCode::DELETE_PROP_STATIC => match self.dispatch_delete_prop_static(rd) {
                     Ok(true) => continue,
                     Ok(false) => {}

crates/oxide_vm/src/vm_dispatch_misc.rs

@@ -1013,4 +1013,103 @@ impl Vm {
         }
         Ok(())
     }
+
+    /// GET_TEMPLATE_OBJECT：GetTemplateObject 语义——按 (模块 flat_id, site 序号)
+    /// 查缓存，未命中则构建模板对象（cooked/raw 数组 + raw 属性）并冻结。
+    ///
+    /// # ext 布局（紧跟指令后的扩展字）
+    /// - `n`：quasis 段数；
+    /// - 每段两个字：cooked 字（高位 `0x8000_0000` 标记非法转义 → undefined，
+    ///   低 31 位为常量池下标）、raw 字（常量池下标）；
+    /// - 末尾：site 序号。
+    ///
+    /// # 副作用
+    /// - 首次构建时分配 cooked/raw 数组并写入 `template_objects` 缓存（GC 根）；
+    ///   缓存命中时零分配。
+    pub(crate) fn dispatch_get_template_object(&mut self, rd: usize) -> Result<(), String> {
+        vm_trace!("GET_TEMPLATE_OBJECT rd={}", rd);
+        let n = self.bytecode[self.pc] as usize;
+        self.pc += 1;
+        let mut cooked_words = Vec::with_capacity(n);
+        let mut raw_idxs = Vec::with_capacity(n);
+        for _ in 0..n {
+            cooked_words.push(self.bytecode[self.pc]);
+            self.pc += 1;
+            raw_idxs.push(self.bytecode[self.pc]);
+            self.pc += 1;
+        }
+        let site_no = self.bytecode[self.pc];
+        self.pc += 1;
+
+        let key = (self.active_flat_id, site_no);
+        if let Some(&cached) = self.template_objects.get(&key) {
+            self.regs[rd] = cached;
+            return Ok(());
+        }
+
+        let proto_ptr = self.session.builtin_world().array_proto.as_ptr() as *mut JsObject;
+        let proto_val = JsValue::from_js_object(proto_ptr);
+        // 模板对象直接分配为 session 对象：跨 epoch 写入（存进 global/数组）时
+        // 免 promote 搬移——若按 epoch 分配，首次写入 session 根会把对象搬到新
+        // 地址，缓存中的旧指针与新实例分叉，同一 site 两次取值将返回不同对象。
+        let mut alloc_session_array = |n: usize| {
+            let mut clone = JsObject::new_array(oxide_kernel::shape_forge::EMPTY_SHAPE_ID, proto_val, n, self.epoch.bump());
+            // 标记 session 归属：session_epoch 分配的对象须显式置位，GC/释放路径
+            // 据 SESSION_EPOCH_BIT 判定归属（与 promote_object 的 clone 路径一致）。
+            clone.set_session_epoch(true);
+            let ptr = self.gc_state.session_epoch.alloc(clone) as *mut JsObject;
+            self.gc_state.session_object_ptrs.push(ptr);
+            ptr
+        };
+        let cooked = alloc_session_array(n);
+        let raw = alloc_session_array(n);
+        let cooked_val = JsValue::from_js_object(cooked);
+        let raw_val = JsValue::from_js_object(raw);
+
+        // 元素：可枚举、不可写、不可配置（模板对象属性恒只读，禁止改写元素）。
+        let elem_attrs = PropAttributes::new(false, true, false);
+        for i in 0..n {
+            let (c_val, r_val) = {
+                // immutables 借用限于本块：promote 需 &mut self，先取值再放行借用。
+                let imm = self.immutables();
+                let c_val = if cooked_words[i] & 0x8000_0000 != 0 {
+                    JsValue::undefined()
+                } else {
+                    imm.get(cooked_words[i] as usize).copied().unwrap_or(JsValue::undefined())
+                };
+                let r_val = imm.get(raw_idxs[i] as usize).copied().unwrap_or(JsValue::undefined());
+                (c_val, r_val)
+            };
+            let c_promoted = self.promote_if_needed_for_write_ptr(cooked, c_val);
+            let r_promoted = self.promote_if_needed_for_write_ptr(raw, r_val);
+            // SAFETY: cooked/raw 为本函数刚分配的 epoch 对象，借用仅在本循环内消费。
+            unsafe {
+                (*cooked).set_prop_at(i, c_promoted);
+                (*cooked).set_data_meta(i, elem_attrs);
+                (*raw).set_prop_at(i, r_promoted);
+                (*raw).set_data_meta(i, elem_attrs);
+            }
+        }
+
+        // raw 属性：不可枚举、不可写、不可配置（规范 desc 无 writable/enumerable
+        // 键，DefinePropertyOrThrow 默认 false）。先于冻结定义（冻结后不可扩展，
+        // 新增属性会被拒）。
+        let raw_si = self.kernel_core.perm_interner().intern("raw").0;
+// SAFETY: cooked 为本函数分配的 epoch 对象，借用仅在本次 define 内消费。
+        self.define_data_property(unsafe { &mut *cooked }, raw_si, raw_val, PropAttributes::new(false, false, false))?;
+
+        // 冻结两个数组：不可扩展 + length writable=false（is_frozen 使 length
+        // 赋值与元素写入经 ordinary_set 拒绝）；length {e:false,w:false,c:false}
+        // 由 getOwnPropertyDescriptor 的数组 length 特判表达。
+        // SAFETY: cooked/raw 为本函数分配的 session 对象。
+        unsafe {
+            (*cooked).set_frozen(true);
+            (*cooked).set_extensible(false);
+            (*raw).set_frozen(true);
+            (*raw).set_extensible(false);
+        }
+        self.template_objects.insert(key, cooked_val);
+        self.regs[rd] = cooked_val;
+        Ok(())
+    }
 }

crates/oxide_vm/src/vm_runtime.rs

@@ -109,6 +109,9 @@ macro_rules! inline_save_field {
     ($recv:ident, $window_regs:ident, accessor_frame_target_reg, copy) => {
         $recv.accessor_frame_target_reg
     };
+    ($recv:ident, $window_regs:ident, active_flat_id, copy) => {
+        $recv.active_flat_id
+    };
 }
 
 /// restore 方向的字段写回语句。`regs` 只回拷窗口并把缓冲归还池。
@@ -189,6 +192,9 @@ macro_rules! inline_restore_field {
     ($recv:ident, $saved:ident, accessor_frame_target_reg, copy) => {
         $recv.accessor_frame_target_reg = $saved.accessor_frame_target_reg
     };
+    ($recv:ident, $saved:ident, active_flat_id, copy) => {
+        $recv.active_flat_id = $saved.active_flat_id
+    };
 }
 
 /// 内联同步调用可搬移执行核心字段的单一登记表。save/restore 双向由本宏展开；
@@ -225,6 +231,7 @@ macro_rules! inline_core_fields {
             (inline_args_base, copy),             // M
             (inline_args_count, copy),            // M
             (accessor_frame_target_reg, copy),    // M
+            (active_flat_id, copy),               // M
         )
     };
 }
@@ -370,6 +377,7 @@ impl Vm {
         self.pc = 0;
         self.bytecode = Arc::clone(&sub.bytecode);
         self.activate_immutables(sub_idx, &sub.constants);
+        self.active_flat_id = sub_idx as u32;
         self.active_reg_limit = sub.n_registers.max(1);
         self.root_reg_limit = self.active_reg_limit;
         self.cell_stack.push(Vec::with_capacity(sub.cells_needed as usize));
@@ -424,6 +432,9 @@ impl Vm {
         if let Some(saved_bc) = self.saved_bytecode_stack.pop() {
             self.bytecode = saved_bc;
         }
+        if let Some(saved_flat) = self.saved_flat_id_stack.pop() {
+            self.active_flat_id = saved_flat;
+        }
         vm_debug!(
             "restore_frame: return_addr={} bc_len={} saved_stack={} fn={:?}",
             frame.return_addr,
@@ -466,6 +477,11 @@ impl Vm {
     pub fn run(&mut self, module: &CompiledModule) -> Result<JsValue, String> {
         vm_debug!("run: starting bytecode execution, {} instructions", module.bytecode.len());
         self.clear_execution_state();
+        // 模板对象缓存按 run 清空：flat_id 每次 run 从 0 重新分配，跨 run 复用会
+        // 让不同编译树的 site 误命中（缓存键 = (flat_id, site_no)）。
+        self.template_objects.clear();
+        self.saved_flat_id_stack.clear();
+        self.active_flat_id = 0;
         self.cell_stack.clear();
         self.cell_stack.push(Vec::new());
         self.sub_modules = Arc::new(collect_flat_modules(module));

crates/oxide_vm/src/vm_support.rs

@@ -117,6 +117,9 @@ impl Vm {
                 instruction_count: 0,
             },
             cell_stack: Vec::new(),
+            template_objects: std::collections::HashMap::new(),
+            active_flat_id: 0,
+            saved_flat_id_stack: Vec::new(),
         };
         vm.init_generator_intrinsics();
         vm.init_promise_intrinsics();
@@ -223,6 +226,9 @@ impl Vm {
                 instruction_count: 0,
             },
             cell_stack: Vec::new(),
+            template_objects: std::collections::HashMap::new(),
+            active_flat_id: 0,
+            saved_flat_id_stack: Vec::new(),
         };
         vm.init_generator_intrinsics();
         vm.init_promise_intrinsics();
@@ -304,6 +310,11 @@ impl Vm {
 
     fn clear_full_reset_state(&mut self) {
         self.clear_execution_state();
+        // 模板对象缓存中的 JsValue 指向将被重建的 session 对象：全量重置后悬垂，
+        // 必须随 session 一并清空。
+        self.template_objects.clear();
+        self.saved_flat_id_stack.clear();
+        self.active_flat_id = 0;
         self.bytecode = Arc::default();
         self.immutables_cache.clear();
         self.active_immutables = std::ptr::slice_from_raw_parts(std::ptr::null(), 0);