fix: 顶层 var 读写直连全局对象属性单一真值——GDI 序言 + 声明处同步删除，类原型 session 直分防晋升克隆 identity 分裂，自增减 int 保持

crates/oxide_emit/src/expr/assignment.rs

@@ -95,15 +95,15 @@ impl Emitter {
                 ctx.inst(Inst::new(op, Operand::Reg(val_reg), Operand::Reg(rhs), Operand::None));
                 return Ok(val_reg);
             }
+            let is_tier = self.is_global_tier_name(ctx, name);
             let is_implicit = ctx.is_implicit_global_reg(var_reg);
             if is_implicit && ctx.is_strict {
                 // 严格模式未声明复合写：未解析引用不可 put，值无关抛 ReferenceError。
                 return self.emit_strict_undeclared_write(name, ctx);
             }
-            // 未声明名槽是入口快照（读侧登记的槽从不被读刷新，同脚本后续写
-            // 可使其脱节）：RMW 前从全局对象属性取旧值，属性缺失按 undefined
-            // （sloppy 未解析引用 GetBaseValue 语义，不抛）。
-            if is_implicit {
+            // RMW 前从全局对象属性取旧值：tier 名（顶层已声明 var）与未声明名同，
+            // 属性缺失按 undefined（GetBaseValue 语义，不抛）。
+            if is_tier || is_implicit {
                 let key_idx = ctx.add_constant(Constant::String(name.to_string()));
                 ctx.inst(Inst::new(
                     OpCode::LOAD_GLOBAL_TYPEOF,
@@ -113,6 +113,10 @@ impl Emitter {
                 ));
             }
             ctx.inst(Inst::new(op, Operand::Reg(var_reg), Operand::Reg(rhs), Operand::None));
+            if is_tier {
+                // 顶层已声明 var 复合赋值：新值落全局对象属性（A 侧单一真值）。
+                self.emit_tier_global_write(name, var_reg, ctx);
+            }
             if is_implicit {
                 self.emit_implicit_global_write(name, var_reg, ctx);
             }
@@ -380,9 +384,9 @@ impl Emitter {
                         ));
                     } else {
                         let var_reg = ctx.lookup_or_global(name);
-                        // 未声明名槽是入口快照（读侧登记的槽从不被读刷新）：
-                        // 旧值读前从全局对象属性取当前值，缺失按 undefined（不抛）。
-                        if ctx.is_implicit_global_reg(var_reg) {
+                        // 顶层已声明 var（tier）与未声明名同：旧值读前从全局对象
+                        // 属性取当前值，缺失按 undefined（不抛）。
+                        if self.is_global_tier_name(ctx, name) || ctx.is_implicit_global_reg(var_reg) {
                             let key_idx = ctx.add_constant(Constant::String(name.to_string()));
                             ctx.inst(Inst::new(
                                 OpCode::LOAD_GLOBAL_TYPEOF,
@@ -431,10 +435,14 @@ impl Emitter {
                         } else if !readonly_builtin {
                             // 隐式全局判定以寄存器集合为准：读侧（旧值解析）已登记绑定，
                             // 写侧二次解析命中集合而非"新登记"。
+                            let is_tier = self.is_global_tier_name(ctx, name);
                             let is_implicit = ctx.is_implicit_global_reg(var_reg);
                             if is_implicit && ctx.is_strict {
                                 // 严格模式未声明写：抛 ReferenceError，后续 LOAD_VAR 不可达。
                                 let _ = self.emit_strict_undeclared_write(name, ctx)?;
+                            } else if is_tier {
+                                // 顶层已声明 var 逻辑赋值：新值落全局对象属性（A 侧单一真值）。
+                                self.emit_tier_global_write(name, val_reg, ctx);
                             } else {
                                 ctx.inst(Inst::new(
                                     OpCode::STORE_VAR,

crates/oxide_emit/src/expr/identifier.rs

@@ -45,9 +45,10 @@ impl Emitter {
             Err(err) => return Err(err),
         };
         let r = ctx.alloc_reg();
-        if ctx.implicit_global_reads.contains(&var_reg) {
-            // 未声明标识符读：运行期查 global object 属性存在性，缺失抛
-            // ReferenceError（sloppy 写先登记全局槽的读不在此集合，仍走 LOAD_VAR）。
+        // 顶层已声明 var 裸读与未声明标识符读同形：读全局对象属性（A 侧单一真值），
+        // 缺失抛 ReferenceError（unresolvable）。tier 名属性由 GDI 序言创建（仅删除后
+        // 缺失）；未声明名属性缺失即 unresolvable。已声明 var 不再落镜像 cell/槽。
+        if self.is_global_tier_name(ctx, name) || ctx.implicit_global_reads.contains(&var_reg) {
             let key_idx = ctx.add_constant(Constant::String(name.to_string()));
             ctx.inst(Inst::new(OpCode::LOAD_GLOBAL, Operand::Reg(r), Operand::Const(key_idx), Operand::None));
         } else {
@@ -109,6 +110,15 @@ impl Emitter {
                     Operand::Imm(cell_idx as u16),
                 ));
             }
+        } else if self.is_global_tier_name(ctx, name) {
+            // 顶层已声明 var：with 对象无该属性时回退读全局对象属性（A 侧单一真值）。
+            let key_idx = ctx.add_constant(Constant::String(name.to_string()));
+            ctx.inst(Inst::new(
+                OpCode::LOAD_GLOBAL,
+                Operand::Reg(result_reg),
+                Operand::Const(key_idx),
+                Operand::None,
+            ));
         } else if let Some(reg) = ctx.scopes.symbols.lookup_any(name) {
             ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg), Operand::Reg(reg), Operand::None));
         } else {
@@ -181,12 +191,18 @@ impl Emitter {
             }
             return;
         }
+        let is_tier = self.is_global_tier_name(ctx, name);
         let is_implicit = ctx.is_implicit_global_reg(var_reg);
         if is_implicit && ctx.is_strict {
             // 严格模式未声明写：发射 ReferenceError 抛错，跳过寄存器写（值无关）。
             let _ = self.emit_strict_undeclared_write(name, ctx);
             return;
         }
+        if is_tier {
+            // 顶层已声明 var 裸写：落全局对象属性（A 侧单一真值），不写镜像槽。
+            self.emit_tier_global_write(name, val_reg, ctx);
+            return;
+        }
         ctx.inst(Inst::new(
             OpCode::STORE_VAR,
             Operand::Reg(var_reg),

crates/oxide_emit/src/expr/operator/mod.rs

@@ -267,7 +267,10 @@ impl Emitter {
             let in_with_dynamic = !ctx.with_stack.is_empty() && !ctx.is_with_internal_binding(name);
             let captured =
                 ctx.current_upvalue_captures.iter().any(|u| u.name == name) || ctx.captured_bindings.contains_key(name);
-            if !in_with_dynamic && !captured && ctx.scopes.symbols.lookup_any_binding(name).is_none() {
+            // 顶层已声明 var：typeof 读全局对象属性（A 侧单一真值），缺失 → "undefined"
+            // （非抛，IsUnresolvableReference 语义）。未声明名同走此路（lookup 未命中）。
+            let is_tier = self.is_global_tier_name(ctx, name);
+            if !in_with_dynamic && !captured && (is_tier || ctx.scopes.symbols.lookup_any_binding(name).is_none()) {
                 let key_idx = ctx.add_constant(Constant::String(name.to_string()));
                 let r = ctx.alloc_reg();
                 ctx.inst(Inst::new(
@@ -632,15 +635,15 @@ impl Emitter {
                 ctx.inst(Inst::new(op, Operand::Reg(tmp_reg), Operand::Reg(result_reg), Operand::Reg(result_reg)));
                 return Ok(result_reg);
             }
+            let is_tier = self.is_global_tier_name(ctx, name);
             let is_implicit = ctx.is_implicit_global_reg(var_reg);
             if is_implicit && ctx.is_strict {
                 // 严格模式未声明更新写：值无关抛 ReferenceError。
                 return self.emit_strict_undeclared_write(name, ctx);
             }
-            // 未声明名槽是入口快照（读侧登记的槽从不被读刷新，同脚本后续写
-            // 可使其脱节）：RMW 前从全局对象属性取旧值，属性缺失按 undefined
-            // （sloppy 未解析引用 GetBaseValue 语义，不抛）。
-            if is_implicit {
+            // RMW 前从全局对象属性取旧值：tier 名（顶层已声明 var）与未声明名同，
+            // 属性缺失按 undefined（update 旧值角落，GetBaseValue 语义，不抛）。
+            if is_tier || is_implicit {
                 let key_idx = ctx.add_constant(Constant::String(name.to_string()));
                 ctx.inst(Inst::new(
                     OpCode::LOAD_GLOBAL_TYPEOF,
@@ -657,6 +660,10 @@ impl Emitter {
                 (UpdateOperator::Decrement, false) => OpCode::DEC_POST,
             };
             ctx.inst(Inst::new(op, Operand::Reg(var_reg), Operand::Reg(result_reg), Operand::Reg(result_reg)));
+            if is_tier {
+                // 顶层已声明 var 自增/自减：新值落全局对象属性（A 侧单一真值）。
+                self.emit_tier_global_write(name, var_reg, ctx);
+            }
             if is_implicit {
                 self.emit_implicit_global_write(name, var_reg, ctx);
             }