diff --git a/Cargo.lock b/Cargo.lock
index e8e526a6..839ec101 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1095,7 +1095,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_builtins"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "chrono",
  "fast-float",
@@ -1120,7 +1120,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_bytecode"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "num-bigint",
  "oxide_log",
@@ -1128,7 +1128,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cfg"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_emit",
@@ -1139,7 +1139,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cli"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "ansi_term",
  "bumpalo",
@@ -1159,7 +1159,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_code_cache"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "lru",
  "oxide_bytecode",
@@ -1168,7 +1168,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_compiler"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1187,7 +1187,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_dce"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1201,7 +1201,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_emit"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "num-bigint",
  "oxc_allocator",
@@ -1216,7 +1216,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_ir"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_log",
@@ -1225,7 +1225,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_kernel"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1240,7 +1240,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_liveness"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1252,7 +1252,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_log"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "tracing",
  "tracing-appender",
@@ -1261,7 +1261,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_parser"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxc_allocator",
  "oxc_ast",
@@ -1276,7 +1276,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_regalloc"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1292,7 +1292,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_runtime_api"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -1304,7 +1304,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_test262"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1321,7 +1321,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_types"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "bumpalo",
  "hashbrown 0.14.5",
@@ -1333,7 +1333,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_vm"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "bumpalo",
  "chrono",
diff --git a/Cargo.toml b/Cargo.toml
index dccabf6a..0ab074eb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.6.1"
+version = "0.6.2"
 edition = "2021"
 license = "MIT"
 rust-version = "1.80"
diff --git a/crates/oxide_vm/tests/microbench.rs b/crates/oxide_vm/tests/microbench.rs
new file mode 100644
index 00000000..7e54bf9e
--- /dev/null
+++ b/crates/oxide_vm/tests/microbench.rs
@@ -0,0 +1,212 @@
+//! 毫秒级热路径微基准套件：方向性过滤器，不是门禁。
+//!
+//! 十个 JS 循环用例，每用例 1 个预热 run 加 3 个测量 run，每 run 均为同一模块的
+//! `Vm::run`（新建 VM 共享同一 KernelCore，免每用例重建 builtin world），3 轮取中位。
+//! 每用例断言 run 结果值等于期望值，防死代码消除。
+//!
+//! 角色是方向性过滤器：候选优化在微基准上无方向性收益即直接否决，不跑端到端；
+//! 有方向性收益须进锚点层（release 端到端）方向确认才采信。不设阈值判定——
+//! debug 构建噪声大，阈值会产 flaky 红，debug 数字仅过滤，不作绝对比较。
+//!
+//! 测量语义：`run()` 不清 IC（IC 扩展字在模块字节码内跨 run 持久），同一模块连续
+//! 多 run 时 IC 从首个 run 起持续热态；预热 run 吸收 IC 学习 miss、分配器与代码
+//! 缓存预热，测量轮全部热态。
+//!
+//! 循环规模按「debug 全套件执行段 5 秒内」约束调参：debug 构建每指令税高（无内联、
+//! 分派 match 开销主导），各用例单轮 30 至 130 毫秒，十用例四轮合计约 4 秒。
+//! 规模不是测量语义的一部分，方向判定只依赖相对变化，跨宿主对比绝对值无意义。
+//!
+//! 日常入口 `cargo test -p oxide_vm micro`（名称过滤）；
+//! `cargo test -p oxide_vm --release micro` 跑 release 口径。
+
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::Instant;
+
+use oxide_bytecode::module::CompiledModule;
+use oxide_compiler::compiler::Compiler;
+use oxide_kernel::kernel::{KernelConfig, KernelCore};
+use oxide_parser::Allocator;
+use oxide_types::value::JsValue;
+use oxide_vm::vm::Vm;
+
+/// 每用例测量轮数：三轮取中位，抗单轮尖峰。
+const MEASURE_RUNS: usize = 3;
+
+/// 构建 profile 标签：debug 数字仅过滤，不作绝对比较。
+#[cfg(debug_assertions)]
+const PROFILE: &str = "debug";
+#[cfg(not(debug_assertions))]
+const PROFILE: &str = "release";
+
+/// 全部用例共享同一 kernel：builtin world 只建一次，各用例 VM 经 with_kernel_core 直建。
+static SHARED_KERNEL: OnceLock<Arc<KernelCore>> = OnceLock::new();
+
+/// GC churn 用例专用 kernel（512KB 阈值，gc_mark_sweep bench 同款）：默认阈值过高，
+/// 循环规模内不触发 GC，测不到 sweep 面。
+static CHURN_KERNEL: OnceLock<Arc<KernelCore>> = OnceLock::new();
+
+/// 串行化各用例测量段：cargo test 并发跑测试，多线程争核会污染计时。
+static BENCH_LOCK: Mutex<()> = Mutex::new(());
+
+fn shared_kernel() -> Arc<KernelCore> {
+    SHARED_KERNEL.get_or_init(|| KernelCore::new(KernelConfig::minimal())).clone()
+}
+
+fn churn_kernel() -> Arc<KernelCore> {
+    CHURN_KERNEL
+        .get_or_init(|| {
+            let mut config = KernelConfig::minimal();
+            config.session_gc_threshold = 512 * 1024;
+            KernelCore::new(config)
+        })
+        .clone()
+}
+
+/// 编译 JS 源为模块（计时循环外）。
+fn compile_module(source: &str) -> Arc<CompiledModule> {
+    let allocator = Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).expect("parse");
+    Arc::new(Compiler::new().compile(&program).expect("compile"))
+}
+
+/// 解出数值：int 与 double 两种表示都转 f64（期望值都是二的五十三次方内整数，精确）。
+fn value_as_f64(result: JsValue) -> f64 {
+    if result.is_int() {
+        result.as_int() as f64
+    } else if result.is_double() {
+        result.as_double()
+    } else {
+        panic!("结果应为数字，实际 {result:?}")
+    }
+}
+
+/// 断言 run 结果值等于期望值（防死代码消除）。
+fn expect_number(result: JsValue, expected: f64, label: &str) {
+    assert_eq!(value_as_f64(result), expected, "{label} 结果值不符");
+}
+
+/// 中位数：抗单轮尖峰，轮数取奇数。
+fn median(values: &[f64]) -> f64 {
+    let mut sorted = values.to_vec();
+    sorted.sort_by(f64::total_cmp);
+    sorted[sorted.len() / 2]
+}
+
+/// 测量单用例：1 个预热 run 加 3 个测量 run，每 run 新建 VM 共享同一 kernel，
+/// 三轮取中位后输出一行 `micro <case>: <n> ops, <median> ms, <ns/op> ns/op (r1, r2, r3)`。
+fn measure_case(name: &str, kernel: &Arc<KernelCore>, module: &Arc<CompiledModule>, n_ops: usize, expected: f64) {
+    // 串行化：测量段独占执行，避免并发测试线程争核。
+    let _guard = BENCH_LOCK.lock().unwrap();
+
+    // 预热 run：吸收 IC 学习 miss、分配器与代码缓存预热。
+    let mut vm = Vm::with_kernel_core(Arc::clone(kernel));
+    let result = vm.run(module).expect("预热 run");
+    expect_number(result, expected, name);
+
+    // 测量轮：IC 与缓存全部热态，每轮新建 VM。
+    let mut walls_ms: Vec<f64> = Vec::with_capacity(MEASURE_RUNS);
+    for _ in 0..MEASURE_RUNS {
+        let mut vm = Vm::with_kernel_core(Arc::clone(kernel));
+        let t0 = Instant::now();
+        let result = vm.run(module).expect("测量 run");
+        let ms = t0.elapsed().as_secs_f64() * 1e3;
+        expect_number(result, expected, name);
+        walls_ms.push(ms);
+    }
+
+    let median_ms = median(&walls_ms);
+    eprintln!(
+        "micro {name}: {n_ops} ops, {median_ms:.2} ms, {:.2} ns/op ({}) [{PROFILE}]",
+        median_ms * 1e6 / n_ops as f64,
+        walls_ms.iter().map(|m| format!("{m:.2}")).collect::<Vec<_>>().join(", ")
+    );
+}
+
+/// 纯算术循环：分发主循环每指令税基线（GC 安全点、步数采样、解码与分派）。
+#[test]
+fn micro_dispatch_arith() {
+    let source = "var x = 0; for (var i = 0; i < 1000; i++) { x = x + i - i * 2 + (i % 3); } x";
+    let module = compile_module(source);
+    measure_case("dispatch_arith", &shared_kernel(), &module, 1_000, -498_501.0);
+}
+
+/// 单态对象属性读循环：IC 命中路径。
+#[test]
+fn micro_ic_get_mono() {
+    let source = "var a = { x: 1 }; var sum = 0; for (var i = 0; i < 1800; i++) { sum += a.x; } sum";
+    let module = compile_module(source);
+    measure_case("ic_get_mono", &shared_kernel(), &module, 1_800, 1_800.0);
+}
+
+/// 4 形轮换读（4 槽容量内）：IC 多态命中，每 shape 一次学习 miss 后全命中。
+#[test]
+fn micro_ic_get_poly4() {
+    let source = "var a = { x: 1 }, b = { x: 2, y: 3 }, c = { x: 4, z: 5 }, d = { x: 6, y: 7, z: 8 }; \
+                  var sum = 0; for (var i = 0; i < 1500; i++) { var t = [a, b, c, d][i % 4]; sum += t.x; } sum";
+    let module = compile_module(source);
+    measure_case("ic_get_poly4", &shared_kernel(), &module, 1_500, 4_875.0);
+}
+
+/// 5 形轮换读（超 4 槽容量）：FIFO 逐访问滚动，每次访问都 miss，IC 抖动上限。
+#[test]
+fn micro_ic_get_poly5() {
+    let source = "var s = [{ x: 1 }, { x: 2, y: 3 }, { x: 4, z: 5 }, { x: 6, y: 7, z: 8 }, { x: 9, a: 1, b: 2 }]; \
+                  var sum = 0; for (var i = 0; i < 1500; i++) { sum += s[i % 5].x; } sum";
+    let module = compile_module(source);
+    measure_case("ic_get_poly5", &shared_kernel(), &module, 1_500, 6_600.0);
+}
+
+/// 属性写循环：写侧路径（写侧未走 IC 命中的面）。
+#[test]
+fn micro_ic_set() {
+    let source = "var o = { x: 0 }; for (var i = 0; i < 2200; i++) { o.x = i; } o.x";
+    let module = compile_module(source);
+    measure_case("ic_set", &shared_kernel(), &module, 2_200, 2_199.0);
+}
+
+/// 小函数调用循环：字节码调用与内联路径。
+#[test]
+fn micro_call_bytecode() {
+    let source = "function f(n) { return n * 2 + 1; } var r = 0; \
+                  for (var i = 0; i < 750; i++) { r += f(i); } r";
+    let module = compile_module(source);
+    measure_case("call_bytecode", &shared_kernel(), &module, 750, 562_500.0);
+}
+
+/// push 循环：数组增长路径。
+#[test]
+fn micro_array_push() {
+    let source = "var a = []; for (var i = 0; i < 1300; i++) { a.push(i); } a.length";
+    let module = compile_module(source);
+    measure_case("array_push", &shared_kernel(), &module, 1_300, 1_300.0);
+}
+
+/// 字符串拼接循环：s = s + "y"，拼接与字符串 GC 路径。
+#[test]
+fn micro_string_concat() {
+    let source = "var s = \"x\"; for (var i = 0; i < 800; i++) { s = s + \"y\"; } s.length";
+    let module = compile_module(source);
+    measure_case("string_concat", &shared_kernel(), &module, 800, 801.0);
+}
+
+/// 强转循环：+x 每轮两次 to_number 强转。加数取二进可精确表示值，
+/// 期望值不随浮点累积漂移。
+#[test]
+fn micro_coerce_tonumber() {
+    let source = "var x = \"42\"; var y = \"3.5\"; var r = 0; \
+                  for (var i = 0; i < 1500; i++) { r += (+x) + (+y); } r";
+    let module = compile_module(source);
+    measure_case("coerce_tonumber", &shared_kernel(), &module, 1_500, 68_250.0);
+}
+
+/// GC churn 循环：闭包加对象加数组，每轮全部死亡，512KB 低阈值下执行期两档收集
+/// （epoch 晋升加 session 原地 sweep）触发。规模取单 run 约一千五百个对象
+/// （分配包络超阈值），保证至少一次收集。
+#[test]
+fn micro_gc_churn() {
+    let source = "var t = 0; for (var i = 0; i < 500; i++) { \
+                  var f = function() { return i; }; var o = { a: i, b: [i, i + 1] }; \
+                  t += f() + o.a + o.b.length; } t";
+    let module = compile_module(source);
+    measure_case("gc_churn", &churn_kernel(), &module, 500, 250_500.0);
+}