@vitarx/plugin-vite 1.0.5 → 1.0.6

package/dist/constants/index.d.ts

@@ -1,12 +1,3 @@
-/**
- * Vitarx 运行时 API 名称
- * 这些 API 需要从 vitarx 包导入
- */
-/**
- * UI 相关的 API 名称列表
- * 这些 API 用于创建视图，在 HMR 时需要识别
- */
-export declare const UI_API_NAMES: readonly ["createView", "branch", "dynamic", "expr", "accessor", "withDirectives"];
 /**
  * Ref 相关 API 名称
  * 用于识别 ref 变量

package/dist/constants/index.js

@@ -1,12 +1,3 @@
-/**
- * Vitarx 运行时 API 名称
- * 这些 API 需要从 vitarx 包导入
- */
-/**
- * UI 相关的 API 名称列表
- * 这些 API 用于创建视图，在 HMR 时需要识别
- */
-export const UI_API_NAMES = ['createView', 'branch', 'dynamic', 'expr', 'accessor', 'withDirectives'];
 /**
  * Ref 相关 API 名称
  * 用于识别 ref 变量

package/dist/hmr-client/index.d.ts

@@ -46,6 +46,17 @@ export default class HMRManager {
      * const state = __$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, 'state') ?? ref(0)
      */
     memo(view: ComponentView, name: string): any;
+    /**
+     * 无条件恢复状态（不做 Ref/reactive 门禁）
+     *
+     * 供解构声明的隐藏变量使用：composable 返回的控制器是普通对象
+     * （内含 Ref 与函数），memo 的响应式门禁会将其拒收导致恢复永远
+     * 落空。仅限转换器为解构声明生成的代码调用。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {string} name - 变量名称
+     */
+    memoRaw(view: ComponentView, name: string): any;
     /**
      * 注册节点
      *
@@ -59,10 +70,25 @@ export default class HMRManager {
      * @param component - 组件构造函数
      */
     getId(component: Component): string;
+    /**
+     * 登记视图状态 getter
+     *
+     * 由转换器注入的代码在组件函数每次执行时调用，登记当前作用域的
+     * 惰性状态读取器（同一视图重复登记覆盖旧的）。读取动作延迟到
+     * 热更新快照时发生，正常挂载/重挂载不会产生任何状态残留。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {Record<string, () => any>} getters - 变量名到读取器的映射
+     */
+    trackState(view: ComponentView, getters: Record<string, () => any>): void;
     /**
      * 模块更新
      *
      * @param newModule - 新模块对象
+     * @returns 模块导出中是否包含至少一个已绑定 HMR id 的组件。
+     *          供导入转发模块的 accept 回调判断兜底：转发目标若不含
+     *          可识别组件（如换成未转换模块的组件），调用方应
+     *          invalidate 触发整页刷新，避免界面静默 stale。
      */
-    update(newModule: ModuleNamespace): void;
+    update(newModule: ModuleNamespace): boolean;
 }

package/dist/hmr-client/index.js

@@ -3,10 +3,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _HMRManager_idMapToView, _HMRManager_idMapToComponent;
+var _HMRManager_instances, _HMRManager_idMapToView, _HMRManager_idMapToComponent, _HMRManager_viewStateGetters, _HMRManager_snapshotState;
 import { isComponent, isReactive, isRef } from 'vitarx';
 import { HMR } from '../constants/index.js';
 import { processUpdate } from './update.js';
+import { collectLiveViews, registerViewRef } from './weak-refs.js';
 /**
  * HMR管理器
  *
@@ -14,10 +15,18 @@ import { processUpdate } from './update.js';
  */
 class HMRManager {
     constructor() {
+        _HMRManager_instances.add(this);
         /**
          * id模块映射到组件虚拟节点集合
          *
-         * 模块id -> 组件虚拟节点
+         * 模块id -> 组件虚拟节点（WeakRef 弱引用）
+         *
+         * 为什么用 WeakRef：register 在组件每次执行时都会调用，若用强引用，
+         * 已销毁的视图（弹窗关闭、路由切换）会被本 Map 永久钉住造成内存泄漏。
+         * WeakRef 借助 GC 可达性天然区分「Freeze 停用」与「真销毁」——
+         * Freeze 缓存持有视图强引用，停用中的视图不会被回收，热更新照常处理；
+         * 真销毁的视图无引用可回收，deref() 返回空，遍历时剪枝。
+         * 剪枝时机为 register/update 遍历（dev 下高频），泄漏上限极小。
          */
         _HMRManager_idMapToView.set(this, new Map()
         /**
@@ -28,6 +37,20 @@ class HMRManager {
          * id映射到组件构造函数
          */
         _HMRManager_idMapToComponent.set(this, new Map()
+        /**
+         * 视图状态 getter 登记表
+         *
+         * 组件函数每次执行时通过 trackState 登记当前作用域状态的惰性读取器，
+         * 热更新时读取一次生成快照；视图销毁/重挂载不会保留，避免旧状态泄漏。
+         */
+        );
+        /**
+         * 视图状态 getter 登记表
+         *
+         * 组件函数每次执行时通过 trackState 登记当前作用域状态的惰性读取器，
+         * 热更新时读取一次生成快照；视图销毁/重挂载不会保留，避免旧状态泄漏。
+         */
+        _HMRManager_viewStateGetters.set(this, new WeakMap()
         /**
          * 获取单实例
          */
@@ -81,6 +104,21 @@ class HMRManager {
             return undefined;
         return state;
     }
+    /**
+     * 无条件恢复状态（不做 Ref/reactive 门禁）
+     *
+     * 供解构声明的隐藏变量使用：composable 返回的控制器是普通对象
+     * （内含 Ref 与函数），memo 的响应式门禁会将其拒收导致恢复永远
+     * 落空。仅限转换器为解构声明生成的代码调用。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {string} name - 变量名称
+     */
+    memoRaw(view, name) {
+        if (!view)
+            return undefined;
+        return view[HMR.state]?.[name];
+    }
     /**
      * 注册节点
      *
@@ -92,11 +130,12 @@ class HMRManager {
             return;
         component ?? (component = view.component);
         const id = this.getId(component);
-        if (__classPrivateFieldGet(this, _HMRManager_idMapToView, "f").has(id)) {
-            __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id).add(view);
+        const refs = __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id);
+        if (refs) {
+            registerViewRef(refs, view);
         }
         else {
-            __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").set(id, new Set([view]));
+            __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").set(id, new Set([new WeakRef(view)]));
         }
     }
     /**
@@ -107,14 +146,33 @@ class HMRManager {
     getId(component) {
         return Reflect.get(component, HMR.id);
     }
+    /**
+     * 登记视图状态 getter
+     *
+     * 由转换器注入的代码在组件函数每次执行时调用，登记当前作用域的
+     * 惰性状态读取器（同一视图重复登记覆盖旧的）。读取动作延迟到
+     * 热更新快照时发生，正常挂载/重挂载不会产生任何状态残留。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {Record<string, () => any>} getters - 变量名到读取器的映射
+     */
+    trackState(view, getters) {
+        if (!view)
+            return;
+        __classPrivateFieldGet(this, _HMRManager_viewStateGetters, "f").set(view, getters);
+    }
     /**
      * 模块更新
      *
      * @param newModule - 新模块对象
+     * @returns 模块导出中是否包含至少一个已绑定 HMR id 的组件。
+     *          供导入转发模块的 accept 回调判断兜底：转发目标若不含
+     *          可识别组件（如换成未转换模块的组件），调用方应
+     *          invalidate 触发整页刷新，避免界面静默 stale。
      */
     update(newModule) {
         if (!newModule)
-            return;
+            return false;
         try {
             const components = [];
             const updatedView = new Set();
@@ -135,23 +193,39 @@ class HMRManager {
             for (const component of components) {
                 const id = this.getId(component);
                 // 模块活跃的虚拟节点集合
-                const views = __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id);
-                if (!views)
+                const refs = __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id);
+                if (!refs)
+                    continue;
+                // 收集存活视图（死引用已剪枝），遍历使其更新
+                const views = collectLiveViews(refs);
+                // 集合清空则移除 Map 条目，避免空壳残留长期积累
+                if (refs.size === 0) {
+                    __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").delete(id);
                     continue;
-                // 遍历关联的所有视图，使其更新
+                }
                 for (const view of views) {
                     // 跳过已更新过的视图，避免同一次更新中同一个视图被更新多次
                     if (updatedView.has(view))
                         continue;
                     // 仅在视图是活跃状态，且已挂载时才更新
                     if (view.isActive && view.isMounted) {
-                        // 处理视图更新
-                        processUpdate(view, this.resolveComponent(view.component));
+                        // 重执行前快照当前状态，使组件函数重执行时 memo 命中、保留状态
+                        __classPrivateFieldGet(this, _HMRManager_instances, "m", _HMRManager_snapshotState).call(this, view);
+                        try {
+                            // 处理视图更新
+                            processUpdate(view, this.resolveComponent(view.component));
+                        }
+                        finally {
+                            // 快照仅服务于本次热更新，用完即清——
+                            // 保证后续正常的「卸载→重挂载」拿到全新状态，与生产行为一致
+                            delete view[HMR.state];
+                        }
                         // 标记视图已更新
                         updatedView.add(view);
                     }
                 }
             }
+            return components.length > 0;
         }
         catch (e) {
             if (import.meta.hot) {
@@ -161,7 +235,29 @@ class HMRManager {
                 throw e;
             }
         }
+        return false;
     }
 }
-_HMRManager_idMapToView = new WeakMap(), _HMRManager_idMapToComponent = new WeakMap();
+_HMRManager_idMapToView = new WeakMap(), _HMRManager_idMapToComponent = new WeakMap(), _HMRManager_viewStateGetters = new WeakMap(), _HMRManager_instances = new WeakSet(), _HMRManager_snapshotState = function _HMRManager_snapshotState(view) {
+    const getters = __classPrivateFieldGet(this, _HMRManager_viewStateGetters, "f").get(view);
+    if (!getters)
+        return;
+    const snapshot = {};
+    for (const name in getters) {
+        try {
+            // 注意：getters 是 getter 属性对象——读取属性即执行 getter 并返回值，
+            // 不能再加调用括号（否则会把返回值当函数调用，全部抛 TypeError）
+            const value = getters[name];
+            // 防御：函数值（旧编译产物仍可能登记函数变量）不进入快照，
+            // 绝不调用组件内的业务函数
+            if (typeof value === 'function')
+                continue;
+            snapshot[name] = value;
+        }
+        catch {
+            // 单个变量读取失败（如暂时性死区）不影响其余状态恢复
+        }
+    }
+    view[HMR.state] = snapshot;
+};
 export default HMRManager;

package/dist/hmr-client/update.d.ts

@@ -1,7 +1,16 @@
+/**
+ * HMR 组件更新：统一「卸载 → 重建 → 挂载」语义
+ *
+ * 任何代码变更（含纯 UI/注释）都走完整重挂载：dispose 触发旧实例的
+ * onDispose/onScopeDispose 清理副作用，init 重执行组件函数（状态经
+ * memo/快照协议保留），mount 触发 onMounted——dev 与生产的生命周期
+ * 语义完全一致，不区分 logic/非 logic 分叉，不存在钩子滞留或孤儿监听。
+ * @module hmr-client/update
+ */
 import { Component, ComponentView } from 'vitarx';
 /**
- * 处理组件更新函数
+ * 处理组件更新：卸载旧实例 → 重建（重执行组件函数，状态经快照恢复）→ 挂载
  * @param view - 组件视图对象，包含当前组件的实例和节点信息
- * @param newComponent - 新的组件定义，用于替换现有组件
+ * @param newComponent - 新的组件定义
  */
 export declare function processUpdate(view: ComponentView, newComponent: Component): void;

package/dist/hmr-client/update.js

@@ -1,72 +1,38 @@
-import { createCommentView, EffectScope, getRenderer, runComponent } from 'vitarx';
-import { diffComponentChange } from './utils.js';
 /**
- * 处理组件更新函数
+ * HMR 组件更新：统一「卸载 → 重建 → 挂载」语义
+ *
+ * 任何代码变更（含纯 UI/注释）都走完整重挂载：dispose 触发旧实例的
+ * onDispose/onScopeDispose 清理副作用，init 重执行组件函数（状态经
+ * memo/快照协议保留），mount 触发 onMounted——dev 与生产的生命周期
+ * 语义完全一致，不区分 logic/非 logic 分叉，不存在钩子滞留或孤儿监听。
+ * @module hmr-client/update
+ */
+import { getRenderer } from 'vitarx';
+/**
+ * 处理组件更新：卸载旧实例 → 重建（重执行组件函数，状态经快照恢复）→ 挂载
  * @param view - 组件视图对象，包含当前组件的实例和节点信息
- * @param newComponent - 新的组件定义，用于替换现有组件
+ * @param newComponent - 新的组件定义
  */
 export function processUpdate(view, newComponent) {
-    // 获取渲染器实例
+    // 获取渲染器实例，创建占位注释节点并插入到旧元素位置，
+    // 作为新旧子树替换的锚点
     const renderer = getRenderer();
-    // 创建一个占位符注释节点
     const placeholder = renderer.createComment('');
-    // 获取旧组件的DOM元素
-    const oldElement = view.node;
-    // 将占位符插入到旧元素的位置
-    renderer.insert(placeholder, oldElement);
-    // 获取组件实例
-    const instance = view.instance;
-    // 比较新旧组件的差异，检查逻辑是否有变化
-    const { logic } = diffComponentChange(view.component.toString(), newComponent.toString());
-    // 更新视图中的组件引用
+    renderer.insert(placeholder, view.node);
+    // 更新视图中的组件引用为最新模块导出
     Object.defineProperty(view, 'component', {
         value: newComponent,
         writable: true,
         enumerable: true,
         configurable: true
     });
-    // 如果逻辑有变化，则完全重新挂载组件
-    if (logic) {
-        const ctx = view.ctx;
-        view.dispose();
-        view.init(ctx);
-        view.mount(placeholder, 'replace');
-        return;
-    }
-    // 销毁旧作用域
-    instance.scope.dispose();
-    // 重新创建新的作用域
-    const scope = new EffectScope({
-        name: view.name,
-        errorHandler: (error, source) => {
-            instance.reportError(error, `effect:${source}`);
-        }
-    });
-    Object.defineProperty(instance, 'scope', {
-        value: scope,
-        writable: true,
-        enumerable: true,
-        configurable: true
-    });
-    // 销毁旧的子树
-    instance.subView.dispose();
-    // 创建新的子树
-    let subView;
-    try {
-        subView = runComponent(instance, () => newComponent(view.props));
-    }
-    catch (e) {
-        instance.reportError(e, 'component:run');
-        subView = createCommentView(`Component<${view.name}>:failed`);
-    }
-    Object.defineProperty(instance, 'subView', {
-        value: instance['normalizeView'](subView),
-        writable: true,
-        enumerable: true,
-        configurable: true
-    });
-    // 初始化新的子树
-    instance.subView.init(instance.subViewContext);
-    // 挂载新的子树
-    instance.subView.mount(placeholder, 'replace');
+    // 完整重挂载：dispose（清理旧副作用，触发 onDispose/onScopeDispose）
+    // → init（重执行组件函数，memo 命中快照保留状态）
+    // → mount（触发 onMounted，重新注册副作用）
+    // 注意：ctx 必须在 dispose 之前捕获——dispose 会拆除 provide 链，
+    // 之后读取 ctx 会导致重执行时 inject（如 useRouter）解析失败
+    const ctx = view.ctx;
+    view.dispose();
+    view.init(ctx);
+    view.mount(placeholder, 'replace');
 }

package/dist/hmr-client/weak-refs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * HMR 视图弱引用集合工具
+ *
+ * #idMapToView 借助 WeakRef 让已销毁视图可被 GC 回收，避免被管理器
+ * 永久强引用造成内存泄漏。GC 可达性天然区分「Freeze 停用」与
+ * 「真销毁」——Freeze 缓存持有视图强引用，停用中的视图不会被回收，
+ * 热更新照常处理；真销毁的视图无引用可回收，deref() 返回空，遍历时剪枝。
+ *
+ * 剪枝/去重逻辑抽为纯函数并接受 WeakRefLike 结构类型，便于以伪引用
+ * 做确定性单元测试（真实 WeakRef 的 deref 时点依赖 GC，无法确定性断言）。
+ * @module hmr-client/weak-refs
+ */
+import type { ComponentView } from 'vitarx';
+/**
+ * WeakRef 结构类型
+ *
+ * 真实 WeakRef 天然满足此结构；测试可注入自定义伪引用。
+ */
+export interface WeakRefLike<T extends object> {
+    deref(): T | undefined;
+}
+/**
+ * 向引用集合登记视图：剪枝死引用 + 按 deref 比对去重
+ *
+ * WeakRef 身份 ≠ 视图身份，同一视图多次登记（组件每次执行都会
+ * register）必须按解引用结果比对，否则集合会被同视图的多个
+ * WeakRef 无限撑大。
+ * @param refs - 视图弱引用集合（原地修改）
+ * @param view - 待登记的视图
+ */
+export declare function registerViewRef(refs: Set<WeakRefLike<ComponentView>>, view: ComponentView): void;
+/**
+ * 收集集合中仍存活（未被 GC）的视图，并原地剪枝死引用
+ * @param refs - 视图弱引用集合（原地修改）
+ * @returns 存活视图数组
+ */
+export declare function collectLiveViews(refs: Set<WeakRefLike<ComponentView>>): ComponentView[];

package/dist/hmr-client/weak-refs.js

@@ -0,0 +1,41 @@
+/**
+ * 向引用集合登记视图：剪枝死引用 + 按 deref 比对去重
+ *
+ * WeakRef 身份 ≠ 视图身份，同一视图多次登记（组件每次执行都会
+ * register）必须按解引用结果比对，否则集合会被同视图的多个
+ * WeakRef 无限撑大。
+ * @param refs - 视图弱引用集合（原地修改）
+ * @param view - 待登记的视图
+ */
+export function registerViewRef(refs, view) {
+    let exists = false;
+    for (const ref of refs) {
+        const cached = ref.deref();
+        if (!cached) {
+            refs.delete(ref);
+        }
+        else if (cached === view) {
+            exists = true;
+        }
+    }
+    if (!exists)
+        refs.add(new WeakRef(view));
+}
+/**
+ * 收集集合中仍存活（未被 GC）的视图，并原地剪枝死引用
+ * @param refs - 视图弱引用集合（原地修改）
+ * @returns 存活视图数组
+ */
+export function collectLiveViews(refs) {
+    const live = [];
+    for (const ref of refs) {
+        const view = ref.deref();
+        if (view) {
+            live.push(view);
+        }
+        else {
+            refs.delete(ref);
+        }
+    }
+    return live;
+}

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

@@ -2,4 +2,4 @@
  * HMR 注入模块入口
  * @module passes/hmr
  */
-export { injectHMRSupport } from './inject.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './inject.js';

package/dist/passes/hmr/index.js

@@ -2,4 +2,4 @@
  * HMR 注入模块入口
  * @module passes/hmr
  */
-export { injectHMRSupport } from './inject.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './inject.js';

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

@@ -20,15 +20,21 @@ export declare function createHMRRegistrationStatements(variableNames: string[])
  */
 export declare function createWrappedComponentHMRStatements(componentName: string): t.Statement[];
 /**
- * 从函数体中收集局部变量名
- * 递归遍历函数体中的所有变量声明，用于状态恢复
+ * 为函数体注入状态恢复代码并收集需要登记（trackState）的变量名
+ *
+ * 处理规则：
+ * - 标识符声明（非函数初始值）：初始值包装为 memo(view, '变量名') ?? 原始初始值
+ * - useModel 调用：豁免（桥接状态每次重建，见 isUseModelCall）
+ * - 解构声明（如 `const { a } = useFoo()`）：拆分为隐藏变量整包 memo +
+ *   原声明解构隐藏变量——composable 返回的状态对象得以跨重执行保留，
+ *   其内部创建的响应式状态与已挂载的副作用保持一致
+ * - 函数类型初始值 / 无初始值：不注入
+ * - for 循环头部声明：循环局部绑定，不注入（仅递归循环体）
+ *
+ * 单趟完成注入与收集，返回按执行顺序排列的登记名列表（标识符名 +
+ * 隐藏变量名），供 trackState 生成 getter。隐藏变量采用用户标识符不可能
+ * 命中的 `__$VITARX_D<N>$__` 命名，按组件函数内确定性计数。
  * @param functionBody - 函数体语句块
- * @returns 变量名数组
+ * @returns 需要状态登记的变量名数组
  */
-export declare function collectLocalVariableNames(functionBody: t.BlockStatement): string[];
-/**
- * 为函数体内的变量声明注入状态恢复代码
- * 递归遍历所有变量声明（包括 if/for/while/switch/try 嵌套块）
- * @param functionBody - 函数体语句块
- */
-export declare function injectStatePreservation(functionBody: t.BlockStatement): void;
+export declare function injectStatePreservation(functionBody: t.BlockStatement): string[];

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,90 +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();
-    forEachVariableDeclarator(functionBody, decl => {
-        if (decl.id.type !== 'VoidPattern') {
-            collectPatternBindings(decl.id, variableNames);
-        }
-    });
-    return Array.from(variableNames);
-}
-/**
- * 遍历语句块中的所有变量声明，对每个 VariableDeclarator 执行回调
- * 递归处理嵌套的控制流语句（if/for/while/switch/try 等）
- * @param block - 语句块节点
- * @param visitor - 变量声明访问者回调
- */
-function forEachVariableDeclarator(block, visitor) {
-    for (const stmt of block.body) {
-        traverseStatementForDeclarators(stmt, visitor);
-    }
-}
-/**
- * 从单个语句中递归查找变量声明并执行回调
- * 支持多种语句类型：变量声明、条件语句、循环语句、switch、try-catch 等
- * @param stmt - 语句节点
- * @param visitor - 变量声明访问者回调
- */
-function traverseStatementForDeclarators(stmt, visitor) {
-    if (stmt.type === 'VariableDeclaration') {
-        for (const decl of stmt.declarations) {
-            visitor(decl);
-        }
-    }
-    else if (stmt.type === 'IfStatement') {
-        traverseBodyForDeclarators(stmt.consequent, visitor);
-        if (stmt.alternate) {
-            traverseBodyForDeclarators(stmt.alternate, visitor);
-        }
-    }
-    else if (stmt.type === 'ForStatement' || stmt.type === 'WhileStatement' || stmt.type === 'DoWhileStatement') {
-        traverseBodyForDeclarators(stmt.body, visitor);
-    }
-    else if (stmt.type === 'ForInStatement' || stmt.type === 'ForOfStatement') {
-        traverseBodyForDeclarators(stmt.body, visitor);
-    }
-    else if (stmt.type === 'BlockStatement') {
-        forEachVariableDeclarator(stmt, visitor);
-    }
-    else if (stmt.type === 'SwitchStatement') {
-        for (const c of stmt.cases) {
-            for (const s of c.consequent) {
-                traverseStatementForDeclarators(s, visitor);
-            }
-        }
-    }
-    else if (stmt.type === 'TryStatement') {
-        forEachVariableDeclarator(stmt.block, visitor);
-        if (stmt.handler) {
-            forEachVariableDeclarator(stmt.handler.body, visitor);
-        }
-        if (stmt.finalizer) {
-            forEachVariableDeclarator(stmt.finalizer, visitor);
-        }
-    }
-}
-/**
- * 遍历语句体（可能是 BlockStatement 或单条语句）中的变量声明
- */
-function traverseBodyForDeclarators(body, visitor) {
-    if (body.type === 'BlockStatement') {
-        forEachVariableDeclarator(body, visitor);
-    }
-    else {
-        traverseStatementForDeclarators(body, visitor);
-    }
-}
 /**
  * 判断表达式是否为函数类型
- * 函数类型不需要状态恢复（函数定义本身不会改变）
+ * 函数类型不需要状态恢复（函数定义本身不会改变）；且快照读取 getter 会
+ * 拿到函数值，一旦被误调用将执行组件内的业务函数
  * @param expr - 表达式节点
  * @returns 是否为函数类型
  */
@@ -149,44 +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);
-}
-/**
- * 为函数体内的变量声明注入状态恢复代码
- * 递归遍历所有变量声明（包括 if/for/while/switch/try 嵌套块）
+ * 为函数体注入状态恢复代码并收集需要登记（trackState）的变量名
+ *
+ * 处理规则：
+ * - 标识符声明（非函数初始值）：初始值包装为 memo(view, '变量名') ?? 原始初始值
+ * - useModel 调用：豁免（桥接状态每次重建，见 isUseModelCall）
+ * - 解构声明（如 `const { a } = useFoo()`）：拆分为隐藏变量整包 memo +
+ *   原声明解构隐藏变量——composable 返回的状态对象得以跨重执行保留，
+ *   其内部创建的响应式状态与已挂载的副作用保持一致
+ * - 函数类型初始值 / 无初始值：不注入
+ * - for 循环头部声明：循环局部绑定，不注入（仅递归循环体）
+ *
+ * 单趟完成注入与收集，返回按执行顺序排列的登记名列表（标识符名 +
+ * 隐藏变量名），供 trackState 生成 getter。隐藏变量采用用户标识符不可能
+ * 命中的 `__$VITARX_D<N>$__` 命名，按组件函数内确定性计数。
  * @param functionBody - 函数体语句块
+ * @returns 需要状态登记的变量名数组
  */
 export function injectStatePreservation(functionBody) {
-    forEachVariableDeclarator(functionBody, decl => {
-        injectStatePreservationForDeclaration(decl);
-    });
+    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') {
+            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/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/transform.js

@@ -7,8 +7,8 @@ import generate from '@babel/generator';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import { createContext } from './context.js';
-import { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
-import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, isPureCompileComponent } from './utils/index.js';
+import { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectHMRAcceptOnly, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
+import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, hasForwardedComponentDefaultExport, isPureCompileComponent } from './utils/index.js';
 const entryPatterns = [/\/src\/main\.(tsx|jsx)$/, /\\src\\main\.(tsx|jsx)$/];
 /**
  * 创建解析器选项
@@ -152,8 +152,15 @@ export async function transform(code, id, options) {
     ctx.nonRefVariables = collectNonRefVariables(ast.program);
     transformAST(ast, ctx);
     injectImports(ast.program, ctx);
-    if (options.hmr && components.length > 0 && !isEntryFile(id)) {
-        injectHMRSupport(ast.program, components, id);
+    if (options.hmr && !isEntryFile(id)) {
+        if (components.length > 0) {
+            injectHMRSupport(ast.program, components, id);
+        }
+        else if (hasForwardedComponentDefaultExport(ast.program)) {
+            // 导入转发组件默认导出的模块（如 _layout 转发文件）：无本地组件定义，
+            // 注入 accept-only 自接受，避免编辑时回落整页刷新
+            injectHMRAcceptOnly(ast.program);
+        }
     }
     return generateCode(ast, code, id, options.sourceMap);
 }

package/dist/utils/forward-export.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 导入转发默认导出检测
+ *
+ * 识别「纯转发组件默认导出」的模块——典型场景是文件路由的 _layout 布局
+ * 转发文件（`export default AdminLayout` / `export { AdminLayout as default }`，
+ * AdminLayout 为 import 绑定）。此类模块本身不含组件函数定义，组件收集
+ * 结果为空，此前不会注入任何 HMR 代码，编辑该文件时 Vite 找不到自接受
+ * 边界而回落整页刷新。
+ *
+ * 注意只匹配组件形态（大写开头）的导入绑定：转发普通值（工具函数、常量）
+ * 的模块不具备组件热更新能力，保持整页刷新的默认行为。
+ * @module utils/forward-export
+ */
+import * as t from '@babel/types';
+/**
+ * 检测模块是否存在「导入转发形式的组件默认导出」
+ *
+ * 覆盖两种转发形态（转发目标均为本地 import 绑定且大写开头）：
+ * 1. `export default AdminLayout`（含 `as T` 断言包装）
+ * 2. `export { AdminLayout as default }`
+ *
+ * 带 source 的 re-export（`export { X as default } from './x'`）没有本地
+ * 绑定，不在导入绑定集合中，天然被排除。
+ *
+ * @param program - AST Program 节点
+ * @returns 是否存在转发形式的组件默认导出
+ */
+export declare function hasForwardedComponentDefaultExport(program: t.Program): boolean;

package/dist/utils/forward-export.js

@@ -0,0 +1,76 @@
+import { isValidComponentName } from './component-collect.js';
+/**
+ * 收集模块内所有本地 import 绑定名称
+ * @param program - AST Program 节点
+ * @returns 导入绑定名称集合
+ */
+function collectImportedBindingNames(program) {
+    const importedBindings = new Set();
+    for (const node of program.body) {
+        if (node.type !== 'ImportDeclaration')
+            continue;
+        for (const spec of node.specifiers) {
+            importedBindings.add(spec.local.name);
+        }
+    }
+    return importedBindings;
+}
+/**
+ * 解包 TS 类型包装表达式
+ *
+ * `export default X as T` 在 babel TS 插件下解析为 TSAsExpression
+ * （还有 satisfies / 非空断言变体），解包到真实表达式后再判定。
+ * @param node - 默认导出声明表达式
+ * @returns 解包后的表达式
+ */
+function unwrapTsWrappers(node) {
+    while (node.type === 'TSAsExpression' ||
+        node.type === 'TSSatisfiesExpression' ||
+        node.type === 'TSNonNullExpression') {
+        node = node.expression;
+    }
+    return node;
+}
+/**
+ * 检测模块是否存在「导入转发形式的组件默认导出」
+ *
+ * 覆盖两种转发形态（转发目标均为本地 import 绑定且大写开头）：
+ * 1. `export default AdminLayout`（含 `as T` 断言包装）
+ * 2. `export { AdminLayout as default }`
+ *
+ * 带 source 的 re-export（`export { X as default } from './x'`）没有本地
+ * 绑定，不在导入绑定集合中，天然被排除。
+ *
+ * @param program - AST Program 节点
+ * @returns 是否存在转发形式的组件默认导出
+ */
+export function hasForwardedComponentDefaultExport(program) {
+    const importedBindings = collectImportedBindingNames(program);
+    if (importedBindings.size === 0)
+        return false;
+    for (const node of program.body) {
+        // 形态1：export default X
+        if (node.type === 'ExportDefaultDeclaration') {
+            const decl = unwrapTsWrappers(node.declaration);
+            if (decl.type === 'Identifier') {
+                const name = decl.name;
+                if (importedBindings.has(name) && isValidComponentName(name))
+                    return true;
+            }
+        }
+        // 形态2：export { X as default }
+        if (node.type === 'ExportNamedDeclaration') {
+            for (const spec of node.specifiers) {
+                if (spec.type === 'ExportSpecifier' &&
+                    spec.exported.type === 'Identifier' &&
+                    spec.exported.name === 'default' &&
+                    spec.local.type === 'Identifier' &&
+                    importedBindings.has(spec.local.name) &&
+                    isValidComponentName(spec.local.name)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}

package/dist/utils/index.d.ts

@@ -5,4 +5,5 @@ export { collectPatternBindings, collectObjectPatternBindings } from './pattern-
 export { createBranch, createBinaryBranch, buildNestedCondition, type BranchConfig } from './branch-factory.js';
 export { validateVIfChain, collectVIfChainInfo, collectFragmentVIfChains, type VIfChainInfo } from './vif-helpers.js';
 export { collectComponentFunctions, type ComponentInfo } from './component-collect.js';
+export { hasForwardedComponentDefaultExport } from './forward-export.js';
 export { generateUniqueAlias, generateUniqueDefaultName } from './generate.js';

package/dist/utils/index.js

@@ -12,5 +12,7 @@ export { createBranch, createBinaryBranch, buildNestedCondition } from './branch
 export { validateVIfChain, collectVIfChainInfo, collectFragmentVIfChains } from './vif-helpers.js';
 // 组件收集
 export { collectComponentFunctions } from './component-collect.js';
+// 导入转发默认导出检测
+export { hasForwardedComponentDefaultExport } from './forward-export.js';
 // 生成器
 export { generateUniqueAlias, generateUniqueDefaultName } from './generate.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitarx/plugin-vite",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "The official plugin for Vitarx support in Vite.",
   "author": "ZhuChongLin <8210856@qq.com>",
   "license": "MIT",
@@ -47,7 +47,6 @@
     "acorn-walk": "^8.3.5"
   },
   "devDependencies": {
-    "typescript": "^6.0.3",
     "@commitlint/cli": "^20.4.2",
     "@commitlint/config-conventional": "^20.4.2",
     "@commitlint/types": "^20.4.0",
@@ -55,13 +54,15 @@
     "@types/babel__generator": "^7.27.0",
     "@types/babel__traverse": "^7.28.0",
     "@types/node": "^25.3.2",
+    "happy-dom": "^20.14.5",
     "husky": "^9.1.7",
     "node": "^25.7.0",
     "prettier": "^3.8.1",
     "rimraf": "^6.1.3",
-    "vitest": "^4.0.18",
+    "typescript": "^6.0.3",
+    "vitarx": "^4.0.6",
     "vite": "^8.0.5",
-    "vitarx": "^4.0.6"
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "vitest run && rimraf dist && tsc -p tsconfig.build.json",

package/dist/hmr-client/utils.d.ts

@@ -1,23 +0,0 @@
-/**
- * 代码变更类型
- */
-export interface ChangeCode {
-    /** UI 描述代码是否变化（需要重新构建视图） */
-    build: boolean;
-    /** 非 UI 代码是否变化（需要完全重新挂载） */
-    logic: boolean;
-}
-/**
- * 判断两个函数组件的代码差异
- *
- * 分析策略：
- * 1. 解析函数代码，提取所有 createView/branch/expr 等 UI API 调用
- * 2. 将这些调用识别为 UI 描述代码
- * 3. 其余代码识别为非 UI 代码（逻辑代码）
- * 4. 分别比较 UI 代码和非 UI 代码是否变化
- *
- * @param newCode 新函数代码
- * @param oldCode 旧函数代码
- * @returns {ChangeCode} 变更检测结果
- */
-export declare function diffComponentChange(newCode: string, oldCode: string): ChangeCode;

package/dist/hmr-client/utils.js

@@ -1,137 +0,0 @@
-/**
- * HMR 代码变更检测工具
- * 用于判断组件代码中 UI 描述部分和非 UI 部分的变更
- * @module hmr-client/utils
- */
-import { parse } from 'acorn';
-import { simple as walkSimple } from 'acorn-walk';
-import { UI_API_NAMES } from '../constants/index.js';
-/**
- * UI 相关的运行时 API 名称
- * 这些 API 调用代表 UI 描述代码
- */
-const UI_APIS = new Set([...UI_API_NAMES, 'jsxDEV', 'h']);
-/**
- * 判断标识符名称是否为 UI API
- * 支持原始名称和带后缀的名称（如 jsxDEV$1、branch$2、expr$1）
- */
-function isUIApi(name) {
-    if (UI_APIS.has(name))
-        return true;
-    for (const api of UI_APIS) {
-        if (name.startsWith(api + '$'))
-            return true;
-    }
-    return false;
-}
-/**
- * 从函数代码中分离 UI 代码和非 UI 代码
- * @param functionCode 完整函数代码
- * @returns 包含逻辑代码和渲染代码的对象
- */
-function separateLogicAndRender(functionCode) {
-    const uiNodes = [];
-    // 包装代码以便解析
-    const wrappedCode = `(${functionCode})`;
-    try {
-        const ast = parse(wrappedCode, {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            allowReturnOutsideFunction: true,
-            allowAwaitOutsideFunction: true,
-            allowImportExportEverywhere: true,
-            allowHashBang: true,
-            allowReserved: true
-        });
-        // 遍历 AST 收集所有 UI API 调用节点
-        walkSimple(ast, {
-            CallExpression(node) {
-                const callee = node.callee;
-                // 直接调用：createView(...)
-                if (callee.type === 'Identifier' && isUIApi(callee.name)) {
-                    uiNodes.push({ start: node.start, end: node.end });
-                    return;
-                }
-                // 成员调用：exports.createView(...)
-                if (callee.type === 'MemberExpression' &&
-                    callee.property.type === 'Identifier' &&
-                    isUIApi(callee.property.name)) {
-                    uiNodes.push({ start: node.start, end: node.end });
-                }
-            }
-        });
-    }
-    catch {
-        // 解析失败时，返回原始代码作为逻辑代码
-        return {
-            logicCode: functionCode.trim(),
-            renderCode: ''
-        };
-    }
-    // 按位置排序，从后向前替换以保持索引正确
-    uiNodes.sort((a, b) => a.start - b.start);
-    const filteredNodes = [];
-    for (const node of uiNodes) {
-        const isContained = filteredNodes.some(parent => node.start >= parent.start && node.end <= parent.end);
-        if (!isContained) {
-            filteredNodes.push(node);
-        }
-    }
-    filteredNodes.sort((a, b) => b.start - a.start);
-    // 提取 UI 代码
-    const renderCode = filteredNodes
-        .map(n => wrappedCode.slice(n.start, n.end))
-        .reverse()
-        .join('\n');
-    // 移除 UI 代码后的逻辑代码
-    let logicCode = wrappedCode;
-    for (const node of filteredNodes) {
-        logicCode = logicCode.slice(0, node.start) + logicCode.slice(node.end);
-    }
-    return {
-        logicCode: logicCode.trim(),
-        renderCode
-    };
-}
-/**
- * 规范化代码字符串
- * 移除多余空白、注释等，用于比较
- */
-function normalizeCode(code) {
-    // 移除多行注释
-    let result = code.replace(/\/\*[\s\S]*?\*\//g, '');
-    // 移除单行注释
-    result = result.replace(/\/\/.*$/gm, '');
-    // 移除多余空白
-    result = result.replace(/\s+/g, ' ');
-    // 移除首尾空白
-    return result.trim();
-}
-/**
- * 判断两个函数组件的代码差异
- *
- * 分析策略：
- * 1. 解析函数代码，提取所有 createView/branch/expr 等 UI API 调用
- * 2. 将这些调用识别为 UI 描述代码
- * 3. 其余代码识别为非 UI 代码（逻辑代码）
- * 4. 分别比较 UI 代码和非 UI 代码是否变化
- *
- * @param newCode 新函数代码
- * @param oldCode 旧函数代码
- * @returns {ChangeCode} 变更检测结果
- */
-export function diffComponentChange(newCode, oldCode) {
-    const { renderCode: newRenderCode, logicCode: newLogicCode } = separateLogicAndRender(newCode);
-    const { renderCode: oldRenderCode, logicCode: oldLogicCode } = separateLogicAndRender(oldCode);
-    // 规范化后比较，避免格式差异导致误判
-    const normalizedNewLogic = normalizeCode(newLogicCode);
-    const normalizedOldLogic = normalizeCode(oldLogicCode);
-    const normalizedNewRender = normalizeCode(newRenderCode);
-    const normalizedOldRender = normalizeCode(oldRenderCode);
-    return {
-        // UI 代码变化：需要重新构建视图
-        build: normalizedNewRender !== normalizedOldRender,
-        // 非 UI 代码变化：需要完全重新挂载组件
-        logic: normalizedNewLogic !== normalizedOldLogic
-    };
-}