diff --git a/deps.json b/deps.json
index 0f74cb07..1e4e1b5e 100644
--- a/deps.json
+++ b/deps.json
@@ -1,7 +1,7 @@
 {
-  "kvspace": "v0.2.14",
-  "kvspace-c": "v0.2.14",
-  "kvspace-durable": "v0.2.14",
+  "kvspace": "v0.2.15",
+  "kvspace-c": "v0.2.15",
+  "kvspace-durable": "v0.2.15",
   "blockmalloc": "v0.1.4",
   "slotsboxmalloc": "v0.1.5"
 }
diff --git a/extensions/kvlang/syntaxes/kvlang.tmLanguage.json b/extensions/kvlang/syntaxes/kvlang.tmLanguage.json
index e0128181..076fb433 100644
--- a/extensions/kvlang/syntaxes/kvlang.tmLanguage.json
+++ b/extensions/kvlang/syntaxes/kvlang.tmLanguage.json
@@ -46,7 +46,7 @@
     },
     "keyword": {
       "name": "keyword.control.kvlang",
-      "match": "\\b(rwfunc|rwir|lib|if|else|for|while|break|continue|return)\\b"
+      "match": "\\b(rwfunc|rwir|lib|struct|if|else|for|while|break|continue|return)\\b"
     },
     "block_label": {
       "name": "entity.name.label.kvlang",
diff --git a/layout/src/code.rs b/layout/src/code.rs
index 91796038..d3f91da0 100644
--- a/layout/src/code.rs
+++ b/layout/src/code.rs
@@ -1,17 +1,19 @@
 //! layoutcode（对齐 layout/layout.go）：检查 AST 并把结果布局写到 /lib/ 下的结构化 KV。
 //!
 //! 存储约定：
-//!   /lib/<pkg>·<name>/[0,0]         布局后签名（kind=rwfunc）
-//!   /lib/<pkg>·<name>/<param>       命名参数→slot 指针（langtype=char, ref=1）
+//!   /lib/<pkg>·<name>/[0,0]         布局后签名锚点（kind=rwfunc，body=计数头 [nr,nw,dyn]）
+//!   /lib/<pkg>·<name>/<param>       命名参数→slot 指针（langtype=该参类型, ref=1, body=坐标）
 //!   /lib/<pkg>·<name>/[i,j]         编译后指令（kind=rwir），i 从 1 开始
 //!   /lib/<pkg>·<name>/‥labels/<l>   label → irseq
-//!   /lib/<pkg>·<name>.src           源码副本
+//!   /lib/<pkg>·<name>.src           源码副本（仅 write_func 保留写入，dump 不再依赖）
 //!
 //! WriteBody: DFS-number insts (incl. ScopeStmt), emit [i,j], rewrite goto/br labels to irseq.
+//! dump: 反向——严格读 /lib/<pkg> 子树重建 AST（签名读命名参数 Ptr、体读线性槽+‥labels），
+//!       不读 .src、不依赖签名行 [0,x] 静态槽。
 
 use std::collections::HashMap;
 
-use super::ast::{Expr, Func, Instruction, RwirDecl, Stmt, StructDecl};
+use super::ast::{self, Expr, Func, FuncSig, Instruction, Param, RwirDecl, ScopeStmt, Stmt, StructDecl};
 use super::ffi::Kv;
 use super::{builtin, ffi, keytree, kvkind, lower, parser};
 
@@ -173,15 +175,16 @@ pub fn dump(kv: &mut Kv, lib: &str) -> String {
         // prefix 本身就是函数目录：直接重建该函数（pkg/name 从路径反推）。
         let base = prefix.trim_start_matches("/lib/");
         let (fpkg, name) = func_identity("", base);
-        let src = kvkind::value_string(&kv.get_one(&format!("{prefix}.src")));
+        let dir = format!("{prefix}/");
+        let text = reconstruct(kv, &dir, &name);
         let mut slots = Vec::new();
-        collect_slots(kv, &format!("{prefix}/"), &mut slots);
+        collect_slots(kv, &dir, &mut slots);
         funcs.push(DumpFunc {
             pkg: fpkg,
             name,
-            src,
+            text,
             slots,
-            dir: format!("{prefix}/"),
+            dir,
         });
     } else {
         // 虚拟 pkg：func dir 以 prefix 为前缀（`/lib/foo` 匹配 `/lib/foo·*` 与 `/lib/foo/*`）。
@@ -210,11 +213,11 @@ pub fn dump(kv: &mut Kv, lib: &str) -> String {
     out
 }
 
-/// 一个可运行函数：源码（.src）+ 原始槽位注释。
+/// 一个可运行函数：从 /lib 子树重建的源码 + 原始槽位注释。
 struct DumpFunc {
     pkg: String,
     name: String,
-    src: String,
+    text: String,
     slots: Vec<String>,
     dir: String,
 }
@@ -262,13 +265,13 @@ fn collect_funcs(
         let mem_sub = format!("{prefix}{base}·");
         if is_func_dir(kv, &dir_sub) {
             let (fpkg, name) = func_identity(pkg, &base);
-            let src = kvkind::value_string(&kv.get_one(&format!("{prefix}{base}.src")));
+            let text = reconstruct(kv, &dir_sub, &name);
             let mut slots = Vec::new();
             collect_slots(kv, &dir_sub, &mut slots);
             funcs.push(DumpFunc {
                 pkg: fpkg,
                 name,
-                src,
+                text,
                 slots,
                 dir: dir_sub,
             });
@@ -342,7 +345,7 @@ fn emit_node(out: &mut String, node: &DumpNode, indent: &str) {
 }
 
 fn emit_func(out: &mut String, f: &DumpFunc, indent: &str) {
-    for line in f.src.lines() {
+    for line in f.text.lines() {
         out.push_str(indent);
         out.push_str(line);
         out.push('\n');
@@ -360,6 +363,251 @@ fn emit_func(out: &mut String, f: &DumpFunc, indent: &str) {
     out.push('\n');
 }
 
+// ── dump 重建：严格从 /lib 子树反出可运行 kvlang（不读 .src）─────────────
+//
+// 数据来源（对齐 write_func / spec「指令布局格式」）：
+//   签名  ← [0,0] 计数头(nr,nw,dyn) + 命名参数 Ptr 键（langtype=类型、body=[0,±k] 定位读/写与序）
+//   函数体 ← 线性指令槽 [n,0]=opcode、[n,-j]=读参、[n,j]=写参（n 连续、scope 已拍平）
+//   控制流 ← ‥labels/<label>=irseq；goto/br 的整数读参即 irseq，映射回 label 名并按 irseq 切块
+// 重建成 AST(Func) 后复用其 Display/full_text，箭头一律规范化为 `->`（源箭头风格不落盘）。
+
+/// 单个函数目录 → 可运行 kvlang 文本（签名 + 体）。
+fn reconstruct(kv: &mut Kv, dir: &str, name: &str) -> String {
+    let (nr, nw, dynamic) = kvkind::counts(&kv.get_one(&format!("{dir}[0,0]")));
+    let sig = reconstruct_sig(kv, dir, name, nr, nw, dynamic);
+    let labels = read_labels(kv, dir);
+    let insts = read_insts(kv, dir);
+    let body = build_body(&insts, &labels);
+    Func {
+        comments: Vec::new(),
+        sig,
+        body,
+        pkg: String::new(),
+    }
+    .full_text()
+}
+
+/// 从命名参数 Ptr 键重建签名：类型取 Ptr langtype，读/写与序取 body 坐标 [0,±k]。
+fn reconstruct_sig(kv: &mut Kv, dir: &str, name: &str, nr: i32, nw: i32, dynamic: bool) -> FuncSig {
+    let blank = || Param {
+        name: String::new(),
+        ty: String::new(),
+    };
+    let mut params: Vec<Param> = (0..nr).map(|_| blank()).collect();
+    let mut returns: Vec<Param> = (0..nw).map(|_| blank()).collect();
+    for c in kv.list(dir, false, true) {
+        if c.starts_with('[') || c.ends_with('/') || c.starts_with(keytree::RUNTIME_MEMBER_SEP) {
+            continue; // 指令槽 / labels 目录 / 运行时保留字段
+        }
+        let data = kv.get_one(&format!("{dir}{c}"));
+        if !kvkind::is_ptr(&data) {
+            continue;
+        }
+        let ty = kvkind::langtype(&data);
+        let (is_read, k) = match parse_slot_coord(&kvkind::ptr_target(&data)) {
+            Some(v) => v,
+            None => continue,
+        };
+        let slot = Param {
+            name: c.clone(),
+            ty,
+        };
+        let dst = if is_read { &mut params } else { &mut returns };
+        if k >= 1 && (k as usize) <= dst.len() {
+            dst[k as usize - 1] = slot;
+        }
+    }
+    if dynamic {
+        if let Some(p) = params.last_mut() {
+            if !p.ty.is_empty() {
+                p.ty.push_str("...");
+            }
+        }
+    }
+    FuncSig {
+        name: name.to_string(),
+        params,
+        returns,
+    }
+}
+
+/// 解析槽坐标 `[0,-1]`/`[0,1]` → (是否读参, |k|)。
+fn parse_slot_coord(s: &str) -> Option<(bool, i32)> {
+    let inner = s.strip_prefix('[')?.strip_suffix(']')?;
+    let col = inner.split(',').nth(1)?.trim();
+    let n: i32 = col.parse().ok()?;
+    Some((n < 0, n.abs()))
+}
+
+/// ‥labels/ 子树 → (irseq, label)，按 irseq 升序（体切块用）。
+fn read_labels(kv: &mut Kv, dir: &str) -> Vec<(i32, String)> {
+    let ldir = format!("{dir}{}{}/", keytree::RUNTIME_MEMBER_SEP, keytree::SEG_LABELS);
+    let mut out: Vec<(i32, String)> = kv
+        .list(&ldir, false, true)
+        .into_iter()
+        .filter(|c| !c.ends_with('/'))
+        .filter_map(|c| {
+            let irseq: i32 = kvkind::plain(&kv.get_one(&format!("{ldir}{c}"))).parse().ok()?;
+            Some((irseq, c))
+        })
+        .collect();
+    out.sort_by_key(|(irseq, _)| *irseq);
+    out
+}
+
+/// 一条重建指令：opcode + 读操作数 + 写目标名。
+struct RawInst {
+    opcode: String,
+    reads: Vec<Operand>,
+    writes: Vec<String>,
+}
+
+/// 操作数：引用（变量/opcode/路径）、字符串字面量、其它字面量（数值/bool）。
+enum Operand {
+    Ref(String),
+    Str(String),
+    Lit(String),
+}
+
+/// 线性读回 [n,*]（n 从 1 连续到首个空 opcode 前）。
+fn read_insts(kv: &mut Kv, dir: &str) -> Vec<RawInst> {
+    let mut out = Vec::new();
+    let mut n = 1;
+    loop {
+        let op = kv.get_one(&format!("{dir}[{n},0]"));
+        if op.is_empty() {
+            break;
+        }
+        let opcode = kvkind::rwir_sig(&op);
+        let mut reads = Vec::new();
+        let mut j = 1;
+        loop {
+            let d = kv.get_one(&format!("{dir}[{n},-{j}]"));
+            if d.is_empty() {
+                break;
+            }
+            reads.push(decode_operand(&d));
+            j += 1;
+        }
+        let mut writes = Vec::new();
+        let mut j = 1;
+        loop {
+            let d = kv.get_one(&format!("{dir}[{n},{j}]"));
+            if d.is_empty() {
+                break;
+            }
+            writes.push(kvkind::rwir_sig(&d));
+            j += 1;
+        }
+        out.push(RawInst {
+            opcode,
+            reads,
+            writes,
+        });
+        n += 1;
+    }
+    out
+}
+
+/// 槽值 → Operand：rwir 族为引用/opcode 名，char 为字符串字面量，其余为明文字面量。
+fn decode_operand(data: &[u8]) -> Operand {
+    let k = kvkind::kind(data);
+    if matches!(k.as_str(), "rwir" | "rwir|rwfunc" | "rwfunc" | "def rwir") {
+        Operand::Ref(kvkind::rwir_sig(data))
+    } else if kvkind::is_char_kind(&k) {
+        Operand::Str(kvkind::plain(data))
+    } else {
+        Operand::Lit(kvkind::plain(data))
+    }
+}
+
+fn operand_expr(o: &Operand) -> Expr {
+    match o {
+        Operand::Ref(s) | Operand::Lit(s) => ast::leaf(s),
+        Operand::Str(s) => ast::str_lit(s),
+    }
+}
+
+/// goto/br 的整数读参 → label 名（查不到则原样保留数字）。
+fn label_leaf(o: &Operand, by_irseq: &HashMap<i32, String>) -> Expr {
+    if let Operand::Lit(s) = o {
+        if let Ok(n) = s.parse::<i32>() {
+            if let Some(l) = by_irseq.get(&n) {
+                return ast::leaf(l);
+            }
+        }
+    }
+    operand_expr(o)
+}
+
+/// 线性指令 + labels → 语句序列：首 label 前为前导语句，各 label 段成 ScopeStmt。
+fn build_body(insts: &[RawInst], labels: &[(i32, String)]) -> Vec<Stmt> {
+    let by_irseq: HashMap<i32, String> = labels.iter().map(|(i, l)| (*i, l.clone())).collect();
+    let total = insts.len() as i32;
+    let first = labels.first().map(|(i, _)| *i).unwrap_or(total + 1);
+    let inst_stmt = |i: i32| Stmt::Instruction(build_inst(&insts[i as usize - 1], &by_irseq));
+    let mut body: Vec<Stmt> = (1..first).map(inst_stmt).collect();
+    for (bi, (start, label)) in labels.iter().enumerate() {
+        let end = labels.get(bi + 1).map(|(i, _)| *i).unwrap_or(total + 1);
+        body.push(Stmt::Scope(ScopeStmt {
+            comments: Vec::new(),
+            label: label.clone(),
+            body: (*start..end).map(inst_stmt).collect(),
+        }));
+    }
+    body
+}
+
+/// (opcode, reads, writes) → Instruction（箭头规范化为 `->`；复用 Display 还原算子/糖）。
+fn build_inst(inst: &RawInst, by_irseq: &HashMap<i32, String>) -> Instruction {
+    let expr = match inst.opcode.as_str() {
+        "" => None,
+        "return" => Some(ast::leaf("return")),
+        "=" => inst.reads.first().map(operand_expr),
+        "goto" => Some(ast::call(
+            "goto",
+            inst.reads
+                .iter()
+                .map(|o| label_leaf(o, by_irseq))
+                .collect(),
+        )),
+        "br" => {
+            let mut args = Vec::with_capacity(inst.reads.len());
+            for (i, o) in inst.reads.iter().enumerate() {
+                args.push(if i == 0 {
+                    operand_expr(o)
+                } else {
+                    label_leaf(o, by_irseq)
+                });
+            }
+            Some(ast::call("br", args))
+        }
+        op => Some(ast::call(op, inst.reads.iter().map(operand_expr).collect())),
+    };
+    // array·fill 首参即写目标 langtype（Display 隐去不回显），回填 write_types 恢复类型标注。
+    // 且须用前置 `=` 式（arrow_left=true）：parser 仅在前置标注式把写类型喂给 array·fill 首参，
+    // 后置箭头式 `[5...] -> b:TYPE` 会丢弃该类型（parser 不对称），故这里强制前置式以保幂等。
+    let is_fill = inst.opcode == "array·fill" && !inst.writes.is_empty();
+    let write_types = if is_fill {
+        let ty = match inst.reads.first() {
+            Some(Operand::Str(s)) | Some(Operand::Ref(s)) | Some(Operand::Lit(s)) => s.clone(),
+            None => String::new(),
+        };
+        let mut v = vec![String::new(); inst.writes.len()];
+        v[0] = ty;
+        v
+    } else {
+        Vec::new()
+    };
+    Instruction {
+        comments: Vec::new(),
+        expr,
+        writes: inst.writes.clone(),
+        write_types,
+        arrow_left: is_fill,
+    }
+}
+
 /// 写函数到 /lib/：签名（rwfunc）、源码、参数 Ptr、指令体。
 pub fn write_func(kv: &mut Kv, pkg: &str, fn_: &mut Func) {
     let mut type_map = lower::infer_types(fn_);
diff --git a/layout/src/kvkind.rs b/layout/src/kvkind.rs
index 77c72bd1..bad048b7 100644
--- a/layout/src/kvkind.rs
+++ b/layout/src/kvkind.rs
@@ -14,7 +14,6 @@ pub const KIND_CHAR_ASCII: &str = "char/ascii";
 pub const KIND_BOOL: &str = "bool";
 pub const KIND_INT64: &str = "int64";
 pub const KIND_FLOAT64: &str = "float64";
-pub const KIND_OBJ: &str = "object";
 pub const KIND_MAP: &str = "stringkeymap";
 pub const KIND_INDEX: &str = "index";
 pub const KIND_EXT_INDEX: &str = "extindex";
@@ -304,3 +303,41 @@ pub fn rwfunc_num_writes(body: &[u8]) -> i32 {
     }
     u16::from_le_bytes([body[2], body[3]]) as i32
 }
+
+/// 主槽计数头 (nr, nw, dynamic)——直接吃整条 XValue（rwfunc/def rwir）。
+pub fn counts(data: &[u8]) -> (i32, i32, bool) {
+    if data.is_empty() {
+        return (0, 0, false);
+    }
+    let h = ffi::decode_head(data);
+    let b = body(data, &h);
+    if b.len() >= 5 {
+        (
+            u16::from_le_bytes([b[0], b[1]]) as i32,
+            u16::from_le_bytes([b[2], b[3]]) as i32,
+            b[4] != 0,
+        )
+    } else {
+        (0, 0, false)
+    }
+}
+
+/// 字面量的明文源值（不含 kind 前缀、不含引号）；char/utf32 按码点正确解码。
+pub fn plain(data: &[u8]) -> String {
+    if data.is_empty() {
+        return String::new();
+    }
+    let (_, k) = parse_langtype(&langtype(data));
+    let h = ffi::decode_head(data);
+    plain_value(&k, body(data, &h))
+}
+
+/// rwir 族槽值的载荷串（opcode / 引用名）：body 去 5 字节计数头后的字节。
+pub fn rwir_sig(data: &[u8]) -> String {
+    if data.is_empty() {
+        return String::new();
+    }
+    let h = ffi::decode_head(data);
+    let b = body(data, &h);
+    String::from_utf8_lossy(&b[5.min(b.len())..]).into_owned()
+}
diff --git a/layout/src/langtype.rs b/layout/src/langtype.rs
index 9ef19ee3..3f63a449 100644
--- a/layout/src/langtype.rs
+++ b/layout/src/langtype.rs
@@ -38,7 +38,6 @@ fn known_kind(k: &str) -> bool {
             | "char/utf32"
             | "char/utf8"
             | "char/ascii"
-            | "object"
             | "stringkeymap"
             | "index"
             | "extindex"
@@ -121,7 +120,7 @@ fn valid_shape(s: &str) -> bool {
     valid_base(s)
 }
 
-/// 标量 kind（可作元组键元素；不含 char/object/index 等）。
+/// 标量 kind（可作元组键元素；不含 char/stringkeymap/index 等）。
 fn valid_scalar(s: &str) -> bool {
     matches!(
         s,
@@ -175,6 +174,35 @@ pub fn valid_langtype(expr: &str) -> bool {
     !expr.is_empty() && expr.split('|').all(valid_atom)
 }
 
+/// 隐式 struct 名解析：把 langtype 中裸 struct 名（非 known kind / any 的标识符）展开为
+/// `/lib/<name>`，使 kv 源可写 `x:Node` / `[int64]·Node`，runtime 恒收到完整 `/lib/…` 路径。
+/// 已 `/` 开头或 known kind 原样返回。mapexpr 只对 value 递归展开（key 恒 `[…]` 非 struct）。
+pub fn expand_struct_refs(s: &str) -> String {
+    s.split('|')
+        .map(expand_atom)
+        .collect::<Vec<_>>()
+        .join("|")
+}
+
+fn expand_atom(s: &str) -> String {
+    if s.starts_with('/') {
+        return s.to_string();
+    }
+    if s.starts_with('[') {
+        if let Some(i) = s.find('·') {
+            let key = &s[..i];
+            if valid_key(key) {
+                return format!("{key}·{}", expand_struct_refs(&s[i + '·'.len_utf8()..]));
+            }
+        }
+        return s.to_string();
+    }
+    if s.is_empty() || known_kind(s) || s == "any" {
+        return s.to_string();
+    }
+    format!("/lib/{s}")
+}
+
 fn base_match(s: &str, kind: &str) -> bool {
     match s {
         "any" => true,
@@ -280,7 +308,6 @@ mod tests {
             "char/utf8",
             "char/utf32",
             "char/ascii",
-            "object",
             "stringkeymap",
             "index",
             "[]float32",
@@ -299,7 +326,7 @@ mod tests {
             "[2,3]float32|float32",
             "[]float32|[]float64",
             "bool|char/utf8",
-            "index|object",
+            "index|stringkeymap",
             "[]char/utf8·int64",
             "[]char/utf32·[]char/utf8",
             "[]char/utf8·[]char/utf8·int64",
@@ -340,7 +367,6 @@ mod tests {
         assert!(match_langtype("/lib/Point", "/lib/Point", 0, &[]));
         assert!(!match_langtype("/lib/Point", "/lib/Node", 0, &[]));
         assert!(match_langtype("[]char/utf8·int64", "stringkeymap", 1, &[3]));
-        assert!(!match_langtype("[]char/utf8·int64", "object", 0, &[]));
     }
 
     #[test]
@@ -406,7 +432,7 @@ mod tests {
         let cases = [
             ("int64", "int64", 0, &[][..], true),
             ("int64", "float64", 0, &[], false),
-            ("any", "object", 0, &[], true),
+            ("any", "stringkeymap", 0, &[], true),
             ("any", "int4", 0, &[], true),
             ("char/utf8", "char/utf8", 0, &[], true),
             ("char/utf8", "char/utf32", 0, &[], false),
@@ -423,7 +449,7 @@ mod tests {
             ("[2,3]float32|float32", "float64", 0, &[], false),
             ("[]float32|[]float64", "float64", 1, &[10], true),
             ("bool|char/utf8", "char/utf8", 0, &[], true),
-            ("index|object", "index", 0, &[], true),
+            ("index|stringkeymap", "index", 0, &[], true),
         ];
         for (expr, kind, ndim, dims, want) in cases {
             let got = match_langtype(expr, kind, ndim, dims);
diff --git a/layout/src/lower.rs b/layout/src/lower.rs
index 80dc238a..72874ce0 100644
--- a/layout/src/lower.rs
+++ b/layout/src/lower.rs
@@ -6,10 +6,10 @@ use super::ast::{self, Expr, Func, Instruction, LitKind, Stmt};
 use super::scanner::{Diagnostic, Pos};
 use super::{builtin, keytree, symbol};
 
-/// 容器类型（object / stringkeymap / mapexpr）不可用 `[]` 下标访问成员——
+/// 容器类型（stringkeymap / mapexpr）不可用 `[]` 下标访问成员——
 /// `[]` 仅限 compact array（shaped langtype，含字符串 `[]char/*`）。
 fn is_container_type(t: &str) -> bool {
-    t == "object" || t == "stringkeymap" || t.contains(keytree::MEMBER_SEP)
+    t == "stringkeymap" || t.contains(keytree::MEMBER_SEP)
 }
 
 /// `[]` 下标校验：xv·at/xv·set 基座若为容器类型 → 报错，逼用 kv·get/kv·set/`base·key`。
@@ -381,7 +381,7 @@ fn lower_for_with_cont(
     let is_obj = s.iter.op == "obj"
         || s.iter.op == "map"
         || (s.iter.is_leaf()
-            && matches!(tm.get(&s.iter.val), Some(t) if t == "object" || t == "[]stringkeymap" || t == "stringkeymap"));
+            && matches!(tm.get(&s.iter.val), Some(t) if t == "[]stringkeymap" || t == "stringkeymap"));
 
     // 迭代源：裸标识符直接原地遍历；表达式（如数组字面量）先物化到临时槽。
     let mut init_body = Vec::new();
@@ -750,10 +750,10 @@ fn infer_inst(inst: &Instruction, tm: &mut HashMap<String, String>) {
         Some(e) => e,
         None => return,
     };
-    // kv.set 成员形（3 读：base, key, val）是 void 无写槽，但 base 仍须推断为 obj/map（供 for-in / 成员访问）
+    // kv.set 成员形（3 读：base, key, val）是 void 无写槽，但 base 仍须推断为 stringkeymap（供 for-in / 成员访问）
     if e.op == "kv·set" && e.args.len() >= 3 && !e.args[0].val.contains('/') {
         tm.entry(e.args[0].val.clone())
-            .or_insert_with(|| "object".to_string());
+            .or_insert_with(|| "stringkeymap".to_string());
     }
     if inst.writes.is_empty() {
         return;
@@ -834,16 +834,16 @@ fn infer_op_type(opcode: &str, reads: &[String], tm: &mut HashMap<String, String
         return opcode.to_string();
     }
     if opcode == "obj" {
-        return "object".to_string();
+        return "stringkeymap".to_string();
     }
     if opcode == "map" {
         return "[]stringkeymap".to_string();
     }
     if opcode == "kv·set" {
-        // 成员写 base.key = v（3 reads：base, key, value）→ base 是 obj/map。
+        // 成员写 base.key = v（3 reads：base, key, value）→ base 是 stringkeymap。
         if reads.len() >= 3 {
             tm.entry(reads[0].clone())
-                .or_insert_with(|| "object".to_string());
+                .or_insert_with(|| "stringkeymap".to_string());
         }
         return String::new();
     }
diff --git a/layout/src/parser.rs b/layout/src/parser.rs
index c3009b10..c7d4b2f5 100644
--- a/layout/src/parser.rs
+++ b/layout/src/parser.rs
@@ -459,6 +459,11 @@ impl Parser {
     }
 
     fn parse_type(&mut self) -> String {
+        let raw = self.parse_type_raw();
+        super::langtype::expand_struct_refs(&raw)
+    }
+
+    fn parse_type_raw(&mut self) -> String {
         let mut sb = String::new();
         let mut depth = 0i32;
         loop {
@@ -742,10 +747,14 @@ impl Parser {
     }
 
     fn parse_stmt(&mut self) -> Option<Stmt> {
-        // 块标签检测（优先级最高）
+        // 块标签检测（优先级最高）。排除类型注解写槽：`x:Type`（Ident）、`x:[…]`（LBrack）、
+        // `x:/lib/Name`（structref langtype，以 / 起头的路径 Literal）。
+        let t2 = self.peek_at(2);
+        let t2_structref = t2.kind == Kind::Literal && t2.value.starts_with('/');
         if self.peek_at(1).kind == Kind::Colon
-            && self.peek_at(2).kind != Kind::Ident
-            && self.peek_at(2).kind != Kind::LBrack
+            && t2.kind != Kind::Ident
+            && t2.kind != Kind::LBrack
+            && !t2_structref
         {
             return Some(self.parse_block_label());
         }
@@ -890,6 +899,26 @@ impl Parser {
     /// （赋值右值 / for-in 源）；无论如何，其元素内部都不得再嵌套散 key 字面量。
     // 空容器字面量 `{}` 不含任何类型信息，必须由写目标显式标注 langtype：
     // 禁 `d = {}`，须 `d:[]char/utf8·int64 = {}`（非空 `{a=…}` 可由成员推断，放行）。
+    /// `{}` 对应两种 langtype：写类型是 structref（`/lib/Name`）→ `struct·new(path, k, v, …)`；
+    /// 否则（stringkeymap / mapexpr）保留 `obj`（runtime 构 stringkeymap）。裸无类型 `{}` 由
+    /// check_empty_container_typed 报错。desugar 已把成员/下标写目标改成 kv·set，故此处只命中简单局部。
+    fn dispatch_obj_by_type(&mut self, inst: &mut Instruction) {
+        if inst.expr.as_ref().map(|e| e.op.as_str()) != Some("obj") {
+            return;
+        }
+        let ty = inst.write_types.first().map(String::as_str).unwrap_or("");
+        if !ty.starts_with('/') {
+            return;
+        }
+        let e = inst.expr.take().unwrap();
+        let mut args = vec![ast::str_lit(ty)];
+        args.extend(e.args);
+        inst.expr = Some(ast::call(
+            &format!("struct{}new", keytree::MEMBER_SEP),
+            args,
+        ));
+    }
+
     fn check_empty_container_typed(&mut self, inst: &Instruction) {
         let Some(e) = &inst.expr else { return };
         if e.op != "obj" || !e.args.is_empty() {
@@ -998,6 +1027,7 @@ impl Parser {
                 inst.write_types = wtypes;
                 self.advance(); // consume =
                 inst.expr = self.parse_pratt(0);
+                self.dispatch_obj_by_type(&mut inst);
                 self.lower_array_fill(&mut inst);
                 self.desugar_subscript_write(&mut inst);
                 self.desugar_member_write(&mut inst);
@@ -1008,6 +1038,7 @@ impl Parser {
                 let (writes, wtypes) = self.collect_write_list();
                 inst.writes = writes;
                 inst.write_types = wtypes;
+                self.dispatch_obj_by_type(&mut inst);
                 self.desugar_subscript_write(&mut inst);
                 self.desugar_member_write(&mut inst);
             }
@@ -1785,8 +1816,14 @@ impl Parser {
                         break;
                     }
                 }
+                // 成员写槽可带 langtype 注解 `a·1:Node = {…}`：struct 对象定义的推荐形态。
+                let mut ty = String::new();
+                if self.peek().kind == Kind::Colon {
+                    self.advance();
+                    ty = self.parse_type();
+                }
                 writes.push(w);
-                wtypes.push(String::new());
+                wtypes.push(ty);
                 continue;
             }
             if t.kind == Kind::Ident && self.peek_at(1).kind == Kind::LBrack {
diff --git a/runtime-rs/src/rwir/json.rs b/runtime-rs/src/rwir/json.rs
index d12586a1..1699a6c7 100644
--- a/runtime-rs/src/rwir/json.rs
+++ b/runtime-rs/src/rwir/json.rs
@@ -1,10 +1,10 @@
 //! rwir `json·to` / `json·from`：KV 子树 ↔ JSON 文本（对齐 kvlang go/json 的 · 成员形态）。
-//!   json·to(root)   -> str   root 整棵子树读成 JSON：object 容器（p + memindex p·）→
-//!                            嵌套对象；stringkeymap（散 key 数组 name·[i]）→ JSON 数组；
+//!   json·to(root)   -> str   root 整棵子树读成 JSON：stringkeymap 容器（p + memindex p·）
+//!                            按成员名形态分派——`[i]` 坐标段 → JSON 数组，命名键 → JSON 对象；
 //!                            / 目录树（kind=index）→ 嵌套对象；compact ndarray → 数组。
 //!   json·from(json) -> root  反序列化 JSON 写回 root 子树（覆盖语义，先 del_tree）。
-//! 容器值在 p（无后缀）：object body 空、stringkeymap dims=[n]；memindex p·（kind=index，
-//! body=[4B count LE][names]）是成员列表唯一权威。对象数组（choices/messages）递归支持。
+//! 容器值在 p（无后缀）：stringkeymap，命名字典 dims=[0]、坐标数组 dims=[n]；memindex p·
+//! （kind=index，body=[4B count LE][names]）是成员列表唯一权威。对象数组递归支持。
 //! 编码走权威 kvspace ABI：DecodeHead 读头、TlvEncode/NewCharByte 编码。
 
 use serde_json::{Map, Value};
@@ -15,7 +15,6 @@ use crate::ffi::*;
 // 常量与 kvlang go/json 的 cconst 对齐（直连 kvspace，无 kvspaceConst ABI）。
 const SEP: &str = "·";
 const DIR_SUF: &str = "/";
-const KIND_OBJ: &str = "object";
 const KIND_MAP: &str = "stringkeymap";
 const KIND_INDEX: &str = "index";
 
@@ -53,11 +52,8 @@ fn params(eng: &Engine, pc: &str) -> Vec<String> {
 
 fn read_value(eng: &Engine, path: &str) -> Value {
     let (kind, raw, arr_len) = parse_tlv(&eng.get_tlv(path));
-    if kind == KIND_OBJ {
-        return read_obj(eng, path);
-    }
     if kind == KIND_MAP {
-        return read_arr(eng, path);
+        return read_container(eng, path);
     }
     let dkind = parse_tlv(&eng.get_tlv(&format!("{path}{DIR_SUF}"))).0;
     if dkind == KIND_INDEX {
@@ -82,7 +78,25 @@ fn read_dir(eng: &Engine, path: &str) -> Value {
     Value::Object(map)
 }
 
-// read_obj：object 容器值 p → 遍历 memindex p· 成员。
+// read_container：stringkeymap 容器 p → 按 memindex 成员名形态分派。
+// 成员全为 `[i]` 坐标段 → JSON 数组；否则（命名键）→ JSON 对象。
+fn read_container(eng: &Engine, path: &str) -> Value {
+    let names = eng.list_kv(&format!("{path}{SEP}"));
+    let all_idx = !names.is_empty()
+        && names.iter().all(|n| {
+            n.strip_prefix('[')
+                .and_then(|r| r.strip_suffix(']'))
+                .map(|i| i.parse::<usize>().is_ok())
+                .unwrap_or(false)
+        });
+    if all_idx {
+        read_arr(eng, path)
+    } else {
+        read_obj(eng, path)
+    }
+}
+
+// read_obj：命名字典 stringkeymap p → 遍历 memindex p· 成员。
 fn read_obj(eng: &Engine, path: &str) -> Value {
     let mut map = Map::new();
     for name in eng.list_kv(&format!("{path}{SEP}")) {
@@ -259,9 +273,9 @@ fn mk_mem_index(names: &[String]) -> Vec<u8> {
     tlv_encode(KIND_INDEX, &body, &[])
 }
 
-// object 容器值 p：body 空。
+// 命名字典容器值 p：kind=stringkeymap，dims=[0]（无形状，成员在 memindex）。
 fn mk_obj_value() -> Vec<u8> {
-    tlv_encode(KIND_OBJ, &[], &[])
+    tlv_encode(KIND_MAP, &[], &[0])
 }
 
 // stringkeymap 容器值 p：body 空，dims=[n]（恒一维坐标段）。
diff --git a/runtime/src/builtin_collection.c b/runtime/src/builtin_collection.c
index 12074a51..4c2a1876 100644
--- a/runtime/src/builtin_collection.c
+++ b/runtime/src/builtin_collection.c
@@ -486,8 +486,9 @@ int kvlangBuiltinObj(kvlangFrame_t *f) {
             if (kvlangXvalueNone(&in[i + 1])) continue;
             names[j++] = kvlangXvalueValueString(&in[i]);
         }
-        /* 容器值 p：kind=object，body 空。 */
-        kvlangXvalue_t mark; kvlangXvalueNewTlv(&mark, KVSPACE_KIND_OBJ, (const uint8_t *)"", 0, 1);
+        /* 容器值 p：kind=stringkeymap，dims=[0]（命名字典无形状，成员在 memindex）。 */
+        int32_t odims[1] = { 0 };
+        kvlangXvalue_t mark; kvlangBuiltinMapMarker(&mark, odims, 1);
         kvlangKvPair_t p0 = { ok, mark };
         kvlangKvSet(f->kv, &p0, 1, err, sizeof err);
         kvlangXvalueFree(&mark);
diff --git a/runtime/src/builtin_kv.c b/runtime/src/builtin_kv.c
index eb056df7..cb20750f 100644
--- a/runtime/src/builtin_kv.c
+++ b/runtime/src/builtin_kv.c
@@ -21,12 +21,12 @@ static char *path_arg(kvlangFrame_t *f, int idx, const kvlangXvalue_t *in) {
     return NULL;
 }
 
-/* 容器 base：object/map/index/extindex 或 struct 实例（kind=structref，以 / 起头）。
+/* 容器 base：stringkeymap/index/extindex 或 struct 实例（kind=structref，以 / 起头）。
  * 容器取其写槽路径拼成员 key；非容器把 base 值当 key 串。 */
 static bool base_is_container(const kvlangXvalue_t *base) {
     if (kvlangXvalueNone(base)) return true;
     const char *k = kvlangXvalueKind(base);
-    return k[0] == '/' || strcmp(k, KVSPACE_KIND_OBJ) == 0 || strcmp(k, KVSPACE_KIND_MAP) == 0 ||
+    return k[0] == '/' || strcmp(k, KVSPACE_KIND_MAP) == 0 ||
            strcmp(k, KVSPACE_KIND_INDEX) == 0 || strcmp(k, KVSPACE_KIND_EXT_INDEX) == 0;
 }
 
diff --git a/runtime/src/const.h b/runtime/src/const.h
index c19bb4df..078e148f 100644
--- a/runtime/src/const.h
+++ b/runtime/src/const.h
@@ -24,7 +24,6 @@
 #define KVSPACE_KIND_CHAR       "char/utf32"
 #define KVSPACE_KIND_CHAR_UTF8  "char/utf8"
 #define KVSPACE_KIND_CHAR_ASCII "char/ascii"
-#define KVSPACE_KIND_OBJ        "object"
 #define KVSPACE_KIND_MAP        "stringkeymap"
 #define KVSPACE_KIND_INDEX      "index"
 #define KVSPACE_KIND_EXT_INDEX  "extindex"
diff --git a/runtime/src/langtype.c b/runtime/src/langtype.c
index c286fb3d..1aefc3d4 100644
--- a/runtime/src/langtype.c
+++ b/runtime/src/langtype.c
@@ -34,7 +34,7 @@ static bool known_kind(const char *s, size_t len) {
            kind_eq(s, len, KVSPACE_KIND_FLOAT8_E4M3) || kind_eq(s, len, KVSPACE_KIND_FLOAT8_E5M2) ||
            kind_eq(s, len, KVSPACE_KIND_CHAR) || kind_eq(s, len, KVSPACE_KIND_CHAR_UTF8) ||
            kind_eq(s, len, KVSPACE_KIND_CHAR_ASCII) ||
-           kind_eq(s, len, KVSPACE_KIND_OBJ) || kind_eq(s, len, KVSPACE_KIND_MAP) ||
+           kind_eq(s, len, KVSPACE_KIND_MAP) ||
            kind_eq(s, len, KVSPACE_KIND_INDEX) || kind_eq(s, len, KVSPACE_KIND_EXT_INDEX) ||
            kind_eq(s, len, KVSPACE_KIND_RWIR) || kind_eq(s, len, KVSPACE_KIND_RWFUNC) ||
            kind_eq(s, len, KVSPACE_KIND_SCOPE) || kind_eq(s, len, KVSPACE_KIND_STRUCT) ||
diff --git a/runtime/src/langtypetable.c b/runtime/src/langtypetable.c
index 47f86880..a55de1b0 100644
--- a/runtime/src/langtypetable.c
+++ b/runtime/src/langtypetable.c
@@ -26,7 +26,6 @@ static const lt_ent_t LANGTYPETABLE[] = {
     LT(KVSPACE_KIND_CHAR, KVLANG_LT_CHAR_UTF32),
     LT(KVSPACE_KIND_CHAR_UTF8, KVLANG_LT_CHAR_UTF8),
     LT(KVSPACE_KIND_CHAR_ASCII, KVLANG_LT_CHAR_ASCII),
-    LT(KVSPACE_KIND_OBJ, KVLANG_LT_OBJECT),
     LT(KVSPACE_KIND_MAP, KVLANG_LT_MAP),
     LT(KVSPACE_KIND_INDEX, KVLANG_LT_INDEX),
     LT(KVSPACE_KIND_EXT_INDEX, KVLANG_LT_EXTINDEX),
diff --git a/runtime/src/runtime_internal.h b/runtime/src/runtime_internal.h
index b9724cfe..3c79e7a8 100644
--- a/runtime/src/runtime_internal.h
+++ b/runtime/src/runtime_internal.h
@@ -144,7 +144,7 @@ enum {
     KVLANG_LT_UINT8, KVLANG_LT_UINT16, KVLANG_LT_UINT32, KVLANG_LT_UINT64,
     KVLANG_LT_FLOAT32, KVLANG_LT_FLOAT64,
     KVLANG_LT_CHAR_UTF32, KVLANG_LT_CHAR_UTF8, KVLANG_LT_CHAR_ASCII,
-    KVLANG_LT_OBJECT, KVLANG_LT_MAP, KVLANG_LT_INDEX, KVLANG_LT_EXTINDEX,
+    KVLANG_LT_MAP, KVLANG_LT_INDEX, KVLANG_LT_EXTINDEX,
     KVLANG_LT_RWIR, KVLANG_LT_RWFUNC, KVLANG_LT_SCOPE, KVLANG_LT_STRUCT,
     KVLANG_LT_TIME, KVLANG_LT_DURATION,
     KVLANG_LT_COUNT
diff --git a/runtime/src/xvalue.c b/runtime/src/xvalue.c
index b5614ce7..3e707677 100644
--- a/runtime/src/xvalue.c
+++ b/runtime/src/xvalue.c
@@ -456,8 +456,6 @@ char *kvlangXvalueValueString(const kvlangXvalue_t *v) {
         kvlangStrbufPrintf(&b, "(%d)", n);
         return kvlangStrbufDetach(&b);
     }
-    if (strcmp(k, KVSPACE_KIND_OBJ) == 0)
-        return strdup(KVSPACE_KIND_OBJ);
     if (strcmp(k, KVSPACE_KIND_MAP) == 0) {
         kvlangStrbuf_t b;
         kvlangStrbufInit(&b);
diff --git a/tutorial/01-basics/chinese_ident.kv b/tutorial/01-basics/chinese_ident.kv
index 381fa859..6c1fb134 100644
--- a/tutorial/01-basics/chinese_ident.kv
+++ b/tutorial/01-basics/chinese_ident.kv
@@ -31,7 +31,7 @@ rwfunc test() -> () {
 	/lib/数学/几何·相加(10, 20) -> 结果2
 	println("相加 =", 结果2)
 	/lib/外层/内层·问候()
-	原点 = 点{横=3.0 纵=4.0}
+	原点:点 = {横=3.0 纵=4.0}
 	原点·横 -> x
 	原点·纵 -> y
 	println("点 =", x, y)
diff --git a/tutorial/05-dict/literal.kv b/tutorial/05-dict/literal.kv
index 3d1f2116..a2e69e92 100644
--- a/tutorial/05-dict/literal.kv
+++ b/tutorial/05-dict/literal.kv
@@ -1,11 +1,14 @@
-// literal: 字典字面量与成员访问
-// 语义: { k=v; ... } 创建 dict 目录；base·key 成员访问；has 检查存在性
+// literal: 字典（stringkeymap）成员赋值与访问
+// 语义: h:[]char/utf32·int64 = {} 建空字典；h·key = v 成员赋值；base·key 访问；
+//       kv·get 检查存在性（缺失键返回 None）
 // 期望输出:
 //   h·x = 1
 //   h·z = 42
 //   has x: true
 rwfunc test() -> () {
-	h = {x=1; y=2}
+	h:[]char/utf32·int64 = {}
+	h·x = 1
+	h·y = 2
 	h·x -> v
 	println("h·x =", v)
 	42 -> h·z
diff --git a/tutorial/08-leetcode/002_add_two_numbers.kv b/tutorial/08-leetcode/002_add_two_numbers.kv
index d446d9ee..f8c775c8 100644
--- a/tutorial/08-leetcode/002_add_two_numbers.kv
+++ b/tutorial/08-leetcode/002_add_two_numbers.kv
@@ -4,13 +4,9 @@
 //   7
 //   0
 //   8
-rwfunc build_lists() -> () {
-	/l1_0 = { val=2; next="/l1_1" }
-	/l1_1 = { val=4; next="/l1_2" }
-	{ val=3; next="" } -> /l1_2
-	/l2_0 = { val=5; next="/l2_1" }
-	{ val=6; next="/l2_2" } -> /l2_1
-	/l2_2 = { val=4; next="" }
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 lib lc {
@@ -51,6 +47,23 @@ rwfunc add(a:[]char/utf32, b:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	build_lists()
-	lc·add("/l1_0", "/l2_0")
+	l1:[int64]·Node = {}
+	kv·abs(l1) -> b1
+	b1 + "·2" -> a2
+	b1 + "·3" -> a3
+	l1·1:Node = {val=2 next=a2}
+	l1·2:Node = {val=4 next=a3}
+	l1·3:Node = {val=3 next=""}
+	b1 + "·1" -> h1
+
+	l2:[int64]·Node = {}
+	kv·abs(l2) -> b2
+	b2 + "·2" -> c2
+	b2 + "·3" -> c3
+	l2·1:Node = {val=5 next=c2}
+	l2·2:Node = {val=6 next=c3}
+	l2·3:Node = {val=4 next=""}
+	b2 + "·1" -> h2
+
+	lc·add(h1, h2)
 }
diff --git a/tutorial/08-leetcode/021_merge_two_lists.kv b/tutorial/08-leetcode/021_merge_two_lists.kv
index 7391639a..a77c1971 100644
--- a/tutorial/08-leetcode/021_merge_two_lists.kv
+++ b/tutorial/08-leetcode/021_merge_two_lists.kv
@@ -7,13 +7,9 @@
 //   3
 //   4
 //   4
-rwfunc build_lists() -> () {
-	/a0 = { val=1; next="/a1" }
-	/a1 = { val=2; next="/a2" }
-	{ val=4; next="" } -> /a2
-	/b0 = { val=1; next="/b1" }
-	/b1 = { val=3; next="/b2" }
-	{ val=4; next="" } -> /b2
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 rwfunc merge(a:[]char/utf32, b:[]char/utf32) -> () {
@@ -48,6 +44,23 @@ rwfunc merge(a:[]char/utf32, b:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	build_lists()
-	merge("/a0", "/b0")
+	a:[int64]·Node = {}
+	kv·abs(a) -> ab
+	ab + "·2" -> a2
+	ab + "·3" -> a3
+	a·1:Node = {val=1 next=a2}
+	a·2:Node = {val=2 next=a3}
+	a·3:Node = {val=4 next=""}
+	ab + "·1" -> ha
+
+	b:[int64]·Node = {}
+	kv·abs(b) -> bb
+	bb + "·2" -> b2
+	bb + "·3" -> b3
+	b·1:Node = {val=1 next=b2}
+	b·2:Node = {val=3 next=b3}
+	b·3:Node = {val=4 next=""}
+	bb + "·1" -> hb
+
+	merge(ha, hb)
 }
diff --git a/tutorial/08-leetcode/056_merge_intervals.kv b/tutorial/08-leetcode/056_merge_intervals.kv
index 64b95e76..d2c76cc4 100644
--- a/tutorial/08-leetcode/056_merge_intervals.kv
+++ b/tutorial/08-leetcode/056_merge_intervals.kv
@@ -27,7 +27,6 @@ rwfunc bubble_sort(n:int64) -> () {
 
 rwfunc merge(n:int64) -> (m:int64) {
 	bubble_sort(n)
-	result:object = {}
 	ki = 0
 	/tmp/mi[0] -> cur
 	idx = 1
diff --git a/tutorial/08-leetcode/083_remove_dup_list.kv b/tutorial/08-leetcode/083_remove_dup_list.kv
index 5650e5cc..27aea8b1 100644
--- a/tutorial/08-leetcode/083_remove_dup_list.kv
+++ b/tutorial/08-leetcode/083_remove_dup_list.kv
@@ -1,4 +1,4 @@
-// 083: Remove Duplicates from Sorted List — 链表去重（dict 字面量建表 + next 改写）
+// 083: Remove Duplicates from Sorted List — 链表去重（局部 map 建表 + next 改写）
 // 来源: LeetCode #83
 // 期望输出:
 //   1
@@ -6,15 +6,9 @@
 //   1
 //   2
 //   3
-rwfunc build() -> () {
-	/e0 = { val=1; next="/e1" }
-	/e1 = { val=1; next="/e2" }
-	{ val=2; next="" } -> /e2
-	/f0 = { val=1; next="/f1" }
-	/f1 = { val=1; next="/f2" }
-	{ val=2; next="/f3" } -> /f2
-	/f3 = { val=3; next="/f4" }
-	/f4 = { val=3; next="" }
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 rwfunc dedup(head:[]char/utf32) -> () {
@@ -49,9 +43,29 @@ rwfunc show(head:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	build()
-	dedup("/e0")
-	show("/e0")
-	dedup("/f0")
-	show("/f0")
+	e:[int64]·Node = {}
+	kv·abs(e) -> eb
+	eb + "·2" -> e2
+	eb + "·3" -> e3
+	e·1:Node = {val=1 next=e2}
+	e·2:Node = {val=1 next=e3}
+	e·3:Node = {val=2 next=""}
+	eb + "·1" -> e1
+	dedup(e1)
+	show(e1)
+
+	f:[int64]·Node = {}
+	kv·abs(f) -> fb
+	fb + "·2" -> f2
+	fb + "·3" -> f3
+	fb + "·4" -> f4
+	fb + "·5" -> f5
+	f·1:Node = {val=1 next=f2}
+	f·2:Node = {val=1 next=f3}
+	f·3:Node = {val=2 next=f4}
+	f·4:Node = {val=3 next=f5}
+	f·5:Node = {val=3 next=""}
+	fb + "·1" -> f1
+	dedup(f1)
+	show(f1)
 }
diff --git a/tutorial/08-leetcode/094_inorder_traversal.kv b/tutorial/08-leetcode/094_inorder_traversal.kv
index e6a83000..3e691ca7 100644
--- a/tutorial/08-leetcode/094_inorder_traversal.kv
+++ b/tutorial/08-leetcode/094_inorder_traversal.kv
@@ -4,10 +4,10 @@
 //   2
 //   1
 //   3
-rwfunc build_tree() -> () {
-	/t0 = { val=1; left="/t1"; right="/t2" }
-	/t1 = { val=2; left=""; right="" }
-	{ val=3; left=""; right="" } -> /t2
+struct TNode {
+	val:int64=0
+	left:[]char/utf32=""
+	right:[]char/utf32=""
 }
 
 rwfunc inorder(root:[]char/utf32) -> () {
@@ -30,6 +30,13 @@ rwfunc inorder(root:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	build_tree()
-	inorder("/t0")
+	t:[int64]·TNode = {}
+	kv·abs(t) -> tb
+	tb + "·2" -> t1
+	tb + "·3" -> t2
+	t·1:TNode = {val=1 left=t1 right=t2}
+	t·2:TNode = {val=2}
+	t·3:TNode = {val=3}
+	tb + "·1" -> root
+	inorder(root)
 }
diff --git a/tutorial/08-leetcode/100_same_tree.kv b/tutorial/08-leetcode/100_same_tree.kv
index bfe37de2..87f19cf9 100644
--- a/tutorial/08-leetcode/100_same_tree.kv
+++ b/tutorial/08-leetcode/100_same_tree.kv
@@ -3,13 +3,10 @@
 // 期望输出:
 //   true
 //   false
-rwfunc build() -> () {
-	/t0 = { val=1; left="/t1"; right="/t2" }
-	{ val=2; left=""; right="" } -> /t1
-	/t2 = { val=3; left=""; right="" }
-	/v0 = { val=1; left="/v1"; right="/v2" }
-	/v1 = { val=2; left=""; right="" }
-	{ val=4; left=""; right="" } -> /v2
+struct TNode {
+	val:int64=0
+	left:[]char/utf32=""
+	right:[]char/utf32=""
 }
 
 rwfunc same(a:[]char/utf32, b:[]char/utf32) -> (ok:int64) {
@@ -26,9 +23,26 @@ rwfunc same(a:[]char/utf32, b:[]char/utf32) -> (ok:int64) {
 }
 
 rwfunc test() -> () {
-	build()
-	same("/t0", "/t0") -> r1
+	t:[int64]·TNode = {}
+	kv·abs(t) -> tb
+	tb + "·2" -> t1
+	tb + "·3" -> t2
+	t·1:TNode = {val=1 left=t1 right=t2}
+	t·2:TNode = {val=2}
+	t·3:TNode = {val=3}
+	tb + "·1" -> rt
+
+	v:[int64]·TNode = {}
+	kv·abs(v) -> vb
+	vb + "·2" -> v1
+	vb + "·3" -> v2
+	v·1:TNode = {val=1 left=v1 right=v2}
+	v·2:TNode = {val=2}
+	v·3:TNode = {val=4}
+	vb + "·1" -> rv
+
+	same(rt, rt) -> r1
 	if (r1 == 1) { println("true") } else { println("false") }
-	same("/t0", "/v0") -> r2
+	same(rt, rv) -> r2
 	if (r2 == 1) { println("true") } else { println("false") }
 }
diff --git a/tutorial/08-leetcode/104_max_tree_depth.kv b/tutorial/08-leetcode/104_max_tree_depth.kv
index 66d51507..a459b638 100644
--- a/tutorial/08-leetcode/104_max_tree_depth.kv
+++ b/tutorial/08-leetcode/104_max_tree_depth.kv
@@ -2,12 +2,10 @@
 // 来源: LeetCode #104
 // 期望输出:
 //   3
-rwfunc build_tree() -> () {
-	/t0 = { val=3; left="/t1"; right="/t2" }
-	{ val=9; left=""; right="" } -> /t1
-	/t2 = { val=20; left="/t3"; right="/t4" }
-	/t3 = { val=15; left=""; right="" }
-	{ val=7; left=""; right="" } -> /t4
+struct TNode {
+	val:int64=0
+	left:[]char/utf32=""
+	right:[]char/utf32=""
 }
 
 rwfunc max_depth(root:[]char/utf32) -> (depth:int64) {
@@ -21,7 +19,18 @@ rwfunc max_depth(root:[]char/utf32) -> (depth:int64) {
 }
 
 rwfunc test() -> () {
-	build_tree()
-	d = max_depth("/t0")
+	t:[int64]·TNode = {}
+	kv·abs(t) -> tb
+	tb + "·2" -> t1
+	tb + "·3" -> t2
+	tb + "·4" -> t3
+	tb + "·5" -> t4
+	t·1:TNode = {val=3 left=t1 right=t2}
+	t·2:TNode = {val=9}
+	t·3:TNode = {val=20 left=t3 right=t4}
+	t·4:TNode = {val=15}
+	t·5:TNode = {val=7}
+	tb + "·1" -> root
+	d = max_depth(root)
 	println(d)
 }
diff --git a/tutorial/08-leetcode/141_linked_list_cycle.kv b/tutorial/08-leetcode/141_linked_list_cycle.kv
index 28884a53..39231fc1 100644
--- a/tutorial/08-leetcode/141_linked_list_cycle.kv
+++ b/tutorial/08-leetcode/141_linked_list_cycle.kv
@@ -26,23 +26,29 @@ rwfunc has_cycle(head:[]char/utf32) -> (result:int64) {
 	}
 }
 
-rwfunc build_cycle() -> () {
-	{ val=3; next="/c1" } -> /c0
-	/c1 = { val=2; next="/c2" }
-	/c2 = { val=0; next="/c0" }
-}
-
-rwfunc build_no_cycle() -> () {
-	/n0 = { val=1; next="/n1" }
-	{ val=2; next="" } -> /n1
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 rwfunc test() -> () {
-
-	build_cycle()
-	r1 = has_cycle("/c0")
+	c:[int64]·Node = {}
+	kv·abs(c) -> cb
+	cb + "·1" -> c1
+	cb + "·2" -> c2
+	cb + "·3" -> c3
+	c·1:Node = {val=3 next=c2}
+	c·2:Node = {val=2 next=c3}
+	c·3:Node = {val=0 next=c1}
+	r1 = has_cycle(c1)
 	println(r1)
-	build_no_cycle()
-	has_cycle("/n0") -> r2
+
+	n:[int64]·Node = {}
+	kv·abs(n) -> nb
+	nb + "·1" -> n1
+	nb + "·2" -> n2
+	n·1:Node = {val=1 next=n2}
+	n·2:Node = {val=2 next=""}
+	has_cycle(n1) -> r2
 	println(r2)
 }
diff --git a/tutorial/08-leetcode/160_intersection_list.kv b/tutorial/08-leetcode/160_intersection_list.kv
index 611fff41..8d8e7773 100644
--- a/tutorial/08-leetcode/160_intersection_list.kv
+++ b/tutorial/08-leetcode/160_intersection_list.kv
@@ -3,18 +3,9 @@
 // 双指针法: pA 走完走 B, pB 走完走 A, 相遇即交点
 // 期望输出:
 //   8
-rwfunc build_lists() -> () {
-	// common tail: 8→4→5
-	/t8 = { val=8; next="/t4" }
-	/t4 = { val=4; next="/t5" }
-	{ val=5; next="" } -> /t5
-	// list A: 4→1→/t8
-	/a0 = { val=4; next="/a1" }
-	{ val=1; next="/t8" } -> /a1
-	// list B: 5→6→1→/t8
-	/b0 = { val=5; next="/b1" }
-	/b1 = { val=6; next="/b2" }
-	{ val=1; next="/t8" } -> /b2
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 rwfunc get_intersection(ha:[]char/utf32, hb:[]char/utf32) -> () {
@@ -53,6 +44,33 @@ rwfunc get_intersection(ha:[]char/utf32, hb:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	build_lists()
-	get_intersection("/a0", "/b0")
+	// common tail: 8→4→5
+	t:[int64]·Node = {}
+	kv·abs(t) -> tb
+	tb + "·1" -> t8
+	tb + "·2" -> t4
+	tb + "·3" -> t5
+	t·1:Node = {val=8 next=t4}
+	t·2:Node = {val=4 next=t5}
+	t·3:Node = {val=5 next=""}
+
+	// list A: 4→1→t8
+	a:[int64]·Node = {}
+	kv·abs(a) -> ab
+	ab + "·2" -> a2
+	a·1:Node = {val=4 next=a2}
+	a·2:Node = {val=1 next=t8}
+	ab + "·1" -> ha
+
+	// list B: 5→6→1→t8
+	b:[int64]·Node = {}
+	kv·abs(b) -> bb
+	bb + "·2" -> b2
+	bb + "·3" -> b3
+	b·1:Node = {val=5 next=b2}
+	b·2:Node = {val=6 next=b3}
+	b·3:Node = {val=1 next=t8}
+	bb + "·1" -> hb
+
+	get_intersection(ha, hb)
 }
diff --git a/tutorial/08-leetcode/203_remove_linked_elements.kv b/tutorial/08-leetcode/203_remove_linked_elements.kv
index 578bdde6..5f8244c9 100644
--- a/tutorial/08-leetcode/203_remove_linked_elements.kv
+++ b/tutorial/08-leetcode/203_remove_linked_elements.kv
@@ -6,18 +6,13 @@
 //   3
 //   4
 //   5
-rwfunc build_list() -> () {
-	/n0 = { val=1; next="/n1" }
-	/n1 = { val=2; next="/n2" }
-	{ val=6; next="/n3" } -> /n2
-	/n3 = { val=3; next="/n4" }
-	/n4 = { val=4; next="/n5" }
-	{ val=5; next="/n6" } -> /n5
-	/n6 = { val=6; next="" }
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 rwfunc remove(head:[]char/utf32, val:int64) -> () {
-	p = "/n0"
+	head -> p
 	while (p != "") {
 		v = p·val
 		v == val -> skip
@@ -32,6 +27,21 @@ rwfunc remove(head:[]char/utf32, val:int64) -> () {
 }
 
 rwfunc test() -> () {
-	build_list()
-	remove("/n0", 6)
+	n:[int64]·Node = {}
+	kv·abs(n) -> nb
+	nb + "·2" -> n2
+	nb + "·3" -> n3
+	nb + "·4" -> n4
+	nb + "·5" -> n5
+	nb + "·6" -> n6
+	nb + "·7" -> n7
+	n·1:Node = {val=1 next=n2}
+	n·2:Node = {val=2 next=n3}
+	n·3:Node = {val=6 next=n4}
+	n·4:Node = {val=3 next=n5}
+	n·5:Node = {val=4 next=n6}
+	n·6:Node = {val=5 next=n7}
+	n·7:Node = {val=6 next=""}
+	nb + "·1" -> h
+	remove(h, 6)
 }
diff --git a/tutorial/08-leetcode/206_reverse_linked_list.kv b/tutorial/08-leetcode/206_reverse_linked_list.kv
index b5649620..4ddb6658 100644
--- a/tutorial/08-leetcode/206_reverse_linked_list.kv
+++ b/tutorial/08-leetcode/206_reverse_linked_list.kv
@@ -6,12 +6,9 @@
 //   3
 //   2
 //   1
-rwfunc build_list() -> () {
-	/n0 = { val=1; next="/n1" }
-	{ val=2; next="/n2" } -> /n1
-	/n2 = { val=3; next="/n3" }
-	/n3 = { val=4; next="/n4" }
-	{ val=5; next="" } -> /n4
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
 }
 
 rwfunc reverse(head:[]char/utf32) -> () {
@@ -32,6 +29,17 @@ rwfunc reverse(head:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	build_list()
-	reverse("/n0")
+	n:[int64]·Node = {}
+	kv·abs(n) -> nb
+	nb + "·2" -> p2
+	nb + "·3" -> p3
+	nb + "·4" -> p4
+	nb + "·5" -> p5
+	n·1:Node = {val=1 next=p2}
+	n·2:Node = {val=2 next=p3}
+	n·3:Node = {val=3 next=p4}
+	n·4:Node = {val=4 next=p5}
+	n·5:Node = {val=5 next=""}
+	nb + "·1" -> h
+	reverse(h)
 }
diff --git a/tutorial/08-leetcode/234_palindrome_list.kv b/tutorial/08-leetcode/234_palindrome_list.kv
index 235de97f..5b82f876 100644
--- a/tutorial/08-leetcode/234_palindrome_list.kv
+++ b/tutorial/08-leetcode/234_palindrome_list.kv
@@ -1,8 +1,13 @@
-// 234: Palindrome Linked List — 链表复制到键族数组 + 双指针（dict 声明整型键）
+// 234: Palindrome Linked List — 链表复制到键族数组 + 双指针
 // 来源: LeetCode #234
 // 期望输出:
 //   true
 //   false
+struct Node {
+	val:int64=0
+	next:[]char/utf32=""
+}
+
 rwfunc is_pal(head:[]char/utf32) -> () {
 	arr:[int64]·int64 = {}
 	0 -> n
@@ -34,17 +39,24 @@ rwfunc is_pal(head:[]char/utf32) -> () {
 	}
 }
 
-rwfunc build() -> () {
-	/p0 = { val=1; next="/p1" }
-	/p1 = { val=2; next="/p2" }
-	{ val=2; next="/p3" } -> /p2
-	/p3 = { val=1; next="" }
-	/q0 = { val=1; next="/q1" }
-	{ val=2; next="" } -> /q1
-}
-
 rwfunc test() -> () {
-	build()
-	is_pal("/p0")
-	is_pal("/q0")
+	p:[int64]·Node = {}
+	kv·abs(p) -> pb
+	pb + "·2" -> p2
+	pb + "·3" -> p3
+	pb + "·4" -> p4
+	p·1:Node = {val=1 next=p2}
+	p·2:Node = {val=2 next=p3}
+	p·3:Node = {val=2 next=p4}
+	p·4:Node = {val=1 next=""}
+	pb + "·1" -> hp
+	is_pal(hp)
+
+	q:[int64]·Node = {}
+	kv·abs(q) -> qb
+	qb + "·2" -> q2
+	q·1:Node = {val=1 next=q2}
+	q·2:Node = {val=2 next=""}
+	qb + "·1" -> hq
+	is_pal(hq)
 }
diff --git a/tutorial/12-struct/00-point.kv b/tutorial/12-struct/00-point.kv
index c64f7574..be26ae7a 100644
--- a/tutorial/12-struct/00-point.kv
+++ b/tutorial/12-struct/00-point.kv
@@ -1,6 +1,6 @@
 // point: struct 声明 + 实例化 + 成员访问
 // 语义: struct Name { field:kindexpr=default } 注册 /lib/Name 原型；
-//       Name{f=v} 克隆原型子树、覆盖字段并做类型校验；p·f 成员访问。
+//       p:Name = {f=v} 克隆原型子树、覆盖字段并做类型校验；p·f 成员访问。
 // 期望输出:
 //   x= 3.0  y= 4.0
 //   default x= 0.0  y= 0.0
@@ -10,11 +10,11 @@ struct Point {
 }
 
 rwfunc test() -> () {
-	p = Point{x=3.0 y=4.0}
+	p:Point = {x=3.0 y=4.0}
 	p·x -> a
 	p·y -> b
 	println("x=", a, " y=", b)
-	q = Point{}
+	q:Point = {}
 	q·x -> c
 	q·y -> d
 	println("default x=", c, " y=", d)
diff --git a/tutorial/12-struct/01-fields.kv b/tutorial/12-struct/01-fields.kv
index 16edbb8c..6d701e72 100644
--- a/tutorial/12-struct/01-fields.kv
+++ b/tutorial/12-struct/01-fields.kv
@@ -11,12 +11,12 @@ struct User {
 }
 
 rwfunc test() -> () {
-	u = User{name="alice" age=30 active=true}
+	u:User = {name="alice" age=30 active=true}
 	u·name -> n
 	u·age -> a
 	u·active -> ac
 	println(n, a, ac)
-	d = User{}
+	d:User = {}
 	d·name -> dn
 	d·age -> da
 	d·active -> dac
diff --git a/tutorial/12-struct/02-mutate.kv b/tutorial/12-struct/02-mutate.kv
index 17ecd441..887aa3eb 100644
--- a/tutorial/12-struct/02-mutate.kv
+++ b/tutorial/12-struct/02-mutate.kv
@@ -9,7 +9,7 @@ struct P {
 }
 
 rwfunc test() -> () {
-	p = P{x=1 y=2}
+	p:P = {x=1 y=2}
 	p·x -> a
 	p·y -> b
 	println("before x=", a, " y=", b)
diff --git a/tutorial/12-struct/03-linked-list.kv b/tutorial/12-struct/03-linked-list.kv
index 378bb7f0..2e86187d 100644
--- a/tutorial/12-struct/03-linked-list.kv
+++ b/tutorial/12-struct/03-linked-list.kv
@@ -1,5 +1,5 @@
 // linked-list: struct 节点存进 map（int 键、struct 值），指针用绝对路径
-// 语义: /list 是 [int64]·/lib/Node 的 map；节点存在自增整数键 ·1 ·2 ·3；
+// 语义: /list 是 [int64]·Node 的 map；节点存在自增整数键 ·1 ·2 ·3；
 //       next 字段存下一节点的绝对路径串（""=尾）；"路径"·field 解引用。
 // 期望输出:
 //   10
@@ -11,10 +11,10 @@ struct Node {
 }
 
 rwfunc test() -> () {
-	/list:[int64]·/lib/Node = {}
-	Node{val=10 next="/list·2"} -> /list·1
-	Node{val=20 next="/list·3"} -> /list·2
-	Node{val=30} -> /list·3
+	/list:[int64]·Node = {}
+	/list·1:Node = {val=10 next="/list·2"}
+	/list·2:Node = {val=20 next="/list·3"}
+	/list·3:Node = {val=30}
 	cur = "/list·1"
 	while (cur != "") {
 		cur·val -> v
diff --git a/tutorial/12-struct/04-tree.kv b/tutorial/12-struct/04-tree.kv
index 929ddd7a..ba2f41a9 100644
--- a/tutorial/12-struct/04-tree.kv
+++ b/tutorial/12-struct/04-tree.kv
@@ -1,5 +1,5 @@
 // tree: 二叉树存进 map（int 键、struct 值），左右孩子用绝对路径指针
-// 语义: /tree 是 [int64]·/lib/TNode 的 map；left/right 存孩子绝对路径（""=空）；
+// 语义: /tree 是 [int64]·TNode 的 map；left/right 存孩子绝对路径（""=空）；
 //       inorder 递归中序遍历，node 是路径串，node·field 解引用。
 // 期望输出:
 //   3
@@ -23,10 +23,10 @@ rwfunc inorder(node:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	/tree:[int64]·/lib/TNode = {}
-	TNode{val=5} -> /tree·1
-	TNode{val=3} -> /tree·2
-	TNode{val=8} -> /tree·3
+	/tree:[int64]·TNode = {}
+	/tree·1:TNode = {val=5}
+	/tree·2:TNode = {val=3}
+	/tree·3:TNode = {val=8}
 	"/tree·2" -> /tree·1·left
 	"/tree·3" -> /tree·1·right
 	inorder("/tree·1")
diff --git a/tutorial/12-struct/05-graph.kv b/tutorial/12-struct/05-graph.kv
index 3ba5a880..a5741948 100644
--- a/tutorial/12-struct/05-graph.kv
+++ b/tutorial/12-struct/05-graph.kv
@@ -1,5 +1,5 @@
 // graph: 有向图存进 map（int 键、struct 值），邻居用绝对路径指针
-// 语义: /graph 是 [int64]·/lib/GNode 的 map；e0/e1 是两条出边的绝对路径（""=无）；
+// 语义: /graph 是 [int64]·GNode 的 map；e0/e1 是两条出边的绝对路径（""=无）；
 //       seen 标记去重；dfs 深度优先，node 是路径串，本地拷贝 n 后经 n·seen 回写。
 // 边: 1→2 1→3 2→3
 // 期望输出:
@@ -30,10 +30,10 @@ rwfunc dfs(node:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	/graph:[int64]·/lib/GNode = {}
-	GNode{val=1} -> /graph·1
-	GNode{val=2} -> /graph·2
-	GNode{val=3} -> /graph·3
+	/graph:[int64]·GNode = {}
+	/graph·1:GNode = {val=1}
+	/graph·2:GNode = {val=2}
+	/graph·3:GNode = {val=3}
 	"/graph·2" -> /graph·1·e0
 	"/graph·3" -> /graph·1·e1
 	"/graph·3" -> /graph·2·e0
diff --git a/tutorial/12-struct/06-list-reverse.kv b/tutorial/12-struct/06-list-reverse.kv
index fa29acdd..91404034 100644
--- a/tutorial/12-struct/06-list-reverse.kv
+++ b/tutorial/12-struct/06-list-reverse.kv
@@ -12,10 +12,10 @@ struct Node {
 }
 
 rwfunc test() -> () {
-	/list:[int64]·/lib/Node = {}
-	Node{val=10 next="/list·2"} -> /list·1
-	Node{val=20 next="/list·3"} -> /list·2
-	Node{val=30} -> /list·3
+	/list:[int64]·Node = {}
+	/list·1:Node = {val=10 next="/list·2"}
+	/list·2:Node = {val=20 next="/list·3"}
+	/list·3:Node = {val=30}
 	prev = ""
 	cur = "/list·1"
 	while (cur != "") {
diff --git a/tutorial/12-struct/07-list-local.kv b/tutorial/12-struct/07-list-local.kv
index 4e88fa4e..6002b791 100644
--- a/tutorial/12-struct/07-list-local.kv
+++ b/tutorial/12-struct/07-list-local.kv
@@ -1,7 +1,7 @@
 // list-local: 用局部变量容器实现链表（不放全局绝对路径）
 // 语义: list 是局部 map（帧内，路径含动态 vthread id，源码写不死）；
 //       kv·abs(list) 取容器运行期绝对路径，拼 ·n 造节点指针串；
-//       struct 赋值 X{…} -> list·n 由 layout 下沉为 kv·cpdir 深拷子树（成员随之落位）。
+//       struct 赋值 list·n:X = {…} 由 layout 下沉为 kv·cpdir 深拷子树（成员随之落位）。
 // 链表: 10→20→30
 // 期望输出:
 //   10
@@ -13,13 +13,13 @@ struct Node {
 }
 
 rwfunc test() -> () {
-	list:[int64]·/lib/Node = {}
+	list:[int64]·Node = {}
 	kv·abs(list) -> base
 	base + "·2" -> p2
 	base + "·3" -> p3
-	Node{val=10 next=p2} -> list·1
-	Node{val=20 next=p3} -> list·2
-	Node{val=30} -> list·3
+	list·1:Node = {val=10 next=p2}
+	list·2:Node = {val=20 next=p3}
+	list·3:Node = {val=30}
 	base + "·1" -> cur
 	while (cur != "") {
 		cur·val -> v