@vitarx/plugin-vite 1.0.4 → 1.0.6

package/dist/passes/hmr/inject-state.js

@@ -5,7 +5,6 @@
  */
 import * as t from '@babel/types';
 import { HMR } from '../../constants/index.js';
-import { collectPatternBindings } from '../../utils/index.js';
 import { GET_COMPONENT_VIEW_ALIAS } from './inject-imports.js';
 /**
  * 创建组件函数体内的 HMR 注册代码
@@ -25,15 +24,13 @@ export function createHMRRegistrationStatements(variableNames) {
     statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view)])));
     // 构建状态对象的 getter 属性，延迟求值避免不必要的计算
     const stateProperties = variableNames.map(name => t.objectMethod('get', t.identifier(name), [], t.blockStatement([t.returnStatement(t.identifier(name))])));
-    // 语句3: __$VITARX_HMR_VIEW_NODE$__ && Promise.resolve().then(() => {
-    //   __$VITARX_HMR_VIEW_NODE$__.__$vitarx_hmr_state$__ = { get 变量名() { return 变量名 } }
-    // })
-    // 异步保存状态到视图节点，确保 DOM 更新完成后再保存
-    statements.push(t.expressionStatement(t.logicalExpression('&&', t.identifier(HMR.view), t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('resolve')), []), t.identifier('then')), [
-        t.arrowFunctionExpression([], t.blockStatement([
-            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(HMR.view), t.identifier(HMR.state)), t.objectExpression(stateProperties)))
-        ]))
-    ]))));
+    // 语句3: __$VITARX_HMR_VIEW_NODE$__ && __$VITARX_HMR$__.instance.trackState(
+    //   __$VITARX_HMR_VIEW_NODE$__,
+    //   { get 变量名() { return 变量名 } }
+    // )
+    // 惰性登记状态 getter：只在热更新时由管理器读取快照写入视图，
+    // 正常「卸载→重挂载」不会写入状态，memo 永远不命中，避免旧状态泄漏
+    statements.push(t.expressionStatement(t.logicalExpression('&&', t.identifier(HMR.view), t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('trackState')), [t.identifier(HMR.view), t.objectExpression(stateProperties)]))));
     return statements;
 }
 /**
@@ -54,105 +51,10 @@ export function createWrappedComponentHMRStatements(componentName) {
     statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view), t.identifier(componentName)])));
     return statements;
 }
-/**
- * 从函数体中收集局部变量名
- * 递归遍历函数体中的所有变量声明，用于状态恢复
- * @param functionBody - 函数体语句块
- * @returns 变量名数组
- */
-export function collectLocalVariableNames(functionBody) {
-    const variableNames = new Set();
-    collectFromBlock(functionBody, variableNames);
-    return Array.from(variableNames);
-}
-/**
- * 从语句块中收集变量名
- * @param block - 语句块节点
- * @param variableNames - 存储变量名的集合
- */
-function collectFromBlock(block, variableNames) {
-    // 遍历语句块中的每个语句
-    for (const stmt of block.body) {
-        collectFromStatement(stmt, variableNames);
-    }
-}
-/**
- * 从单个语句中收集变量名
- * 支持多种语句类型：变量声明、条件语句、循环语句、switch、try-catch 等
- * @param stmt - 语句节点
- * @param variableNames - 存储变量名的集合
- */
-function collectFromStatement(stmt, variableNames) {
-    // 处理变量声明语句：const/let/var
-    if (stmt.type === 'VariableDeclaration') {
-        for (const decl of stmt.declarations) {
-            // 跳过 void 模式（如 void 0）
-            if (decl.id.type !== 'VoidPattern') {
-                collectPatternBindings(decl.id, variableNames);
-            }
-        }
-    }
-    else if (stmt.type === 'IfStatement') {
-        // 递归处理 if 语句的两个分支
-        if (stmt.consequent.type === 'BlockStatement') {
-            collectFromBlock(stmt.consequent, variableNames);
-        }
-        else {
-            collectFromStatement(stmt.consequent, variableNames);
-        }
-        if (stmt.alternate) {
-            if (stmt.alternate.type === 'BlockStatement') {
-                collectFromBlock(stmt.alternate, variableNames);
-            }
-            else {
-                collectFromStatement(stmt.alternate, variableNames);
-            }
-        }
-    }
-    else if (stmt.type === 'ForStatement' || stmt.type === 'WhileStatement' || stmt.type === 'DoWhileStatement') {
-        // 处理 for/while/do-while 循环
-        if (stmt.body.type === 'BlockStatement') {
-            collectFromBlock(stmt.body, variableNames);
-        }
-        else {
-            collectFromStatement(stmt.body, variableNames);
-        }
-    }
-    else if (stmt.type === 'ForInStatement' || stmt.type === 'ForOfStatement') {
-        // 处理 for...in/for...of 循环
-        if (stmt.body.type === 'BlockStatement') {
-            collectFromBlock(stmt.body, variableNames);
-        }
-        else {
-            collectFromStatement(stmt.body, variableNames);
-        }
-    }
-    else if (stmt.type === 'BlockStatement') {
-        // 处理嵌套语句块
-        collectFromBlock(stmt, variableNames);
-    }
-    else if (stmt.type === 'SwitchStatement') {
-        // 处理 switch 语句，遍历所有 case
-        for (const c of stmt.cases) {
-            for (const s of c.consequent) {
-                collectFromStatement(s, variableNames);
-            }
-        }
-    }
-    else if (stmt.type === 'TryStatement') {
-        // 处理 try-catch-finally
-        collectFromBlock(stmt.block, variableNames);
-        if (stmt.handler) {
-            collectFromBlock(stmt.handler.body, variableNames);
-        }
-        if (stmt.finalizer) {
-            collectFromBlock(stmt.finalizer, variableNames);
-        }
-    }
-}
 /**
  * 判断表达式是否为函数类型
- * 函数类型不需要状态恢复（函数定义本身不会改变）
+ * 函数类型不需要状态恢复（函数定义本身不会改变）；且快照读取 getter 会
+ * 拿到函数值，一旦被误调用将执行组件内的业务函数
  * @param expr - 表达式节点
  * @returns 是否为函数类型
  */
@@ -164,48 +66,152 @@ function isFunctionExpression(expr) {
         expr.type === 'ClassExpression' // 类表达式
     );
 }
+/**
+ * 判断是否为 useModel 调用
+ *
+ * useModel 返回的 ModelRef 是父组件状态的双向桥接（派生视图）而非独立
+ * 状态：其内部以 flush:'sync' 的 watch 同步 props→镜像，该 watch 绑定在
+ * 执行时的作用域上。若被 memo 复用，旧 watch 会随旧作用域销毁，表现为
+ * props→镜像同步断裂（v-model 显示残留）。因此每次执行都重建 ModelRef
+ * ——镜像从当前 props 重新初始化，语义正确。
+ * @param expr - 表达式节点
+ * @returns 是否为 useModel 调用
+ */
+function isUseModelCall(expr) {
+    return (!!expr &&
+        expr.type === 'CallExpression' &&
+        expr.callee.type === 'Identifier' &&
+        expr.callee.name === 'useModel');
+}
 /**
  * 创建状态恢复表达式
- * 格式：__$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, '变量名') ?? 原始初始值
- * 如果 memo 方法返回保存的状态则使用，否则使用原始初始值
+ * 格式：__$VITARX_HMR$__.instance.memo(view, '变量名') ?? 原始初始值
  * @param variableName - 变量名
- * @param originalInit - 原始初始化表达式
+ * @param originalInit - 原始初始值表达式
+ * @param raw - 是否绕过响应式门禁（memoRaw）：解构声明的隐藏变量保存的是
+ *   composable 返回的普通对象（内含 Ref 与函数），memo 的门禁会拒收，
+ *   必须走无条件恢复
  * @returns 状态恢复表达式
  */
-function createMemoExpression(variableName, originalInit) {
+function createMemoExpression(variableName, originalInit, raw = false) {
     return t.logicalExpression('??', // 使用空值合并运算符
-    t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('memo')), [t.identifier(HMR.view), t.stringLiteral(variableName)]), originalInit // 原始初始值作为 fallback
+    t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier(raw ? 'memoRaw' : 'memo')), [t.identifier(HMR.view), t.stringLiteral(variableName)]), originalInit // 原始初始值作为 fallback
     );
 }
 /**
- * 为单个变量声明注入状态恢复代码
- * 将 const x = value 转换为 const x = memo(view, 'x') ?? value
- * @param decl - 变量声明节点
- */
-function injectStatePreservationForDeclaration(decl) {
-    // 只处理标识符形式的变量名（跳过解构赋值）
-    if (decl.id.type !== 'Identifier')
-        return;
-    // 跳过没有初始值的声明
-    if (!decl.init)
-        return;
-    // 跳过函数类型的初始值（不需要状态恢复）
-    if (isFunctionExpression(decl.init))
-        return;
-    // 替换初始值为状态恢复表达式
-    decl.init = createMemoExpression(decl.id.name, decl.init);
-}
-/**
- * 为函数体内的变量声明注入状态恢复代码
- * 遍历函数体中的所有变量声明语句
+ * 为函数体注入状态恢复代码并收集需要登记（trackState）的变量名
+ *
+ * 处理规则：
+ * - 标识符声明（非函数初始值）：初始值包装为 memo(view, '变量名') ?? 原始初始值
+ * - useModel 调用：豁免（桥接状态每次重建，见 isUseModelCall）
+ * - 解构声明（如 `const { a } = useFoo()`）：拆分为隐藏变量整包 memo +
+ *   原声明解构隐藏变量——composable 返回的状态对象得以跨重执行保留，
+ *   其内部创建的响应式状态与已挂载的副作用保持一致
+ * - 函数类型初始值 / 无初始值：不注入
+ * - for 循环头部声明：循环局部绑定，不注入（仅递归循环体）
+ *
+ * 单趟完成注入与收集，返回按执行顺序排列的登记名列表（标识符名 +
+ * 隐藏变量名），供 trackState 生成 getter。隐藏变量采用用户标识符不可能
+ * 命中的 `__$VITARX_D<N>$__` 命名，按组件函数内确定性计数。
  * @param functionBody - 函数体语句块
+ * @returns 需要状态登记的变量名数组
  */
 export function injectStatePreservation(functionBody) {
-    for (const stmt of functionBody.body) {
+    const trackedNames = [];
+    let destructureCounter = 0;
+    processBlock(functionBody);
+    return trackedNames;
+    /** 处理语句块：注入可能把一条声明拆成多条，需重建语句数组 */
+    function processBlock(block) {
+        const newBody = [];
+        for (const stmt of block.body) {
+            newBody.push(...processStatement(stmt));
+        }
+        block.body = newBody;
+    }
+    /** 处理单条语句，返回替换它的语句列表（1~n 条） */
+    function processStatement(stmt) {
         if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-                injectStatePreservationForDeclaration(decl);
+            return processVariableDeclaration(stmt);
+        }
+        if (stmt.type === 'IfStatement') {
+            stmt.consequent = wrapBody(stmt.consequent);
+            if (stmt.alternate)
+                stmt.alternate = wrapBody(stmt.alternate);
+        }
+        else if (stmt.type === 'ForStatement' ||
+            stmt.type === 'WhileStatement' ||
+            stmt.type === 'DoWhileStatement') {
+            // for 头部声明是循环局部绑定不注入；仅递归循环体
+            stmt.body = wrapBody(stmt.body);
+        }
+        else if (stmt.type === 'ForInStatement' || stmt.type === 'ForOfStatement') {
+            // 同上：for-of/for-in 的 left 绑定按迭代取值，不做状态保留
+            stmt.body = wrapBody(stmt.body);
+        }
+        else if (stmt.type === 'BlockStatement') {
+            processBlock(stmt);
+        }
+        else if (stmt.type === 'SwitchStatement') {
+            for (const switchCase of stmt.cases) {
+                switchCase.consequent = processStatementList(switchCase.consequent);
+            }
+        }
+        else if (stmt.type === 'TryStatement') {
+            processBlock(stmt.block);
+            if (stmt.handler)
+                processBlock(stmt.handler.body);
+            if (stmt.finalizer)
+                processBlock(stmt.finalizer);
+        }
+        return [stmt];
+    }
+    function processStatementList(list) {
+        const results = [];
+        for (const stmt of list) {
+            results.push(...processStatement(stmt));
+        }
+        return results;
+    }
+    /** 语句体若因注入产生多条语句，需要块化包装保持语法合法 */
+    function wrapBody(body) {
+        if (body.type === 'BlockStatement') {
+            processBlock(body);
+            return body;
+        }
+        const results = processStatement(body);
+        return results.length === 1 ? results[0] : t.blockStatement(results);
+    }
+    /** 逐 declarator 处理变量声明（多 declarator 时拆分为多条声明） */
+    function processVariableDeclaration(stmt) {
+        const results = [];
+        for (const decl of stmt.declarations) {
+            const init = decl.init ?? null;
+            // 无初始值 / VoidPattern / 函数初始值：原样保留
+            if (decl.id.type === 'VoidPattern' || !init || isFunctionExpression(init)) {
+                results.push(t.variableDeclaration(stmt.kind, [decl]));
+                continue;
+            }
+            if (decl.id.type === 'Identifier') {
+                if (isUseModelCall(init)) {
+                    // 桥接状态豁免：不 memo、不登记（见 isUseModelCall 注释）
+                    results.push(t.variableDeclaration(stmt.kind, [decl]));
+                    continue;
+                }
+                trackedNames.push(decl.id.name);
+                decl.init = createMemoExpression(decl.id.name, init);
+                results.push(t.variableDeclaration(stmt.kind, [decl]));
+                continue;
             }
+            // 解构声明：隐藏变量整包 memo（raw 恢复）+ 原声明解构隐藏变量
+            const hiddenName = `__$VITARX_D${destructureCounter++}$__`;
+            trackedNames.push(hiddenName);
+            results.push(t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier(hiddenName), createMemoExpression(hiddenName, init, true))
+            ]), t.variableDeclaration(stmt.kind, [
+                t.variableDeclarator(decl.id, t.identifier(hiddenName))
+            ]));
         }
+        return results;
     }
 }

package/dist/passes/hmr/inject.d.ts

@@ -13,3 +13,13 @@ import type { ComponentInfo } from '../../utils/index.js';
  * @param filename - 文件名（用于生成组件唯一 ID）
  */
 export declare function injectHMRSupport(program: t.Program, components: ComponentInfo[], filename: string): void;
+/**
+ * 为「导入转发组件默认导出」的模块注入 accept-only HMR 支持
+ *
+ * 典型场景：文件路由的 _layout 转发文件（export default AdminLayout）。
+ * 模块本身不含组件函数定义，无需 bindId 与函数体注入（函数体属于
+ * 源模块，其自身已有完整 HMR）；仅需自接受模块更新并把新导出交给
+ * HMRManager.update 按组件 id 热替换。
+ * @param program - AST Program 节点
+ */
+export declare function injectHMRAcceptOnly(program: t.Program): void;

package/dist/passes/hmr/inject.js

@@ -6,15 +6,14 @@
 import * as t from '@babel/types';
 import { HMR } from '../../constants/index.js';
 import { injectHMRImport, injectGetComponentViewImport } from './inject-imports.js';
-import { createHMRRegistrationStatements, createWrappedComponentHMRStatements, collectLocalVariableNames, injectStatePreservation } from './inject-state.js';
+import { createHMRRegistrationStatements, createWrappedComponentHMRStatements, injectStatePreservation } from './inject-state.js';
 /**
  * 为组件函数注入 HMR 注册代码
  * @param func - 函数声明/表达式/箭头函数
- * @param variableNames - 需要追踪的变量名列表
  * @param isWrapped - 是否为包装组件（defineComponent/builder）
  * @param componentName - 组件名称（包装组件需要）
  */
-function injectHMRIntoFunction(func, variableNames, isWrapped = false, componentName) {
+function injectHMRIntoFunction(func, isWrapped = false, componentName) {
     // 如果是箭头函数且函数体不是块语句（单行箭头函数），转换为块语句
     if (func.type === 'ArrowFunctionExpression' && func.body.type !== 'BlockStatement') {
         const returnStmt = t.returnStatement(func.body);
@@ -23,10 +22,8 @@ function injectHMRIntoFunction(func, variableNames, isWrapped = false, component
     // 确保函数体是块语句
     if (!func.body || func.body.type !== 'BlockStatement')
         return;
-    // 非包装组件需要注入状态恢复代码
-    if (!isWrapped) {
-        injectStatePreservation(func.body);
-    }
+    // 非包装组件：注入状态恢复代码并收集登记名（单趟完成）
+    const variableNames = isWrapped ? [] : injectStatePreservation(func.body);
     // 根据组件类型创建对应的 HMR 注册语句
     const statements = isWrapped
         ? createWrappedComponentHMRStatements(componentName)
@@ -58,6 +55,35 @@ function createHotAcceptStatement() {
         ]))
     ]));
 }
+/**
+ * 创建导入转发模块的 hot.accept 语句（带 invalidate 兜底）
+ *
+ * 生成：import.meta.hot.accept(mod => {
+ *   if (!__$VITARX_HMR$__.instance.update(mod)) {
+ *     import.meta.hot.invalidate('[VitarxHMR]: ...')
+ *   }
+ * })
+ *
+ * 转发模块本身不含组件定义，update 的返回值表示新模块导出中是否
+ * 含已绑定 HMR id 的组件——为 false 说明转发目标不可识别（如换成
+ * 未转换模块的组件），必须 invalidate 整页刷新，避免界面静默 stale。
+ *
+ * 已知边界：转发目标在两个均有 HMR id 的组件间切换（export default A
+ * 改为 export default B）时，update 只登记 B 的 id 并返回 true，不会
+ * invalidate，挂在旧 id A 名下的视图不会被更新——文件路由场景由
+ * vitarx-router 虚拟路由模块自身的 hot accept 重建路由树兜底；非路由
+ * 场景需手动刷新。此为接受的降级路径，不做运行时检测。
+ * @returns hot.accept 调用语句
+ */
+function createForwardingHotAcceptStatement() {
+    return t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier('import'), t.identifier('meta')), t.identifier('hot')), t.identifier('accept')), [
+        t.arrowFunctionExpression([t.identifier('mod')], t.blockStatement([
+            t.ifStatement(t.unaryExpression('!', t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('update')), [t.identifier('mod')])), t.blockStatement([
+                t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier('import'), t.identifier('meta')), t.identifier('hot')), t.identifier('invalidate')), [t.stringLiteral('[VitarxHMR]: 转发的默认导出不是可热更新的组件，回退整页刷新')]))
+            ]))
+        ]))
+    ]));
+}
 /**
  * 生成组件唯一 ID（文件路径 + 组件名称）
  * 使用 FNV-1a 哈希算法生成短哈希值
@@ -92,9 +118,7 @@ export function injectHMRSupport(program, components, filename) {
     injectGetComponentViewImport(program);
     // 步骤2: 为每个组件函数注入 HMR 注册代码和状态恢复
     for (const { node, isWrapped, name } of components) {
-        // 收集函数体内的局部变量名（用于状态保存）
-        const variableNames = node.body?.type === 'BlockStatement' ? collectLocalVariableNames(node.body) : [];
-        injectHMRIntoFunction(node, variableNames, isWrapped, name);
+        injectHMRIntoFunction(node, isWrapped, name);
     }
     // 步骤3: 为每个组件创建 bindId 语句（用于热更新时识别）
     for (const { name } of components) {
@@ -103,3 +127,16 @@ export function injectHMRSupport(program, components, filename) {
     // 步骤4: 创建 import.meta.hot.accept 语句（监听热更新事件）
     program.body.push(createHotAcceptStatement());
 }
+/**
+ * 为「导入转发组件默认导出」的模块注入 accept-only HMR 支持
+ *
+ * 典型场景：文件路由的 _layout 转发文件（export default AdminLayout）。
+ * 模块本身不含组件函数定义，无需 bindId 与函数体注入（函数体属于
+ * 源模块，其自身已有完整 HMR）；仅需自接受模块更新并把新导出交给
+ * HMRManager.update 按组件 id 热替换。
+ * @param program - AST Program 节点
+ */
+export function injectHMRAcceptOnly(program) {
+    injectHMRImport(program);
+    program.body.push(createForwardingHotAcceptStatement());
+}

package/dist/passes/imports/collectRefVariables.d.ts

@@ -23,6 +23,7 @@ export declare function collectRefVariables(program: t.Program, refApiAliases: R
 /**
  * 收集确定不是 ref 的变量
  * 包括函数声明、箭头函数和函数表达式变量（这些不可能是 ref）
+ * 静态分析能明确变量类型时，跳过 unref 包装以提升性能
  * @param program - AST Program 节点
  * @returns 非 ref 变量名集合
  */

package/dist/passes/imports/collectRefVariables.js

@@ -1,5 +1,5 @@
 import { REF_APIS, RESPONSIVE_MODULES } from '../../constants/index.js';
-import { collectPatternBindings, collectObjectPatternBindings } from '../../utils/index.js';
+import { collectObjectPatternBindings, collectPatternBindings } from '../../utils/index.js';
 /**
  * 收集 ref API 的别名
  * 识别从 vitarx 或 @vitarx/responsive 导入的 ref/toRef/toRefs/shallowRef/computed
@@ -76,6 +76,15 @@ function collectRefVariablesFromNode(node, refVariables, refApiLocalNames, toRef
             if (decl.id.type === 'VoidPattern')
                 continue;
             const init = decl.init;
+            // 如果 init 是箭头函数或函数表达式，递归处理其函数体内的 ref 声明
+            // 确保组件函数（如 const App = () => { const count = ref(0) }）内的 ref 被正确收集
+            if ((init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') &&
+                init.body.type === 'BlockStatement') {
+                for (const stmt of init.body.body) {
+                    collectRefVariablesFromNode(stmt, refVariables, refApiLocalNames, toRefsLocalNames);
+                }
+                continue;
+            }
             // 检查是否为函数调用表达式
             if (init.type !== 'CallExpression' || init.callee.type !== 'Identifier') {
                 continue;
@@ -102,24 +111,32 @@ function collectRefVariablesFromNode(node, refVariables, refApiLocalNames, toRef
         collectRefVariablesFromNode(node.declaration, refVariables, refApiLocalNames, toRefsLocalNames);
     }
     else if (node.type === 'ExportDefaultDeclaration') {
-        // 处理默认导出
+        // 处理默认导出（支持函数声明、箭头函数、函数表达式）
         const decl = node.declaration;
         if (decl.type === 'FunctionDeclaration' && decl.body) {
             for (const stmt of decl.body.body) {
                 collectRefVariablesFromNode(stmt, refVariables, refApiLocalNames, toRefsLocalNames);
             }
         }
+        else if ((decl.type === 'ArrowFunctionExpression' || decl.type === 'FunctionExpression') &&
+            decl.body.type === 'BlockStatement') {
+            for (const stmt of decl.body.body) {
+                collectRefVariablesFromNode(stmt, refVariables, refApiLocalNames, toRefsLocalNames);
+            }
+        }
     }
+    // 控制流语句（if/for/while/switch/try）中的变量声明不递归收集
+    // 函数控制流中通常不会声明 ref 变量，仅收集模块顶层和函数体顶层
 }
 /**
  * 收集确定不是 ref 的变量
  * 包括函数声明、箭头函数和函数表达式变量（这些不可能是 ref）
+ * 静态分析能明确变量类型时，跳过 unref 包装以提升性能
  * @param program - AST Program 节点
  * @returns 非 ref 变量名集合
  */
 export function collectNonRefVariables(program) {
     const nonRefVariables = new Set();
-    // 遍历程序体中的所有节点
     for (const node of program.body) {
         collectNonRefFromNode(node, nonRefVariables);
     }
@@ -127,6 +144,7 @@ export function collectNonRefVariables(program) {
 }
 /**
  * 从节点中递归收集非 ref 变量
+ * 仅处理模块顶层和函数体顶层的声明，不递归控制流语句
  * @param node - AST 节点
  * @param nonRefVariables - 存储非 ref 变量名的集合
  */
@@ -134,7 +152,6 @@ function collectNonRefFromNode(node, nonRefVariables) {
     // 函数声明一定不是 ref
     if (node.type === 'FunctionDeclaration' && node.id) {
         nonRefVariables.add(node.id.name);
-        // 递归处理函数体内的变量
         if (node.body) {
             for (const stmt of node.body.body) {
                 collectNonRefFromNode(stmt, nonRefVariables);
@@ -142,33 +159,49 @@ function collectNonRefFromNode(node, nonRefVariables) {
         }
     }
     else if (node.type === 'VariableDeclaration') {
-        // 变量声明：只有箭头函数或函数表达式才是非 ref
+        // 变量声明：箭头函数或函数表达式赋值一定不是 ref
         for (const decl of node.declarations) {
             if (!decl.init)
                 continue;
-            // 只处理简单标识符（不处理解构）
-            if (decl.id.type !== 'Identifier')
-                continue;
             const init = decl.init;
-            if (init.type === 'ArrowFunctionExpression' ||
-                init.type === 'FunctionExpression') {
-                nonRefVariables.add(decl.id.name);
+            if (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') {
+                if (decl.id.type === 'Identifier') {
+                    nonRefVariables.add(decl.id.name);
+                }
+                // 递归处理函数体内的变量声明
+                if (init.body.type === 'BlockStatement') {
+                    for (const stmt of init.body.body) {
+                        collectNonRefFromNode(stmt, nonRefVariables);
+                    }
+                }
             }
         }
     }
-    else if (node.type === 'ExportNamedDeclaration') {
-        // 处理命名导出的声明
-        if (node.declaration) {
-            collectNonRefFromNode(node.declaration, nonRefVariables);
-        }
+    else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+        collectNonRefFromNode(node.declaration, nonRefVariables);
     }
     else if (node.type === 'ExportDefaultDeclaration') {
-        // 处理默认导出
         const decl = node.declaration;
-        if (decl.type === 'FunctionDeclaration' && decl.id) {
-            nonRefVariables.add(decl.id.name);
+        if (decl.type === 'FunctionDeclaration') {
+            if (decl.id) {
+                nonRefVariables.add(decl.id.name);
+            }
+            // 递归处理函数体，收集内部非 ref 变量（与 collectRefVariablesFromNode 一致）
+            if (decl.body) {
+                for (const stmt of decl.body.body) {
+                    collectNonRefFromNode(stmt, nonRefVariables);
+                }
+            }
+        }
+        else if ((decl.type === 'ArrowFunctionExpression' || decl.type === 'FunctionExpression') &&
+            decl.body.type === 'BlockStatement') {
+            // 处理未被转换的箭头函数/函数表达式默认导出
+            for (const stmt of decl.body.body) {
+                collectNonRefFromNode(stmt, nonRefVariables);
+            }
         }
     }
+    // 控制流语句（if/for/while/switch/try）中的变量声明不递归收集
 }
 /**
  * 构建 ref API 的本地名称集合

package/dist/passes/index.d.ts

@@ -7,4 +7,4 @@ export { processPureCompileComponent, processSwitch, processIfBlock } from './co
 export { processVIfChain, processDirectives } from './directives/index.js';
 export { processChildren, processJSXElement, transformJSXElement, processJSXFragment } from './jsx/index.js';
 export { processProps, type PropsResult } from './props/index.js';
-export { injectHMRSupport } from './hmr/index.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './hmr/index.js';

package/dist/passes/index.js

@@ -13,4 +13,4 @@ export { processChildren, processJSXElement, transformJSXElement, processJSXFrag
 // Props 处理
 export { processProps } from './props/index.js';
 // HMR 注入
-export { injectHMRSupport } from './hmr/index.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './hmr/index.js';

package/dist/passes/jsx/processJSXFragment.js

@@ -1,7 +1,24 @@
 import * as t from '@babel/types';
+import { isJSXElement } from '@babel/types';
 import { markImport } from '../../context.js';
-import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, validateNoDirectMatchChild } from '../../utils/index.js';
+import { createError } from '../../error.js';
+import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, getJSXElementName } from '../../utils/index.js';
 import { processChildren } from './processChildren.js';
+/**
+ * 校验子节点中不能直接包含 Match 组件
+ * Match 必须在 Switch 内使用，非 Switch 元素的子节点中不允许出现 Match
+ * @param children - 子节点数组
+ */
+function validateNoDirectMatchChild(children) {
+    for (const child of children) {
+        if (isJSXElement(child)) {
+            const childName = getJSXElementName(child);
+            if (childName === 'Match') {
+                throw createError('E012', child);
+            }
+        }
+    }
+}
 /**
  * 处理 JSX Fragment
  * @param path - JSX Fragment 路径

package/dist/passes/props/attribute.d.ts

@@ -32,6 +32,9 @@ export declare function getAttributeValue(value: t.JSXAttribute['value']): t.Exp
  *
  * 特殊处理：
  * - children 属性不使用 unref，因为 ref 作为 children 是合法的可变渲染源
+ * - ref 属性不使用 unref/.value，因为 ref 绑定需要 ref 对象本身
+ *   运行时 resolveProps() 通过 isRef() 判定 ref 属性值，若此处解包，
+ *   popProperty 取到的是解包后的值（如 null），isRef 判定失败导致绑定失效
  * - 其他标识符属性使用 unref 解包
  *
  * @param key - 属性名