@dongmingzhixiu/vuexir-compiler 0.1.1 → 0.2.0

package/dist/transform/vue2ir.js

@@ -18,21 +18,100 @@
 import { parse } from '@vue/compiler-sfc';
 import { NodeTypes } from '@vue/compiler-core';
 import { CssParseError, mergeIrProps, parseCss, parseInlineStyle } from './css.js';
+import { buildStoreRegistry, findStoreAliases, parseSharedConstArrays } from './stores.js';
 export class VueCompileError extends Error {
 }
+/** R90 store getter 降级告警（flattenStorePath 无 warnings 参数，先收集后并入） */
+let storeGetterWarnings = [];
+/** R89 派生名表：`all` → `ui_upcoming`（computed 折叠成状态点路径） */
+let derivedNames = new Map();
+/** R88 store 文件导出的常量数组（v-for 编译期内联用） */
+let storeConstArrays = {};
+/** R86 store 别名表：`ui` → StoreDef（每次 vueToIr 重建；与 vforConsts 同风格） */
+let storeAliases = new Map();
+/** R86 把 `alias.field.path` 拍平为 `alias_field.path`；getter/action 返回哨兵串 */
+function flattenStorePath(name) {
+    // R89：computed 折叠出的派生名（all → ui_upcoming；all.length → ui_upcoming.length）
+    if (derivedNames.size > 0) {
+        const m0 = name.match(/^([A-Za-z_$][\w$]*)(\..+)?$/);
+        if (m0 && derivedNames.has(m0[1]))
+            return derivedNames.get(m0[1]) + (m0[2] ?? '');
+    }
+    if (storeAliases.size === 0)
+        return name;
+    const m = name.match(/^([A-Za-z_$][\w$]*)\.(.+)$/);
+    if (!m)
+        return name;
+    const def = storeAliases.get(m[1]);
+    if (!def)
+        return name;
+    const segs = m[2].split('.');
+    const field = segs[0];
+    // R86 续：getter 若可折叠成「从某个 state 字段出发的成员链」，直接拍成该字段的点路径
+    const getter = def.getters.find((g) => g.name === field);
+    if (getter && getter.stateField) {
+        const tail = [getter.path, ...segs.slice(1)].filter(Boolean).join('.');
+        return [`${m[1]}_${getter.stateField}`, tail].filter(Boolean).join('.');
+    }
+    // R90 含计算逻辑的 getter：降级为读取底层 state 字段（筛选/排序/派生字段语义丢失）
+    if (getter && getter.refField) {
+        // 链式解析：getter → 另一个 getter → … → state 字段（如 soon → upcoming → list）
+        let field2 = getter.refField;
+        const seen = new Set([field]);
+        let guard = 0;
+        while (field2 && !def.state.some((f) => f.name === field2) && guard++ < 6 && !seen.has(field2)) {
+            seen.add(field2);
+            field2 = def.getters.find((g) => g.name === field2)?.refField;
+        }
+        if (field2 && def.state.some((f) => f.name === field2)) {
+            const msg = `store getter「${m[1]}.${field}」含计算逻辑（遍历/过滤/排序等），原生端无法求值 → 已降级为直接读取底层状态「${m[1]}_${field2}」，派生语义丢失（R90）`;
+            if (!storeGetterWarnings.includes(msg))
+                storeGetterWarnings.push(msg);
+            return [`${m[1]}_${field2}`, ...segs.slice(1)].filter(Boolean).join('.');
+        }
+    }
+    if (getter && getter.multi) {
+        const msg = `store getter「${m[1]}.${field}」依赖多个 state 字段，无法降级 → 已生成占位（R90）`;
+        if (!storeGetterWarnings.includes(msg))
+            storeGetterWarnings.push(msg);
+        return `\u0000store:${m[1]}.${m[2]}`;
+    }
+    if (!def.state.some((f) => f.name === field))
+        return `\u0000store:${m[1]}.${m[2]}`;
+    return [`${m[1]}_${field}`, ...segs.slice(1)].join('.');
+}
 /** R-VFOBJ-C：解析 <script setup> 顶层 `const rows = [ ... ]`（静态数组字面量）→ { name: 数组内文 }
  *  模板 `v-for="(item, i) in rows"` 引用变量名时查表展开（编译期常量，非 M4b 动态状态）；
  *  自动排除 ref([...])（`=` 后非 `[` 不匹配）、navBar 对象（非数组）与函数体（保守容忍，与 extractScreenState 一致）
  */
 export function extractScreenConstArrays(script) {
     const out = {};
-    const re = /const\s+(\w+)\s*=\s*(\[[\s\S]*?\])\s*;?/g;
+    // 允许类型标注（const WAYS: {...}[] = [）且用括号配平，避免嵌套数组被首个 ] 截断（R88）
+    const re = /const\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*\[/g;
     let m;
     while ((m = re.exec(script))) {
-        const arr = m[2];
-        const inner = arr.slice(1, -1).trim();
+        const at = script.indexOf('[', m.index + m[0].length - 1);
+        if (at === -1)
+            continue;
+        let depth = 0;
+        let end = -1;
+        for (let i = at; i < script.length; i++) {
+            if (script[i] === '[')
+                depth++;
+            else if (script[i] === ']') {
+                depth--;
+                if (depth === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        if (end === -1)
+            continue;
+        const inner = script.slice(at + 1, end).trim();
         if (inner)
             out[m[1]] = inner;
+        re.lastIndex = end + 1;
     }
     return out;
 }
@@ -57,6 +136,37 @@ export function extractScreenState(script) {
         const json = '[' + m[2].trim().replace(/'([^']*)'/g, '"$1"') + ']';
         states.push({ name: m[1], init: json, list: true });
     }
+    // R85 对象态：const board = ref({ month: { label: '10 月' }, tags: '生日' })
+    // init 存规范化 JSON 字符串（双端一致：Swift/Compose 交给 vrnField 点路径解析，JS 侧解析为对象）
+    for (const m of script.matchAll(/const\s+(\w+)\s*=\s*ref(?:<[^>]*>)?\(\s*\{/g)) {
+        const start = (m.index ?? 0) + m[0].length - 1;
+        let depth = 0;
+        let end = -1;
+        for (let i = start; i < script.length; i++) {
+            const ch = script[i];
+            if (ch === '{')
+                depth++;
+            else if (ch === '}') {
+                depth--;
+                if (depth === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        if (end === -1)
+            continue;
+        const raw = script.slice(start, end + 1);
+        // 规范化：单引号 → 双引号；裸键加引号（仅限简单字面量对象，复杂表达式会被 vrnField 忽略该层）
+        const json = raw
+            .replace(/'([^']*)'/g, (_a, inner) => `"${inner.replace(/"/g, '\\"')}"`)
+            .replace(/([{,]\s*)([A-Za-z_$][\w$]*)\s*:/g, (_a, pre, key) => `${pre}"${key}":`)
+            .replace(/,(\s*[}\]])/g, '$1')
+            .replace(/\s*\n\s*/g, ' ')
+            .replace(/\s{2,}/g, ' ')
+            .trim();
+        states.push({ name: m[1], init: json, obj: true });
+    }
     // 箭头函数（有参）：const f = (p) => { x.value = p } / const f = p => { ... }
     for (const m of script.matchAll(/const\s+(\w+)\s*=\s*(?:\(\s*([A-Za-z_]\w*)\s*\)|([A-Za-z_]\w*))\s*=>\s*\{\s*(\w+)\.value\s*=\s*([^;{}]+)\s*;?\s*\}/g)) {
         setters[m[1]] = { target: m[4], param: (m[2] ?? m[3]) };
@@ -264,6 +374,39 @@ if (typeof queueMicrotask !== "function") {
   };
 }
 
+// R81 原生桥：bridge.toast / bridge.openUrl（iOS 由 __nativeToast/__nativeOpenUrl 宿主函数实现；
+// Android 由编译器把 bridge.* 翻译成 VrnBridge.*；浏览器预览退回 alert/console）
+// R81/R84 原生桥：编译期注入的实现（iOS VrnBridge.swift / Android VrnBridge.kt）
+// 未注入原生实现时（浏览器预览）退化为 console / window 语义，保证同一份代码两端可跑
+function __vrnNative(name) {
+  return typeof globalThis[name] === "function" || typeof (typeof self !== "undefined" ? self[name] : undefined) === "function";
+}
+var bridge = {
+  isNative: __vrnNative("__nativeToast"),
+  toast: function (msg) {
+    if (__vrnNative("__nativeToast")) __nativeToast(String(msg));
+    else if (typeof console !== "undefined") console.log("[bridge.toast]", msg);
+  },
+  openUrl: function (url) {
+    if (__vrnNative("__nativeOpenUrl")) __nativeOpenUrl(String(url));
+    else if (typeof window !== "undefined") window.open(String(url), "_blank");
+  },
+  vibrate: function (ms) {
+    if (__vrnNative("__nativeVibrate")) __nativeVibrate(Number(ms) > 0 ? Number(ms) : 18);
+    else if (typeof navigator !== "undefined" && navigator.vibrate) navigator.vibrate(Number(ms) > 0 ? Number(ms) : 18);
+  },
+  copy: function (text) {
+    if (__vrnNative("__nativeCopy")) __nativeCopy(String(text));
+    else if (typeof navigator !== "undefined" && navigator.clipboard) navigator.clipboard.writeText(String(text));
+  },
+  setStatusBar: function (style) {
+    if (__vrnNative("__nativeSetStatusBar")) __nativeSetStatusBar(String(style));
+  },
+  keepScreenOn: function (on) {
+    if (__vrnNative("__nativeKeepScreenOn")) __nativeKeepScreenOn(!!on);
+  }
+};
+
 // localStorage → 原生 UserDefaults（D7：vrn. 前缀 + 同步读写）
 var localStorage = {
   getItem: function (k) { return typeof __lsGet === "function" ? __lsGet("vrn." + k) : null; },
@@ -326,7 +469,81 @@ export function swiftExpr(exp) {
 }
 /** @click="fn(arg)" → 若 fn 是已提取的 setter，内联为状态赋值 { var, value, kind }（M1 扩展无参表达式 setter）
  *  M2：直接赋值表达式 `selected = item` / `selected = i`（列表选中）同样内联 */
-export function resolveSetCall(handler, state) {
+/**
+ * R87 store action 折叠：把 `ui.setSkin('night')` 解析成页面状态赋值。
+ * 只认三种简单体：`this.f = <字面量>` / `this.f = <形参>`（调用处实参替代）/ `this.f++`。
+ * 返回 null 表示不可折叠（调用方保留原样并给 warning）。
+ */
+function resolveStoreAction(alias, actionName, argsRaw, warn) {
+    const def = storeAliases.get(alias);
+    if (!def)
+        return null;
+    const act = def.actions.find((a) => a.name === actionName);
+    if (!act)
+        return null;
+    // 只取第一条语句：`this.skin = skin; void setSetting(...)` 里状态赋值可折叠，持久化副作用丢弃（给 warning）
+    const stmts = act.body
+        .split(/[\n;]+/)
+        .map((t) => t.trim())
+        .filter(Boolean);
+    const body = (stmts[0] ?? '').replace(/;\s*$/, '').trim();
+    const args = argsRaw
+        .split(',')
+        .map((a) => a.trim())
+        .filter(Boolean);
+    // this.f = <rhs>
+    let m = body.match(/^this\.(\w+)\s*=\s*([\s\S]+)$/);
+    if (m) {
+        const field = m[1];
+        if (!def.state.some((f) => f.name === field))
+            return null;
+        let rhs = m[2].trim();
+        const pIdx = act.params.indexOf(rhs);
+        if (pIdx !== -1) {
+            if (args.length <= pIdx)
+                return null;
+            rhs = args[pIdx];
+        }
+        else if (act.params.some((p) => new RegExp(`\\b${p}\\b`).test(rhs))) {
+            return null; // 体里对形参做了运算 → 不折叠
+        }
+        if (stmts.length > 1) {
+            warn?.(`store action「${actionName}」已折叠状态赋值，其余语句（${stmts.slice(1).join('; ')}）未折叠（R87）`);
+        }
+        if (/^-?\d+(\.\d+)?$/.test(rhs))
+            return { var: `${alias}_${field}`, value: Number(rhs), kind: 'literal' };
+        if (/^'[^']*'$|^"[^"]*"$/.test(rhs))
+            return { var: `${alias}_${field}`, value: rhs.slice(1, -1), kind: 'literal' };
+        const expr = swiftExpr(rhs);
+        return expr === null ? null : { var: `${alias}_${field}`, value: expr, kind: 'expr' };
+    }
+    // this.f++ / this.f--
+    m = body.match(/^this\.(\w+)\s*(\+\+|--)$/);
+    if (m && def.state.some((f) => f.name === m[1])) {
+        if (stmts.length > 1)
+            warn?.(`store action「${actionName}」已折叠状态赋值，其余语句（${stmts.slice(1).join('; ')}）未折叠（R87）`);
+        const v = `${alias}_${m[1]}`;
+        return { var: v, value: `${v} ${m[2] === '++' ? '+' : '-'} 1`, kind: 'expr' };
+    }
+    return null;
+}
+/** R87 把 handler 体内 `alias.action(...)` 折成 `stateStore.alias_field = <值>`（双端可译） */
+function foldStoreActionsInBody(body) {
+    if (storeAliases.size === 0)
+        return body;
+    let out = body;
+    for (const [alias, def] of storeAliases) {
+        for (const act of def.actions) {
+            const re = new RegExp(`\\b${alias}\\.${act.name}\\(([^)]*)\\)`, 'g');
+            out = out.replace(re, (whole, args) => {
+                const r = resolveStoreAction(alias, act.name, args);
+                return r === null ? whole : `stateStore.${r.var} = ${r.kind === 'literal' && typeof r.value === 'string' ? JSON.stringify(r.value) : String(r.value)}`;
+            });
+        }
+    }
+    return out;
+}
+export function resolveSetCall(handler, state, warn) {
     const t = handler.trim();
     // M2 直接赋值：目标必须是已声明状态
     const assign = t.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
@@ -341,6 +558,13 @@ export function resolveSetCall(handler, state) {
             return { var: assign[1], value: expr, kind: 'expr' };
         return null;
     }
+    // R87 store action：`ui.setSkin('night')` → onSet 赋值（两端统一走 onSet）
+    const sa = t.match(/^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)\(([^)]*)\)$/);
+    if (sa && storeAliases.has(sa[1])) {
+        const r = resolveStoreAction(sa[1], sa[2], sa[3], warn);
+        if (r)
+            return r;
+    }
     const m = t.match(/^(\w+)\(([^)]*)\)$/);
     if (!m)
         return null;
@@ -464,6 +688,20 @@ function parseVFor(exp, warnings, constArrays) {
     const body = m[3].trim();
     // M4b 动态列表：in <stateName>（stateStore 数组；Swift 侧 JSON 字符串解码渲染）
     // R-VFOBJ-C：引用 script 顶层 const 数组（const rows = [...]）→ 编译期展开，优先于动态状态判定
+    // R88 store 常量数组（store 文件里 export const SKINS = [...]）与页面常量数组同等待遇
+    if (body in storeConstArrays && !(constArrays && body in constArrays)) {
+        const vf = parseVForArrayInner(storeConstArrays[body], itemKey, indexKey, warnings);
+        if (vf)
+            vf.srcName = body;
+        return vf;
+    }
+    // R88 store 状态数组：v-for="x in ui.list" → 拍平为 ui_list 后按动态列表处理
+    {
+        const flat = flattenStorePath(body);
+        if (flat !== body && /^[A-Za-z_$][\w$]*$/.test(flat)) {
+            return { listState: flat, itemKey, indexKey };
+        }
+    }
     if (/^[A-Za-z_]\w*$/.test(body)) {
         if (constArrays && body in constArrays) {
             const inner = constArrays[body];
@@ -569,9 +807,21 @@ function parseObjectLiteral(s) {
         const key = trimmed.slice(0, ci).trim().replace(/^['"]|['"]$/g, '');
         const valRaw = trimmed.slice(ci + 1).trim();
         const lit = literalValue(valRaw);
-        if (lit === undefined || typeof lit === 'boolean')
-            return null;
-        obj[key] = lit;
+        if (typeof lit === 'boolean') {
+            // R88：布尔值按字符串保留（列表项属性表只存 string|number，渲染时按文本用）
+            obj[key] = lit ? 'true' : 'false';
+            continue;
+        }
+        if (lit !== undefined) {
+            obj[key] = lit;
+            continue;
+        }
+        // R88：嵌套数组/对象值 → 序列化为 JSON 文本保底（不作为可渲染字段，但不因此整段丢弃）
+        if (/^[\[{]/.test(valRaw) && /[\]}]$/.test(valRaw)) {
+            obj[key] = valRaw.replace(/'([^']*)'/g, (_a, inner) => `"${inner}"`);
+            continue;
+        }
+        return null;
     }
     return Object.keys(obj).length > 0 ? obj : null;
 }
@@ -588,6 +838,14 @@ const TAG_MAP = {
     li: { type: 'group' },
     p: { type: 'text', defaultProps: { fontSize: 14 } },
     span: { type: 'text', defaultProps: { fontSize: 14 } },
+    // R89 续：行内语义标签按纯文本处理（原生端无 HTML 语义，但文本内容必须保留）
+    b: { type: 'text', defaultProps: { fontSize: 14 } },
+    strong: { type: 'text', defaultProps: { fontSize: 14 } },
+    i: { type: 'text', defaultProps: { fontSize: 14 } },
+    em: { type: 'text', defaultProps: { fontSize: 14 } },
+    small: { type: 'text', defaultProps: { fontSize: 12 } },
+    u: { type: 'text', defaultProps: { fontSize: 14 } },
+    code: { type: 'text', defaultProps: { fontSize: 13 } },
     h1: { type: 'text', defaultProps: { fontSize: 24, fontWeight: 'bold' } },
     h2: { type: 'text', defaultProps: { fontSize: 20, fontWeight: 'bold' } },
     h3: { type: 'text', defaultProps: { fontSize: 17, fontWeight: 'medium' } },
@@ -605,6 +863,10 @@ let vforConsts = {};
 export function vueToIr(source, opts = {}) {
     compPosition = new Map();
     vforConsts = {};
+    storeAliases = new Map();
+    storeConstArrays = {};
+    derivedNames = new Map();
+    storeGetterWarnings = [];
     const warnings = [];
     const { descriptor, errors } = parse(source, { filename: 'Screen.vue' });
     if (errors.length > 0) {
@@ -687,6 +949,8 @@ export function vueToIr(source, opts = {}) {
     let navBarConfig = null;
     let onMountedBody;
     let onMountedAsync = false;
+    /** R74 保留名状态的重命名映射（旧名 → 新名） */
+    const stateRenames = new Map();
     let stateInfo;
     const script = descriptor.scriptSetup ?? descriptor.script;
     if (script && script.content.trim()) {
@@ -706,12 +970,71 @@ export function vueToIr(source, opts = {}) {
                 warnings.push(`handler「${h.name}」函数体疑似含 TS 类型标注（如 const x: number = 1），runtime.js 将解析失败——请移除类型标注（R13 仅支持 JS 子集）`);
             }
         }
-        // R74：状态名撞原生保留成员（SwiftUI `body`、Kotlin 关键字等）会导致生成代码编译失败 → 必须提前警告
+        // R86 Pinia 折叠：`const ui = useUiStore()` → 把 store.state 拍平成页面状态 `ui_<field>`
+        if (opts.storeSources) {
+            for (const src of Object.values(opts.storeSources)) {
+                storeConstArrays = { ...storeConstArrays, ...parseSharedConstArrays(src) };
+            }
+            const registry = buildStoreRegistry(opts.storeSources);
+            storeAliases = findStoreAliases(src, registry);
+            for (const [alias, def] of storeAliases) {
+                for (const f of def.state) {
+                    const flat = `${alias}_${f.name}`;
+                    if (stateInfo.states.some((st) => st.name === flat))
+                        continue;
+                    stateInfo.states.push({ name: flat, init: f.init, ...(f.obj ? { obj: true } : {}), ...(f.list ? { list: true } : {}) });
+                }
+            }
+        }
+        // R89 computed 折叠：`const all = computed(() => store.upcoming)` → 派生名指向扁平状态点路径
+        for (const cm of src.matchAll(/const\s+([A-Za-z_$][\w$]*)\s*=\s*computed\s*\(\s*\(\s*\)\s*=>\s*([^)]+?)\s*\)/g)) {
+            const expr = cm[2].trim();
+            const flat = flattenStorePath(expr);
+            if (flat !== expr && /^[A-Za-z_$][\w$.]*$/.test(flat)) {
+                derivedNames.set(cm[1], flat);
+            }
+        }
+        // R89 常量折叠：模块级纯常量（含可静态求值的模板字面量）注入为状态
+        for (const km of src.matchAll(/const\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(`[^`]*`|'[^']*'|"[^"]*"|-?\d+(?:\.\d+)?)\s*$/gm)) {
+            const raw = km[2];
+            const name = km[1];
+            if (stateInfo.states.some((st) => st.name === name))
+                continue;
+            let value;
+            if (/^-?\d+(\.\d+)?$/.test(raw))
+                value = Number(raw);
+            else if (raw.startsWith('`')) {
+                // 模板字面量：仅允许 Date/Math/数字/字符串等可静态求值的片段，否则跳过
+                const inner = raw.slice(1, -1);
+                if (/\$\{[^}]*\}/.test(inner)) {
+                    // 白名单改为黑名单：允许中文等任意字面字符，但禁止访问宿主/业务对象
+                    if (!/\b(window|document|globalThis|require|process|fetch|store|props|this|localStorage)\b/.test(inner)) {
+                        try {
+                            value = String(new Function(`return \`${inner}\`;`)());
+                        }
+                        catch {
+                            /* 求值失败 → 跳过 */
+                        }
+                    }
+                }
+                else {
+                    value = inner;
+                }
+            }
+            else {
+                value = raw.slice(1, -1);
+            }
+            if (value !== undefined)
+                stateInfo.states.push({ name, init: value });
+        }
+        // R74：状态名撞原生保留成员（SwiftUI `body`、Kotlin 关键字）→ 自动改名 + 警告（不再只警告导致后续编译失败）
         {
             const RESERVED = ['body', 'self', 'init', 'class', 'object', 'fun', 'val', 'var', 'when', 'is', 'in'];
             for (const st of stateInfo?.states ?? []) {
                 if (RESERVED.includes(st.name)) {
-                    warnings.push(`状态名「${st.name}」与原生保留成员冲突（SwiftUI body / Kotlin 关键字）——请改名（如 ${st.name}Text / ${st.name}Value），否则生成的 iOS/Android 代码无法编译`);
+                    const next = `${st.name}Text`;
+                    stateRenames.set(st.name, next);
+                    warnings.push(`状态名「${st.name}」与原生保留成员冲突 → 将自动改名「${next}」（R74）`);
                 }
             }
         }
@@ -723,6 +1046,28 @@ export function vueToIr(source, opts = {}) {
             onMountedAsync = /(^|[^\w$.])await\s/.test(onMountedBody) || /onMounted\s*\(\s*async\b/.test(src);
             onMountedBody = rewriteStateRefs(onMountedBody, (stateInfo?.states ?? []).map((s) => s.name));
         }
+        // R87：handler/onMounted 内的 store action 调用 → 状态赋值（iOS 走 JS stateStore，Android 走内联赋值）
+        if (storeAliases.size > 0) {
+            for (const h of handlers ?? [])
+                h.body = foldStoreActionsInBody(h.body);
+            if (onMountedBody !== undefined)
+                onMountedBody = foldStoreActionsInBody(onMountedBody);
+        }
+        // R74 续：先在 handler/onMounted 源码里改名，再生成 runtime（否则 JS 侧仍指向旧名）
+        if (stateRenames.size > 0) {
+            const renameSrc = (src) => {
+                let out = src;
+                for (const [from, to] of stateRenames) {
+                    out = out.replace(new RegExp(`\\bstateStore\\.${from}\\b`, 'g'), `stateStore.${to}`);
+                    out = out.replace(new RegExp(`\\b${from}\\.value\\b`, 'g'), `${to}.value`);
+                }
+                return out;
+            };
+            for (const h of handlers ?? [])
+                h.body = renameSrc(h.body);
+            if (onMountedBody !== undefined)
+                onMountedBody = renameSrc(onMountedBody);
+        }
         if (handlers.length > 0 || onMountedBody !== undefined) {
             runtime = generateRuntimeSource(stateInfo?.states ?? [], handlers, onMountedBody, onMountedAsync);
         }
@@ -736,6 +1081,21 @@ export function vueToIr(source, opts = {}) {
         compPosition.set(c.name, tree.position);
         return { name: c.name, ui: tree.ui };
     });
+    // R74 续：把重命名应用到 handler/onMounted 源码与 IR 引用（否则绑定仍指向旧名 → 编译失败）
+    if (stateRenames.size > 0) {
+        const renameSrc = (src) => {
+            let out = src;
+            for (const [from, to] of stateRenames) {
+                out = out.replace(new RegExp(`\\bstateStore\\.${from}\\b`, 'g'), `stateStore.${to}`);
+                out = out.replace(new RegExp(`\\b${from}\\.value\\b`, 'g'), `${to}.value`);
+            }
+            return out;
+        };
+        for (const h of handlers ?? [])
+            h.body = renameSrc(h.body);
+        if (onMountedBody !== undefined)
+            onMountedBody = renameSrc(onMountedBody);
+    }
     const children = ast.children.flatMap((c) => walk(c, classProps, comboRules, scopedRules, pseudoRules, warnings, stateInfo, compTable));
     let pageRootBg;
     // 3) 组装 screen：root（width fill + height 基准）包一层 group（承载根元素布局 props）
@@ -774,8 +1134,64 @@ export function vueToIr(source, opts = {}) {
             checkClickHandlers(c);
     };
     checkClickHandlers(ui);
+    // R74 续：IR 树里的状态引用改名（bind/show/onSet/bindParts/fieldOf/condition/动态样式/输入值/列表态）
+    if (stateRenames.size > 0) {
+        // 状态表本身改名（放在 walk 之后，保证 {{ body }} 在解析时仍能命中原名）
+        for (const st of stateInfo?.states ?? []) {
+            const to = stateRenames.get(st.name);
+            if (to !== undefined)
+                st.name = to;
+        }
+        const rn = (v) => (v === undefined ? undefined : stateRenames.get(v) ?? v);
+        const rnCond = (c) => {
+            if (c === undefined)
+                return undefined;
+            let out = c;
+            for (const [from, to] of stateRenames)
+                out = out.replace(new RegExp(`\\b${from}\\b`, 'g'), to);
+            return out;
+        };
+        const walkRen = (n) => {
+            const p = n.props;
+            if (p) {
+                for (const k of ['bind', 'show', 'value', 'colorDynamic', 'fontSizeDynamic']) {
+                    if (typeof p[k] === 'string')
+                        p[k] = rn(p[k]);
+                }
+                if (p.onSet && typeof p.onSet === 'object') {
+                    const os = p.onSet;
+                    os.var = rn(os.var);
+                }
+                if (p.fieldOf && typeof p.fieldOf === 'object') {
+                    const f = p.fieldOf;
+                    f.obj = rn(f.obj);
+                }
+                if (Array.isArray(p.bindParts)) {
+                    for (const seg of p.bindParts) {
+                        if (typeof seg.bind === 'string')
+                            seg.bind = rn(seg.bind);
+                        if (seg.fieldOf && typeof seg.fieldOf === 'object') {
+                            const f = seg.fieldOf;
+                            f.obj = rn(f.obj);
+                        }
+                    }
+                }
+                if (n.vfor && n.vfor.listState)
+                    n.vfor.listState = rn(n.vfor.listState);
+            }
+            n.condition = rnCond(n.condition);
+            if (n.active)
+                n.active.when = rnCond(n.active.when);
+            for (const c of n.children ?? [])
+                walkRen(c);
+        };
+        walkRen(ui);
+    }
     // 5) <script setup> 逻辑源码 → 运行时 JS（R12：事件逻辑由原生 JS 引擎执行）
     //    仅支持 JS 子集（无 TS 类型标注、无 import）；超出即编译期警告（后续阶段扩展）
+    for (const w of storeGetterWarnings)
+        if (!warnings.includes(w))
+            warnings.push(w);
     return {
         screen: {
             id: opts.screenId ?? 'vue-screen',
@@ -804,11 +1220,23 @@ function walk(node, classProps, comboRules, scopedRules, pseudoRules, warnings,
         case NodeTypes.COMMENT:
             return [];
         case NodeTypes.INTERPOLATION: {
-            const name = textOf(node.content).trim();
+            const nameRaw = textOf(node.content).trim();
+            // R86：store 访问先拍平（ui.dialog.title → ui_dialog.title）；getter/action 返回哨兵
+            const name = flattenStorePath(normalizeTemplateExpr(nameRaw, warnings));
             // 组件树模式（propRefs 传入=非空）：{{ 任意名 }} → text ref（Swift Text(prop)，
             // prop 名由组件树实际引用自动收集，不强制 defineProps 声明）
-            if (propRefs)
+            if (propRefs) {
+                // R78 续（G13）：组件内 {{ obj.field }} → 组件 prop 是字符串（JSON）→ 运行时取值
+                const cf = name.match(/^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/);
+                if (cf && propRefs.has(cf[1])) {
+                    return [{ type: 'text', props: { fieldOf: { obj: cf[1], field: cf[2] } } }];
+                }
                 return [{ type: 'text', props: { ref: name } }];
+            }
+            if (name.startsWith('\u0000store:')) {
+                warnings.push(`插值 {{ ${name.slice(7)} }} 是 Pinia store 的 getter/action，R86 目前只折叠 state 字段 → 已生成占位文本`);
+                return [{ type: 'text', props: { text: '\u200B' } }];
+            }
             // M2 模板内三元（D1 小范围）：cond ? 'a' : 'b' → Swift 三元字符串表达式（Text(expr)）
             const tri = parseTernaryExpr(name);
             if (tri)
@@ -830,6 +1258,29 @@ function walk(node, classProps, comboRules, scopedRules, pseudoRules, warnings,
                 }
                 throw new VueCompileError(`插值 {{ ${name} }}：未在 <script setup> 中声明为 ref 状态（M1 白名单：仅支持已声明状态）`);
             }
+            // R92 点路径兜底：{{ a.b ?? '默认' }} → fieldOf + fallback
+            {
+                const fbm = name.match(/^@@fb@@([^@]+)@@([\s\S]*)$/);
+                if (fbm) {
+                    // 内部路径可能仍是 store 别名/computed 派生名 → 先拍平
+                    const p2 = matchFieldPath(flattenStorePath(fbm[1]));
+                    if (p2 && (state?.states ?? []).some((st) => st.name === p2.obj)) {
+                        return [{ type: 'text', props: { fieldOf: { obj: p2.obj, field: p2.field, fallback: fbm[2] } } }];
+                    }
+                }
+            }
+            // R78/R85 对象字段插值 {{ obj.field }} / {{ obj.a.b }} / {{ obj.list.length }}：
+            // obj 是页面状态 → 运行时按点路径取值；否则明确警告 + 空文本降级
+            {
+                const fld = matchFieldPath(name);
+                if (fld) {
+                    const isState = (state?.states ?? []).some((st) => st.name === fld.obj);
+                    if (isState)
+                        return [{ type: 'text', props: { fieldOf: { obj: fld.obj, field: fld.field } } }];
+                    warnings.push(`插值 {{ ${name} }} 的对象「${fld.obj}」不是页面状态（如 Pinia store）→ 已生成占位文本；请把该字段提升为 ref（R78/R85）`);
+                    return [{ type: 'text', props: { text: ' ' } }];
+                }
+            }
             throw new VueCompileError(`插值表达式 {{ ${name} }} 暂不支持（M1 仅支持纯状态名；三元/比较表达式 M2 白名单）`);
         }
         case NodeTypes.ELEMENT:
@@ -840,6 +1291,19 @@ function walk(node, classProps, comboRules, scopedRules, pseudoRules, warnings,
     }
 }
 /** M2 模板内三元插值：`cond ? 'a' : 'b'` → Swift 三元字符串表达式；cond 需过 swiftExpr 白名单 */
+/**
+ * R85 成员链匹配：`a.b` / `a.b.c` / `a.list.length`
+ * 返回 { obj: 首段, field: 余下点路径 }；非纯成员链（含调用/下标/运算符）返回 null。
+ */
+function matchFieldPath(name) {
+    if (!/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)+$/.test(name))
+        return null;
+    const segs = name.split('.');
+    // length/size 只允许出现在末段（作为属性读，而非方法调用）
+    if (segs.slice(1, -1).some((s) => s === 'length' || s === 'size'))
+        return null;
+    return { obj: segs[0], field: segs.slice(1).join('.') };
+}
 function parseTernaryExpr(exp) {
     const t = exp.trim();
     const m = t.match(/^(.+?)\s*\?\s*'([^']+)'\s*:\s*'([^']+)'$/);
@@ -850,6 +1314,29 @@ function parseTernaryExpr(exp) {
         return null;
     return `${cond} ? "${m[2]}" : "${m[3]}"`;
 }
+/**
+ * R91 模板表达式归一化（在成员链/状态判定之前统一处理）：
+ *  ① 可选链 `a?.b` → `a.b`（原生端 vrnField 对缺失键返回空串，近似等价；仅提示一次）；
+ *  ② 空值兜底 `a || 'x'` / `a ?? 'x'`（a 为纯状态名）→ `a ? 'x' : 'x'` 交给三元通道。
+ * 其余形态（方法调用、字符串方法、模板字面量）不在此处理，按原逻辑报错。
+ */
+function normalizeTemplateExpr(name, warnings) {
+    let out = name;
+    if (out.includes('?.')) {
+        out = out.replace(/\?\./g, '.');
+        const msg = `模板可选链「${name}」已归一化为「${out}」——原生端字段缺失时返回空串（近似 null 安全，R91）`;
+        if (!warnings.includes(msg))
+            warnings.push(msg);
+    }
+    const fb = out.match(/^([A-Za-z_$][\w$]*)\s*(?:\|\||\?\?)\s*'([^']*)'$/);
+    if (fb)
+        return `${fb[1]} ? '${fb[2]}' : '${fb[1]}'`;
+    // R92 点路径上的兜底：`a.b ?? '默认'` / `a.b.c || '默认'`（原生端 vrnField 带 fallback）
+    const fb2 = out.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)\s*(?:\|\||\?\?)\s*'([^']*)'$/);
+    if (fb2)
+        return `@@fb@@${fb2[1]}@@${fb2[2]}`;
+    return out;
+}
 function textOf(n) {
     return n?.content ?? '';
 }
@@ -1017,6 +1504,22 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
         ], ancestorClasses);
         return { type: 'for', vfor: vf, children: [item] };
     }
+    // R76 Vue 内置容器组件（Transition/KeepAlive/Teleport/Suspense/Fragment）→ 透明展开：
+    // 原生端无过渡动画/缓存语义，但内容必须保留（否则整页编译失败）
+    if (['Transition', 'TransitionGroup', 'KeepAlive', 'Teleport', 'Suspense', 'Fragment'].includes(node.tag)) {
+        const kids = [];
+        for (const child of node.children) {
+            kids.push(...walk(child, classProps, comboRules, scopedRules, pseudoRules, warnings, state, compTable, propRefs, loopScope, ancestorClasses));
+        }
+        if (kids.length === 0) {
+            warnings.push(`<${node.tag}> 内无内容，已忽略`);
+            return { type: 'group', props: { flexDirection: 'column' }, children: [{ type: 'text', props: { text: ' ' } }] };
+        }
+        warnings.push(`<${node.tag}> 已透明展开（原生端无过渡/缓存语义，仅保留内容，R76）`);
+        if (kids.length === 1)
+            return kids[0];
+        return { type: 'group', props: { flexDirection: 'column' }, children: kids };
+    }
     // <template>：逻辑容器（v-if 条件渲染 / 纯透传），不产生 UI 节点
     if (node.tag === 'template') {
         const children = [];
@@ -1142,7 +1645,7 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
                 // @click="handler" → 状态赋值（setter 内联）优先；否则保留 onClick（JS 运行时调用）
                 // M3 规范化：无参调用 `inc()` → `inc`（Swift invoke 统一 evaluateScript("<名>()")）；带参保留原样
                 if (event === 'click' && handler) {
-                    const set = state && resolveSetCall(handler, state);
+                    const set = state && resolveSetCall(handler, state, (m) => warnings.push(m));
                     if (set) {
                         Object.assign(props, { onSet: set });
                     }
@@ -1229,13 +1732,13 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
                 parts.push({ text: child.content });
             }
             else if (child.type === NodeTypes.INTERPOLATION) {
-                const name = textOf(child.content).trim();
+                const name = flattenStorePath(normalizeTemplateExpr(textOf(child.content).trim(), warnings));
                 // 动态列表项属性 {{ item.field }}：基名（dot[0]）命中循环变量才成立
                 const dot = name.split('.');
                 const base = dot[0];
                 const loopVar = loopScope.find((l) => l.itemKey === base || l.indexKey === base);
                 const dyn = loopVar && dot.length === 2 && dot[0] === loopVar.itemKey && /^\w+$/.test(dot[1]);
-                if (!text && !parts.some((p) => 'bind' in p || 'dynField' in p)) {
+                if (!text && !parts.some((p) => 'bind' in p || 'dynField' in p || 'fieldOf' in p)) {
                     // M2 模板内三元（D1 小范围）：cond ? 'a' : 'b' → Swift 三元字符串表达式（Text(expr)）
                     const tri = parseTernaryExpr(name);
                     if (tri) {
@@ -1247,20 +1750,51 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
                         parts.push({ dynField: { var: dot[0], field: dot[1] } });
                         continue;
                     }
+                    if (name.startsWith('\u0000store:')) {
+                        warnings.push(`插值 {{ ${name.slice(7)} }} 是 Pinia store 的 getter/action，R86 目前只折叠 state 字段 → 已生成占位文本`);
+                        parts.push({ text: '\u200B' });
+                        continue;
+                    }
                     // M2：v-for 循环变量（item/index）优先于状态表
                     if (/^\w+$/.test(name)) {
                         // 纯单插值：组件 View 内 → ref（Text(prop)）；循环变量/页面状态 → bind
                         if (propRefs) {
                             refOnly = name;
+                            // 后面可能还有静态文本 → 同步进 parts，否则最终会走 props.text 分支把插值整段丢掉
+                            parts.push({ bind: name });
                         }
                         else if (loopVar || (state && state.states.some((s) => s.name === name))) {
                             refOnly = name;
+                            parts.push({ bind: name });
                         }
                         else {
                             throw new VueCompileError(`插值 {{ ${name} }}：未在 <script setup> 中声明为 ref 状态（M1 白名单：仅支持已声明状态）`);
                         }
                         continue;
                     }
+                    // R92 点路径兜底（元素文本分支）
+                    {
+                        const fbm2 = name.match(/^@@fb@@([^@]+)@@([\s\S]*)$/);
+                        if (fbm2) {
+                            const p3 = matchFieldPath(flattenStorePath(fbm2[1]));
+                            if (p3 && (state?.states ?? []).some((st) => st.name === p3.obj)) {
+                                parts.push({ fieldOf: { obj: p3.obj, field: p3.field, fallback: fbm2[2] } });
+                                continue;
+                            }
+                        }
+                    }
+                    // R78/R85 对象字段插值 {{ obj.field }} / {{ obj.a.b }} / {{ obj.list.length }}（单插值）
+                    const fld2 = matchFieldPath(name);
+                    if (fld2) {
+                        const isState2 = (state?.states ?? []).some((st) => st.name === fld2.obj) || (propRefs?.has(fld2.obj) ?? false);
+                        if (isState2) {
+                            parts.push({ fieldOf: { obj: fld2.obj, field: fld2.field } });
+                            continue;
+                        }
+                        warnings.push(`插值 {{ ${name} }} 的对象「${fld2.obj}」不是页面状态（如 Pinia store）→ 已生成占位文本；请把该字段提升为 ref（R78/R85）`);
+                        parts.push({ text: ' ' });
+                        continue;
+                    }
                     throw new VueCompileError(`插值表达式 {{ ${name} }} 暂不支持（M1 仅支持纯状态名；三元/比较表达式 M2 白名单；动态列表项属性 M4b）`);
                 }
                 // 混合段：静态文本之后的插值
@@ -1270,8 +1804,16 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
                     parts.push({ bind: name });
                 else if (propRefs)
                     parts.push({ bind: name });
-                else
-                    throw new VueCompileError(`混合文本内插值 {{ ${name} }} 暂不支持（仅支持已声明状态 / 循环变量 / 动态列表项属性）`);
+                else {
+                    // R85 混合文本内的成员链插值：`共 {{ board.month.label }} 条` / `{{ board.tags.length }}`
+                    const mp = matchFieldPath(name);
+                    if (mp && (state?.states ?? []).some((st) => st.name === mp.obj)) {
+                        parts.push({ fieldOf: { obj: mp.obj, field: mp.field } });
+                    }
+                    else {
+                        throw new VueCompileError(`混合文本内插值 {{ ${name} }} 暂不支持（仅支持已声明状态 / 循环变量 / 动态列表项属性 / 已声明对象的点路径 R85）`);
+                    }
+                }
             }
             else if (child.type === NodeTypes.COMMENT) {
                 // 忽略注释
@@ -1292,9 +1834,13 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
                 props.bind = refOnly;
             }
         }
-        else if (parts.length > 1 || (parts.length === 1 && ('bind' in parts[0] || 'dynField' in parts[0]))) {
+        else if (parts.length > 1 || (parts.length === 1 && ('bind' in parts[0] || 'dynField' in parts[0] || 'fieldOf' in parts[0]))) {
             props.bindParts = parts;
         }
+        else if (parts.length === 1 && 'text' in parts[0] && !text.trim()) {
+            // 只有占位文本（如不可折叠的 store getter/action）：渲染空文本而不是报错
+            props.text = parts[0].text;
+        }
         else {
             const t = text.trim();
             if (!t) {
@@ -1326,9 +1872,30 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
             children.push(...walk(child, classProps, comboRules, scopedRules, pseudoRules, warnings, state, compTable, propRefs, loopScope, [...ancestorClasses, ...elementClasses]));
         }
     }
-    // group 空 children → 报错（容器必须可收敛；R17 容器叶子约束）
+    // R88 续：容器节点不接受文本专属样式（color/fontSize/fontWeight/textAlign/lineHeight）
+    // 原生端容器没有「字体继承」，这类属性会直接触发 IR 校验拒收 → 明确降级 + 警告
+    if (mapping.type === 'group' || mapping.type === 'for') {
+        const TEXT_ONLY = ['color', 'fontSize', 'fontWeight', 'textAlign', 'lineHeight'];
+        const dropped = TEXT_ONLY.filter((k) => props[k] !== undefined);
+        if (dropped.length > 0) {
+            for (const k of dropped)
+                delete props[k];
+            warnings.push(`<${node.tag}> 是容器，文本样式（${dropped.join('/')}）在原生端不继承 → 已忽略；请把样式下沉到具体文本节点（R88）`);
+        }
+    }
+    // R77 空容器（<div class="spacer" /> 等占位写法）→ 降级为 spacer 占位 + 警告，而不是中断整个编译
     if (mapping.type === 'group' && children.length === 0) {
-        throw new VueCompileError(`<${node.tag}> 无内容（容器节点必须含子节点，R17）`);
+        warnings.push(`<${node.tag}> 无子节点 → 降级为占位 spacer（R17/R77；可用 padding/height 表达留白）`);
+        const keep = {};
+        const src = props;
+        for (const k of ['width', 'height', 'flex', 'marginTop', 'background']) {
+            if (src[k] !== undefined)
+                keep[k] = src[k];
+        }
+        const spacer = { type: 'spacer', props: keep };
+        if (cond)
+            spacer.condition = normCond(cond);
+        return spacer;
     }
     // overflow:auto → scroll 节点（消费中转标记，避免进入 schema 校验白名单）
     const propsAny = props;
@@ -1339,8 +1906,14 @@ function walkElement(node, classProps, comboRules, scopedRules, pseudoRules, war
     const irNode = { type: (nodeType ?? mapping.type), props };
     if (children.length > 0)
         irNode.children = children;
-    if (cond)
-        irNode.condition = normCond(cond);
+    if (cond) {
+        const nc = normCond(cond);
+        // R78 续（G12）：条件里的对象字段（v-if="dialog.title"）→ 标记，由 codegen 映射为「非空判断」
+        const mCond = nc.match(/^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/);
+        const ownerKnown = mCond !== null &&
+            ((state?.states ?? []).some((st) => st.name === mCond[1]) || (propRefs?.has(mCond[1]) ?? false));
+        irNode.condition = ownerKnown && mCond ? `__vrnField__:${mCond[1]}:${mCond[2]}` : nc;
+    }
     if (activeWhen && activeProps) {
         irNode.active = { when: activeWhen, props: activeProps };
         // active 的 color 注入所有后代 text（选中态金色覆盖子元素显式色）