runtime: rwirext ABI camelCase + 06-编译器语义卷

runtime-rs/src/engine.rs

@@ -193,20 +193,20 @@ impl Engine {
     // ── rwir 派发时按下标解析读/写槽（rwirext 宿主 ABI，传 kvspace 句柄）─
     /// @-aware 读参：@ 句柄按 body 前缀路由兑现真实字节，其余（字面量/普通值/指针）沿用 C ResolveRead。
     pub fn read_at(&self, pc: &str, idx: i32) -> String {
-        let p = take(unsafe { kvlang_rwirextResolveReadPath(self.kv, cs(pc).as_ptr(), idx) });
+        let p = take(unsafe { kvlangRwirextResolveReadPath(self.kv, cs(pc).as_ptr(), idx) });
         if !p.is_empty() {
             let (r, body) = self.head_ref_body(&p);
             if r == 2 {
                 return self.resolve_ext(&body);
             }
         }
-        take(unsafe { kvlang_rwirextResolveRead(self.kv, cs(pc).as_ptr(), idx) })
+        take(unsafe { kvlangRwirextResolveRead(self.kv, cs(pc).as_ptr(), idx) })
     }
     pub fn read0(&self, pc: &str) -> String {
         self.read_at(pc, 0)
     }
     pub fn write_at(&self, pc: &str, idx: i32) -> String {
-        take(unsafe { kvlang_rwirextResolveWrite(self.kv, cs(pc).as_ptr(), idx) })
+        take(unsafe { kvlangRwirextResolveWrite(self.kv, cs(pc).as_ptr(), idx) })
     }
     pub fn write0(&self, pc: &str) -> String {
         self.write_at(pc, 0)
@@ -215,7 +215,7 @@ impl Engine {
     /// 取读参 idx 容器路径 → 读 body 字节；@ 句柄按前缀兑现真实字节；无路径退化为 read_at 的 utf8。
     /// 供 fs·write/append 等需要 []uint8 整块的 rwir 用。
     pub fn read_bytes(&self, pc: &str, idx: i32) -> Vec<u8> {
-        let p = take(unsafe { kvlang_rwirextResolveReadPath(self.kv, cs(pc).as_ptr(), idx) });
+        let p = take(unsafe { kvlangRwirextResolveReadPath(self.kv, cs(pc).as_ptr(), idx) });
         if p.is_empty() {
             return self.read_at(pc, idx).into_bytes();
         }
@@ -447,7 +447,7 @@ impl Engine {
                 break;
             }
             let c = take(pc);
-            let params = take(unsafe { kvlang_rwirextParams(self.kv, cs(&c).as_ptr()) });
+            let params = take(unsafe { kvlangRwirextParams(self.kv, cs(&c).as_ptr()) });
             let op = params.lines().next().unwrap_or("").to_string();
             let handled = if rwir::is_inproc(&op) {
                 rwir::dispatch(self, &op, &c);
@@ -460,7 +460,7 @@ impl Engine {
             if !handled {
                 crate::elog!("未知 rwir: {op} @ {c}");
             }
-            let nxt = take(unsafe { kvlang_rwirextNextPc(cs(&c).as_ptr()) });
+            let nxt = take(unsafe { kvlangRwirextNextPc(cs(&c).as_ptr()) });
             // pc 可能属子 vthread（native vthread·run 冒泡上来）：nextpc 写回其所属 vid，不写主 vid。
             let sub = c.split('/').nth(2).unwrap_or(vid);
             self.set_kv(&format!("/vthread/{sub}/\u{2025}pc"), &nxt);

runtime-rs/src/ffi.rs

@@ -167,32 +167,32 @@ unsafe extern "C" {
     // ── kvlang runtime：rwirext 宿主 ABI（均传 kvspace 句柄）─────────
     // C 头 kvlang_rwirext.h 导出 9 符号；此处声明 7：故意省略 LangtypeValid/LangtypeMatch
     // ——langtype 校验属 layout 期、匹配属 C dispatch 内部，Rust term 侧不调用（非缺陷）。
-    pub fn kvlang_rwirextRegister(
+    pub fn kvlangRwirextRegister(
         kvspace: *mut c_void,
         opcode: *const c_char,
         nr: c_int,
         nw: c_int,
         sig: *const c_char,
     ) -> c_int;
-    pub fn kvlang_rwirextParams(kvspace: *mut c_void, pc: *const c_char) -> *mut c_char;
-    pub fn kvlang_rwirextResolveRead(
+    pub fn kvlangRwirextParams(kvspace: *mut c_void, pc: *const c_char) -> *mut c_char;
+    pub fn kvlangRwirextResolveRead(
         kvspace: *mut c_void,
         pc: *const c_char,
         idx: c_int,
     ) -> *mut c_char;
-    pub fn kvlang_rwirextResolveReadPath(
+    pub fn kvlangRwirextResolveReadPath(
         kvspace: *mut c_void,
         pc: *const c_char,
         idx: c_int,
     ) -> *mut c_char;
-    pub fn kvlang_rwirextResolveWrite(
+    pub fn kvlangRwirextResolveWrite(
         kvspace: *mut c_void,
         pc: *const c_char,
         idx: c_int,
     ) -> *mut c_char;
-    pub fn kvlang_rwirextNextPc(pc: *const c_char) -> *mut c_char;
+    pub fn kvlangRwirextNextPc(pc: *const c_char) -> *mut c_char;
     // Handoff：非己方处理的外部 rwir（如 numpy）移交给对应扩展进程。
-    pub fn kvlang_rwirextHandoff(
+    pub fn kvlangRwirextHandoff(
         kvspace: *mut c_void,
         vtid: *const c_char,
         pc: *const c_char,

runtime-rs/src/main.rs

@@ -308,20 +308,20 @@ fn drive_vid(eng: &Engine, vid: &str) {
         // 连续批处理就地 rwir（print/json/http/kvlayout/input），遇非就地指令停下。
         let mut c = take(pc);
         let stop_op = loop {
-            let params = take(unsafe { kvlang_rwirextParams(kv, cs(&c).as_ptr()) });
+            let params = take(unsafe { kvlangRwirextParams(kv, cs(&c).as_ptr()) });
             let op = params.split('\n').next().unwrap_or("").to_string();
             if !rwir::is_inproc(&op) {
                 break op;
             }
             rwir::dispatch(eng, &op, &c);
-            c = take(unsafe { kvlang_rwirextNextPc(cs(&c).as_ptr()) });
+            c = take(unsafe { kvlangRwirextNextPc(cs(&c).as_ptr()) });
         };
 
         // pc 可能属子 vthread（native vthread·run 冒泡上来）：目标 vid 一律由 pc 导出，非固定主 vid。
         let sub = c.split('/').nth(2).unwrap_or(vid);
         // 停在本 myrwircaps 内的 op：handoff；native/控制帧/帧结束：写回 pc 让 runtime 继续。
         if !stop_op.is_empty() && rwir::in_myrwircaps(&stop_op) {
-            if unsafe { kvlang_rwirextHandoff(kv, cs(sub).as_ptr(), cs(&c).as_ptr()) } != 0 {
+            if unsafe { kvlangRwirextHandoff(kv, cs(sub).as_ptr(), cs(&c).as_ptr()) } != 0 {
                 kvlang_rs::elog!("handoff {stop_op} 失败 @ {c}");
                 std::process::exit(1);
             }

runtime-rs/src/rwir/http.rs

@@ -17,7 +17,7 @@ pub fn call(eng: &Engine, pc: &str) {
 }
 
 fn read(eng: &Engine, pc: &str, idx: i32) -> String {
-    take(unsafe { kvlang_rwirextResolveRead(eng.kv, cs(pc).as_ptr(), idx) })
+    take(unsafe { kvlangRwirextResolveRead(eng.kv, cs(pc).as_ptr(), idx) })
 }
 
 fn agent() -> ureq::Agent {

runtime-rs/src/rwir/json.rs

@@ -45,7 +45,7 @@ pub fn from(eng: &Engine, pc: &str) {
 }
 
 fn params(eng: &Engine, pc: &str) -> Vec<String> {
-    let s = take(unsafe { kvlang_rwirextParams(eng.kv, cs(pc).as_ptr()) });
+    let s = take(unsafe { kvlangRwirextParams(eng.kv, cs(pc).as_ptr()) });
     s.lines().map(str::to_string).collect()
 }
 

runtime-rs/src/rwir/mod.rs

@@ -188,7 +188,7 @@ pub fn register(eng: &Engine) {
                 .collect::<Vec<_>>()
                 .join("\n");
         unsafe {
-            kvlang_rwirextRegister(
+            kvlangRwirextRegister(
                 eng.kv,
                 cs(op).as_ptr(),
                 r.rp.len() as i32,

runtime-rs/src/rwir/networld/proc.rs

@@ -137,7 +137,7 @@ fn phys_dir_str(pid: &str) -> String {
 
 /// 取读参 idx 的容器 KV 路径（ResolveRead 对数组只返首元素，容器须用 ResolveReadPath）。
 fn read_path(eng: &Engine, pc: &str, idx: i32) -> String {
-    take(unsafe { kvlang_rwirextResolveReadPath(eng.kv, cs(pc).as_ptr(), idx) })
+    take(unsafe { kvlangRwirextResolveReadPath(eng.kv, cs(pc).as_ptr(), idx) })
 }
 
 /// stringkeymap 容器路径 p → 按坐标段 ·[i] 数值升序取各成员字符串（get_kv 解 char/utf32）。

runtime-rs/src/rwir/term.rs

@@ -9,7 +9,7 @@ use crate::engine::Engine;
 use crate::ffi::*;
 
 pub fn print_line(eng: &Engine, pc: &str) {
-    let params = take(unsafe { kvlang_rwirextParams(eng.kv, cs(pc).as_ptr()) });
+    let params = take(unsafe { kvlangRwirextParams(eng.kv, cs(pc).as_ptr()) });
     let mut it = params.split('\n');
     let opcode = it.next().unwrap_or("");
     let (sep, rawnl, cerr) = match opcode {

runtime-rwirext_example/go/json/json.go

@@ -167,31 +167,31 @@ func mkindex(c unsafe.Pointer, path string) {
 func resolveRead(c unsafe.Pointer, pc string, idx int) string {
 	cp := cstr(pc)
 	defer C.free(unsafe.Pointer(cp))
-	return gostr(C.kvlang_rwirextResolveRead(c, cp, C.int(idx)))
+	return gostr(C.kvlangRwirextResolveRead(c, cp, C.int(idx)))
 }
 
 func resolveReadPath(c unsafe.Pointer, pc string, idx int) string {
 	cp := cstr(pc)
 	defer C.free(unsafe.Pointer(cp))
-	return gostr(C.kvlang_rwirextResolveReadPath(c, cp, C.int(idx)))
+	return gostr(C.kvlangRwirextResolveReadPath(c, cp, C.int(idx)))
 }
 
 func resolveWrite(c unsafe.Pointer, pc string, idx int) string {
 	cp := cstr(pc)
 	defer C.free(unsafe.Pointer(cp))
-	return gostr(C.kvlang_rwirextResolveWrite(c, cp, C.int(idx)))
+	return gostr(C.kvlangRwirextResolveWrite(c, cp, C.int(idx)))
 }
 
 func nextPC(pc string) string {
 	cp := cstr(pc)
 	defer C.free(unsafe.Pointer(cp))
-	return gostr(C.kvlang_rwirextNextPc(cp))
+	return gostr(C.kvlangRwirextNextPc(cp))
 }
 
 func params(c unsafe.Pointer, pc string) []string {
 	cp := cstr(pc)
 	defer C.free(unsafe.Pointer(cp))
-	return strings.Split(gostr(C.kvlang_rwirextParams(c, cp)), "\n")
+	return strings.Split(gostr(C.kvlangRwirextParams(c, cp)), "\n")
 }
 
 // ── XValue 编解码（走权威 kvspace ABI：DecodeHead 读头 + TlvEncode/NewChar 编码）──
@@ -651,7 +651,7 @@ func register(c unsafe.Pointer) {
 		sig := strings.TrimSuffix(strings.Repeat("any\n", o.nr+o.nw), "\n")
 		co := cstr(o.name)
 		cs := cstr(sig)
-		C.kvlang_rwirextRegister(c, co, C.int32_t(o.nr), C.int32_t(o.nw), cs)
+		C.kvlangRwirextRegister(c, co, C.int32_t(o.nr), C.int32_t(o.nw), cs)
 		C.free(unsafe.Pointer(co))
 		C.free(unsafe.Pointer(cs))
 	}

runtime-rwirext_example/py/numpy/numpy.py

@@ -13,8 +13,8 @@
     算子（reshape/matmul/…）产出并按 [dims]dtype 存回 kvspace。
   · tensor data 零拷贝：读走权威 kvspaceDecodeHead，在 kvspace-c SHM 地址上建 ndarray 视图；
     写走权威 N 维 kvspaceTlvEncode，dims 直接落盘。
-  · 遵照读写码：从 kvlang_rwirextParams 取 opcode 与读/写操作数名；读参优先按路径零拷贝 view，
-    否则回退 kvlang_rwirextResolveRead；写参经 kvlang_rwirextResolveWrite 解析为 KV 路径。
+  · 遵照读写码：从 kvlangRwirextParams 取 opcode 与读/写操作数名；读参优先按路径零拷贝 view，
+    否则回退 kvlangRwirextResolveRead；写参经 kvlangRwirextResolveWrite 解析为 KV 路径。
   · numpy.print 走本进程自身的 stdout（不经 kvlang println）。
 """
 
@@ -90,16 +90,16 @@ def _bind():
                                ctypes.c_char_p, ctypes.c_uint32]
     _ks.kvspaceDel.restype = ctypes.c_int
     # rwirext ABI（kvspace 不提供的 runtime 语义）：句柄传扩展自连的 kvspace
-    for fn in ("kvlang_rwirextParams", "kvlang_rwirextResolveRead", "kvlang_rwirextResolveReadPath",
-               "kvlang_rwirextResolveWrite", "kvlang_rwirextNextPc"):
+    for fn in ("kvlangRwirextParams", "kvlangRwirextResolveRead", "kvlangRwirextResolveReadPath",
+               "kvlangRwirextResolveWrite", "kvlangRwirextNextPc"):
         getattr(_rt, fn).restype = ctypes.c_void_p
-    _rt.kvlang_rwirextRegister.restype = ctypes.c_int
-    _rt.kvlang_rwirextRegister.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char_p]
-    _rt.kvlang_rwirextParams.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
-    _rt.kvlang_rwirextResolveRead.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
-    _rt.kvlang_rwirextResolveReadPath.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
-    _rt.kvlang_rwirextResolveWrite.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
-    _rt.kvlang_rwirextNextPc.argtypes = [ctypes.c_char_p]
+    _rt.kvlangRwirextRegister.restype = ctypes.c_int
+    _rt.kvlangRwirextRegister.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char_p]
+    _rt.kvlangRwirextParams.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    _rt.kvlangRwirextResolveRead.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
+    _rt.kvlangRwirextResolveReadPath.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
+    _rt.kvlangRwirextResolveWrite.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
+    _rt.kvlangRwirextNextPc.argtypes = [ctypes.c_char_p]
     _lay.kvlangLayoutFile.restype = ctypes.c_int
     _lay.kvlangLayoutFile.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p,
                                         ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32]
@@ -279,32 +279,32 @@ def alloc(self, key, arr):
 
     # ── 读参：解析为帧槽路径后零拷贝 view；内联字面量回退 resolve_read ──
     def read_arg(self, pc, i):
-        path = _s(_rt.kvlang_rwirextResolveReadPath(self.kv, pc.encode(), i))
+        path = _s(_rt.kvlangRwirextResolveReadPath(self.kv, pc.encode(), i))
         if path:
             v = self.view(path)
             if v is not None:
                 return v
-        return _parse(_s(_rt.kvlang_rwirextResolveRead(self.kv, pc.encode(), i)))
+        return _parse(_s(_rt.kvlangRwirextResolveRead(self.kv, pc.encode(), i)))
 
     # ── 注册五大类 ─────────────────────────────────────────────────
     def register(self):
         for op, (nr, _) in OPS.items():
-            _rt.kvlang_rwirextRegister(self.kv, op.encode(), nr, 1, ("\n".join(["any"] * (nr + 1))).encode())
-        _rt.kvlang_rwirextRegister(self.kv, b"numpy.print", 1, 0, b"any...")
+            _rt.kvlangRwirextRegister(self.kv, op.encode(), nr, 1, ("\n".join(["any"] * (nr + 1))).encode())
+        _rt.kvlangRwirextRegister(self.kv, b"numpy.print", 1, 0, b"any...")
 
     def _handle(self, op, nr, fn, pc):
-        params = _s(_rt.kvlang_rwirextParams(self.kv, pc.encode())).split("\n")
+        params = _s(_rt.kvlangRwirextParams(self.kv, pc.encode())).split("\n")
         if op == "numpy.print":
             parts = []
             for i in range(len(params) - 1):
-                path = _s(_rt.kvlang_rwirextResolveReadPath(self.kv, pc.encode(), i))
+                path = _s(_rt.kvlangRwirextResolveReadPath(self.kv, pc.encode(), i))
                 v = self.view(path) if path else None
                 parts.append(_fmt(v) if v is not None
-                             else _s(_rt.kvlang_rwirextResolveRead(self.kv, pc.encode(), i)))
+                             else _s(_rt.kvlangRwirextResolveRead(self.kv, pc.encode(), i)))
             print(" ".join(parts), flush=True)
         else:
             args = [self.read_arg(pc, i) for i in range(nr)]
-            self.alloc(_s(_rt.kvlang_rwirextResolveWrite(self.kv, pc.encode(), 0)), np.asarray(fn(args)))
+            self.alloc(_s(_rt.kvlangRwirextResolveWrite(self.kv, pc.encode(), 0)), np.asarray(fn(args)))
 
     def serve(self, stop):
         table = {**OPS, "numpy.print": (1, None)}
@@ -321,7 +321,7 @@ def serve(self, stop):
                         self._handle(op, nr, fn, pc)
                     except Exception as e:                 # 计算失败也要放行，避免 run 阻塞超时
                         print(f"[numpy] {op} @ {pc}: {e}", file=sys.stderr, flush=True)
-                    nxt = _s(_rt.kvlang_rwirextNextPc(pc.encode()))
+                    nxt = _s(_rt.kvlangRwirextNextPc(pc.encode()))
                     self.kv_set(f"/vthread/{vid}/‥pc", nxt)
                     self.kv_set(f"{base}/.done<{vid}>", pid)
                     self.kv_del(todo)

runtime/include/kvlang_rwirext.h

@@ -11,32 +11,32 @@
  * 语义：rwir 解码 + resolve + display + PC 推进 + 类型判定。 */
 
 /* 写 /lib/<opcode> = rwir 签名（幂等） */
-int kvlang_rwirextRegister(void *kvspace, const char *opcode, int32_t nr,
+int kvlangRwirextRegister(void *kvspace, const char *opcode, int32_t nr,
                          int32_t nw, const char *sig);
 
 /* 外部扩展 handoff：写 /lib/<opcode>/.todo<vid> 并阻塞 watch .done<vid>（30s
  * 超时）。RETURN 模式下 term 遇非己方 ext rwir（如 json.to/numpy）时调用，把
  * 该指令交给对应扩展进程，扩展处理后写回下一 PC 并 signal .done。返回 0 成功，
  * -1 失败/超时。 */
-int kvlang_rwirextHandoff(void *kvspace, const char *vtid, const char *pc);
+int kvlangRwirextHandoff(void *kvspace, const char *vtid, const char *pc);
 
 /* 当前指令的下一条 PC（malloc） */
-char *kvlang_rwirextNextPc(const char *pc);
+char *kvlangRwirextNextPc(const char *pc);
 
 /* 解码指令，返回 opcode + 读参名 + 写参名（\n 分隔：首行 opcode，接 nr
  * 行读参名，接 nw 行写参名，malloc）。 供 numpy/tensor 扩展按路径零拷贝读 raw
  * 数据。 */
-char *kvlang_rwirextParams(void *kvspace, const char *pc);
+char *kvlangRwirextParams(void *kvspace, const char *pc);
 
 /* 解析读参 idx 为字符串（变量 → 帧槽值；路径 → 该路径下的值）。 */
-char *kvlang_rwirextResolveRead(void *kvspace, const char *pc, int idx);
+char *kvlangRwirextResolveRead(void *kvspace, const char *pc, int idx);
 
 /* 解析读参 idx 为 KV 路径（变量 → 帧槽路径；路径 → 直接返回；字面量 → ""）。
  * 供 numpy/tensor 扩展按路径零拷贝读整块 ndarray raw 数据。 */
-char *kvlang_rwirextResolveReadPath(void *kvspace, const char *pc, int idx);
+char *kvlangRwirextResolveReadPath(void *kvspace, const char *pc, int idx);
 
 /* 解析写参 idx 为 KV 路径（路径 → 直接返回；变量 → 帧槽路径）。 */
-char *kvlang_rwirextResolveWrite(void *kvspace, const char *pc, int idx);
+char *kvlangRwirextResolveWrite(void *kvspace, const char *pc, int idx);
 
 /* 签名 langtype（runtime篇-07）——供扩展做实参类型判定。 */
 /* 语法校验：type = atom("|"atom)*, atom = [dims](family|kind),

runtime/src/rwirext.c

@@ -48,7 +48,7 @@ static void register_vids(kvlangKv_t *k, const char *opcode) {
   free(base);
 }
 
-int kvlang_rwirextRegister(void *kvspace, const char *opcode, int32_t nr,
+int kvlangRwirextRegister(void *kvspace, const char *opcode, int32_t nr,
                          int32_t nw, const char *sig) {
   kvlangKv_t k = {kvspace};
   char *key = kvlangKeytreeRwir(opcode);
@@ -64,7 +64,7 @@ int kvlang_rwirextRegister(void *kvspace, const char *opcode, int32_t nr,
   return rc;
 }
 
-int kvlang_rwirextHandoff(void *kvspace, const char *vtid, const char *pc) {
+int kvlangRwirextHandoff(void *kvspace, const char *vtid, const char *pc) {
   kvlangKv_t k = {kvspace};
   char *fr = kvlangKeytreeFrameRoot(pc);
   if (!fr)
@@ -84,14 +84,14 @@ int kvlang_rwirextHandoff(void *kvspace, const char *vtid, const char *pc) {
   return rc;
 }
 
-char *kvlang_rwirextNextPc(const char *pc) {
+char *kvlangRwirextNextPc(const char *pc) {
   kvlangStrbuf_t b;
   kvlangStrbufInit(&b);
   kvlangRwirNextPc(pc, &b);
   return kvlangStrbufDetach(&b);
 }
 
-char *kvlang_rwirextParams(void *kvspace, const char *pc) {
+char *kvlangRwirextParams(void *kvspace, const char *pc) {
   kvlangKv_t k = {kvspace};
   char *fr = kvlangKeytreeFrameRoot(pc);
   if (!fr)
@@ -158,7 +158,7 @@ static char *display_map(kvlangKv_t *k, const char *path) {
 }
 
 /* 解析读参 idx 为字符串（变量 → 帧槽值；路径 → 该路径下的值）。 */
-char *kvlang_rwirextResolveRead(void *kvspace, const char *pc, int idx) {
+char *kvlangRwirextResolveRead(void *kvspace, const char *pc, int idx) {
   kvlangKv_t k = {kvspace};
   char *fr = kvlangKeytreeFrameRoot(pc);
   if (!fr)
@@ -195,7 +195,7 @@ char *kvlang_rwirextResolveRead(void *kvspace, const char *pc, int idx) {
 
 /* 解析读参 idx 为 KV 路径（变量/临时 → 帧槽路径；路径 → 直接返回；内联字面量 →
  * ""）。 */
-char *kvlang_rwirextResolveReadPath(void *kvspace, const char *pc, int idx) {
+char *kvlangRwirextResolveReadPath(void *kvspace, const char *pc, int idx) {
   kvlangKv_t k = {kvspace};
   char *fr = kvlangKeytreeFrameRoot(pc);
   if (!fr)
@@ -226,7 +226,7 @@ char *kvlang_rwirextResolveReadPath(void *kvspace, const char *pc, int idx) {
 }
 
 /* 解析写参 idx 为 KV 路径（路径 → 直接返回；变量 → 帧槽路径）。 */
-char *kvlang_rwirextResolveWrite(void *kvspace, const char *pc, int idx) {
+char *kvlangRwirextResolveWrite(void *kvspace, const char *pc, int idx) {
   kvlangKv_t k = {kvspace};
   char *fr = kvlangKeytreeFrameRoot(pc);
   if (!fr)