vite-plugin-taro 0.7.10 → 0.7.12-beta.0

package/dist/node/plugins/deps/create-deps-plugin.d.ts

@@ -0,0 +1,8 @@
+import { type Logger, type Plugin } from 'vite';
+declare const dependencyNames: readonly ['vite', 'rolldown', 'vite-plugin-taro-runtime'];
+type DependencyVersions = Readonly<Record<(typeof dependencyNames)[number], string>>;
+/** Reports untested dependency versions through Vite's configured logger without blocking startup. */
+export declare function createDepsPlugin(): Plugin;
+/** Report every mismatch independently so one untested dependency cannot hide another. */
+export declare function warnDependencyVersions(actualVersions: DependencyVersions, logger: Pick<Logger, 'warn'>): void;
+export {};

package/dist/node/plugins/mini/dev/inject-dev-page-component.d.ts

@@ -1,7 +1,7 @@
 import type { AstTransformResult } from '../../../utils/transform.ts';
 /**
  * In serve, a native Page may load its original physical capsule after HMR has already installed a newer component factory.
- * Taro captures the component at createPageConfig() time; without this lookup, that Page first mounts with stale source even
+ * The VPT factory passes the component to Taro at createVptPageConfig() time; without this lookup, that Page first mounts with stale source even
  * though the patch was acknowledged. Replace only the component argument, leaving the production capsule untouched.
  */
 export declare function injectDevPageComponent({ capsuleCode, componentId, capsuleId }: {

package/dist/node/plugins/mini/dev/modes/devtools/devtools-hmr-mode.d.ts

@@ -21,10 +21,8 @@ export declare function renderInitialDevtoolsPatches(): string;
  */
 export declare function renderDevtoolsPatches(buildId: string, patches: readonly PatchUpdate[]): string;
 /**
- * Injects Page handoff at the exact native registration edge rather than wrapping arbitrary user `Page` calls.
- *
- * The native shell has one stable `Page(pageConfig)` contract. Failing when that contract changes is intentional: silently
- * skipping this transform would let DevTools unload the live Taro Page and destroy React state while appearing to support HMR.
+ * Prepares the capsule's final config immediately before the native shell registers it.
+ * The shared shell owns this one registration call; no platform choice or import-source parsing belongs in HMR.
  */
 export declare function injectPageShellHmr(code: string): {
     code: string;

package/dist/node/plugins/mini/mini-contract.d.ts

@@ -6,7 +6,7 @@ export type TaroContract = {
     componentsReactPath: string;
     targetRuntimePath: string;
 };
-/** Target-specific development runtimes; shared Mini entry IDs live beside their source modules. */
+/** Development runtimes selected once by the target. */
 export type RuntimeContract = {
     devtoolsHmrRuntime: string;
     interpreterHmrRuntime: string;

package/dist/node/plugins/mini/module/module.d.ts

@@ -1,5 +1,5 @@
 import { type Rolldown } from 'vite';
-/** Installs SystemJS, transport, and polyfills before native entries load capsules. */
+/** Initializes SystemJS, transport, polyfills and native query capture before application capsules. */
 export declare const miniBootstrapId: string;
 /** Registers the native App using its generated configuration capsule. */
 export declare const miniAppShellId: string;
@@ -20,14 +20,14 @@ export declare const miniTaroRuntimeId: string;
 export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
 /** Identifies the virtual binding shared by native files, SystemJS capsules and HMR factories. */
 export declare const vptGlobalBindingId = "\0vpt:global-binding";
-/** Generates the selected core-js imports loaded by bootstrap from the native polyfill chunk. */
+/** Generates the selected core-js imports loaded before SystemJS from the native polyfill chunk. */
 export declare const miniPolyfillsId = "\0vpt:mini-polyfills";
-/** External bootstrap dependency emitted only after the bundled graph is finalized. */
+/** External loader dependency emitted only after the bundled graph is finalized. */
 export declare const miniTransportId = "\0vpt:mini-transport";
-export declare const miniTransportOutputPath = "common/vpt/transport.js";
+export declare const miniTransportOutputPath = "common/vpt-transport.js";
 /** Resolves the shared Taro facade's target initialization side effect. */
 export declare const taroTargetRuntimeId = "\0vpt:taro-target-runtime";
-/** Redirects Vite's injected browser preload helper to the bootstrap identity loader. */
+/** Redirects Vite's injected browser preload helper to the SystemJS entry's identity loader. */
 export declare const vitePreloadId = "\0vite/preload-helper.js";
 /** Forces the native App shell entry to emit at the required root path. */
 export declare const appShellFileName = "app.js";
@@ -48,5 +48,5 @@ export declare const miniPolyfillSourceFilter: RegExp;
 export declare function isMiniPolyfillModule(moduleId: string): boolean;
 /** Groups framework modules by resolved package roots; Rolldown includes their dependencies. */
 export declare function isMiniFrameworkVendorModule(moduleId: string): boolean;
-/** Classifies each chunk by its compiler-owned modules; ordinary application chunks are normal capsules. O(M) time. */
+/** Classifies compiler-owned entry facades and modules; ordinary application chunks are normal capsules. O(M) time. */
 export declare function classifyMiniModule(chunk: MiniChunk): MiniChunkKind;

package/dist/node/plugins/mini/output/create-transport-output.d.ts

@@ -5,7 +5,7 @@ import type { PackageLocation } from '../placer/placement.ts';
  * identities: the package-neutral final filename is the SystemJS registration ID, while the package-qualified filename
  * supplies the literal native require path. Preliminary hash placeholders must not escape into this late-generated file.
  *
- * Transport itself executes only as native CommonJS in common/vpt/, separate from the bundled chunk namespace. Together
+ * Transport itself executes only as native CommonJS in common/vpt-transport.js, outside the bundled graph. Together
  * with bootstrap it publishes native namespaces to SystemJS without re-evaluating their module bodies.
  *
  * Do not generate this table in renderChunk: that hook runs before Rolldown's final minifier/code generator, which can rewrite

package/dist/node/plugins/mini/render/native.d.ts

@@ -7,8 +7,8 @@ import type { AstTransformResult } from '../../../utils/transform.ts';
  *
  * 1. Static ESM imports are hoisted into source-order `require` calls. Named imports remain property reads from the required
  *    namespace so they observe current values. Default and namespace imports receive Babel-compatible CommonJS interop.
- * 2. An import whose target owns a capsule entry is not passed to native `require`. It becomes
- *    bootstrap's `System.importSync(logicalChunkId)`, synchronously linking the capsule before the native lifecycle call.
+ * 2. An import targeting any capsule is not passed to native `require`. It becomes
+ *    the loader's `System.importSync(logicalChunkId)`, synchronously linking the capsule before the native lifecycle call.
  * 3. Local exports are published at declaration and mutation points. Imported re-exports use getters, while assignments and
  *    updates notify every alias without changing expression completion values or accidentally matching shadowed bindings.
  * 4. ESM top-level `this` becomes `undefined`. Direct imported calls and tags are explicitly unbound so converting an import

package/dist/node/tests/create-test-project.d.ts

@@ -0,0 +1,2 @@
+/** Creates an isolated consumer project under the repository-root tmp/ directory, outside node_modules. */
+export declare function createTestProject(prefix: string): Promise<string>;

package/dist/node/tests/project-temp-dir.d.ts

@@ -0,0 +1,2 @@
+/** Shared scratch root; each test owns and removes only its own files beneath it. */
+export declare const projectTempDir: string;

package/dist/options.d.ts

@@ -35,6 +35,11 @@ export type VptPageOption = {
      * It does not translate configuration names between platforms.
      */
     config?: VptPageConfig;
+    /**
+     * Registers a native Page data factory for synchronous prerendering; disabled unless true.
+     * Requires host data-factory support (WX glass-easel). Rendering and effects may run before native onLoad.
+     */
+    prerender?: boolean;
 };
 /** Configures vpt for one build target. */
 export interface VptOptions {

package/dist/runtime/mini/amphibious/bootstrap.d.ts

@@ -1,3 +1,4 @@
 import '\0vpt:mini-polyfills';
+export { getPageQuery } from './get-page-query.ts';
 export declare const System: any;
 export declare const __vitePreload: <Value>(load: () => Value) => Value;

package/dist/runtime/mini/amphibious/bootstrap.js

@@ -8,6 +8,8 @@ import '\0vpt:mini-polyfills';
 import { transport } from '\0vpt:mini-transport';
 // Install the minimal SystemJS loader and its synchronous-import extension before any native entry requests a capsule.
 import { System as createdSystem } from '../systemjs/system-core.js';
+// Install native query capture before App/Page capsules evaluate.
+export { getPageQuery } from './get-page-query.js';
 // install the System on globalThis
 globalThis.System = createdSystem;
 // Publish the installed loader as an explicit native dependency; callers need no ambient globalThis binding.

package/dist/runtime/mini/amphibious/get-page-query.d.ts

@@ -0,0 +1,2 @@
+/** Reads the complete native query for the Page instance currently being created. */
+export declare function getPageQuery(): Record<string, unknown>;

package/dist/runtime/mini/amphibious/get-page-query.js

@@ -0,0 +1,16 @@
+/// <reference types="vite/client" />
+// WX Page shells share one listener and the latest query supplied by native routing.
+let pageQuery;
+if (typeof wx !== 'undefined' && typeof wx.onBeforePageLoad === 'function') {
+    const capturePageQuery = ({ query }) => {
+        pageQuery = query;
+    };
+    wx.onBeforePageLoad(capturePageQuery);
+    if (import.meta.hot) {
+        import.meta.hot.dispose(() => wx.offBeforePageLoad(capturePageQuery));
+    }
+}
+/** Reads the complete native query for the Page instance currently being created. */
+export function getPageQuery() {
+    return pageQuery;
+}

package/dist/runtime/mini/capsule/create-vpt-page-config.d.ts

@@ -0,0 +1,23 @@
+import { createPageConfig as createTaroPageConfig, type MiniElementData } from 'vite-plugin-taro-runtime/runtime/mini';
+export type PageData = {
+    app: {
+        nn: string;
+        cn: MiniElementData['cn'];
+    };
+    page: {
+        cn: MiniElementData['cn'];
+    };
+};
+export type VptPageOptions = {
+    path: string;
+    config: Record<string, unknown>;
+    prerender: boolean;
+};
+/** Prepares the original Taro config for native registration, capturing the seed when prerendering. */
+export declare function createVptPageConfig(component: Parameters<typeof createTaroPageConfig>[0], vptPageOptions: {
+    path: string;
+    config: Record<string, unknown>;
+    prerender: boolean;
+}): import("vite-plugin-taro-runtime/runtime/mini").PageInstance & {
+    __vpt_meta: {};
+};

package/dist/runtime/mini/capsule/create-vpt-page-config.js

@@ -0,0 +1,28 @@
+import { createPageConfig as createTaroPageConfig } from 'vite-plugin-taro-runtime/runtime/mini';
+import { prerenderToData } from './prerender-to-data.js';
+/** Prepares the original Taro config for native registration, capturing the seed when prerendering. */
+export function createVptPageConfig(component, vptPageOptions) {
+    const { path: routePath, config: pageConfig, prerender } = vptPageOptions;
+    /*
+     * Generated Page templates invoke Taro's unchanged recursive component, whose input is one compact node selected by i.nn.
+     * App JSX does not have that cardinality: it may return one or many top-level hosts, and the private Page outlet may occur at
+     * any depth within them. vpt_fragment is therefore a native-template-only collection adapter. Its fixed nn selects a transparent
+     * template that iterates cn while one surrounding component owns the Page-content boundary. Runtime projection markers relay
+     * that content only through the App branch containing the outlet. Without the fragment, each App root would need a separate
+     * recursive component and potential Page-content copy, or the component would need an App-specific collection mode.
+     *
+     * This record is not a Taro host: it has no Fiber, event source, ref, lifecycle, native element, or keyed parent collection.
+     * It consequently needs no sid. Only cn is seeded and updated; nn remains the stable generic-template discriminator.
+     */
+    const initialData = { app: { nn: 'vpt_fragment', cn: [] }, page: { cn: [] } };
+    const config = Object.assign(createTaroPageConfig(component, routePath, initialData, pageConfig), {
+        __vpt_meta: {}
+    });
+    // Keep the one-shot prerender identity out of native registration.
+    Object.defineProperty(config, '__vpt_meta', { enumerable: false });
+    if (prerender) {
+        // Keep render inputs in the closure; native onLoad only needs the prepared identity.
+        config.data = () => prerenderToData(config, component, routePath, initialData);
+    }
+    return config;
+}

package/dist/runtime/mini/capsule/page.d.ts

@@ -1,3 +1,5 @@
 import './app.ts';
-declare const config: import("vite-plugin-taro-runtime/runtime/mini").PageInstance;
+declare const config: import("vite-plugin-taro-runtime/runtime/mini").PageInstance & {
+    __vpt_meta: {};
+};
 export default config;

package/dist/runtime/mini/capsule/page.js

@@ -2,17 +2,6 @@
 import './app.js';
 // @ts-expect-error: The Mini Program build replaces this private import with the configured Page component.
 import PageComponent from '\0vpt:page-component';
-import { createPageConfig } from './taro-runtime.js';
-/*
- * Generated Page templates invoke Taro's unchanged recursive component, whose input is one compact node selected by i.nn.
- * App JSX does not have that cardinality: it may return one or many top-level hosts, and the private Page outlet may occur at
- * any depth within them. vpt_fragment is therefore a native-template-only collection adapter. Its fixed nn selects a transparent
- * template that iterates cn while one surrounding component owns the Page-content boundary. Runtime projection markers relay
- * that content only through the App branch containing the outlet. Without the fragment, each App root would need a separate
- * recursive component and potential Page-content copy, or the component would need an App-specific collection mode.
- *
- * This record is not a Taro host: it has no Fiber, event source, ref, lifecycle, native element, or keyed parent collection.
- * It consequently needs no sid. Only cn is seeded and updated; nn remains the stable generic-template discriminator.
- */
-const config = createPageConfig(PageComponent, __VPT_PAGE_PATH__, { app: { nn: 'vpt_fragment', cn: [] }, page: { cn: [] } }, __VPT_PAGE_CONFIG__);
+import { createVptPageConfig } from './taro-runtime.js';
+const config = createVptPageConfig(PageComponent, __VPT_PAGE_OPTIONS__);
 export default config;

package/dist/runtime/mini/capsule/prerender-to-data.d.ts

@@ -0,0 +1,3 @@
+import type { createVptPageConfig, PageData } from './create-vpt-page-config.ts';
+/** Commits one Page into the existing App root and returns its initial native data without dispatching lifecycles. */
+export declare function prerenderToData(config: ReturnType<typeof createVptPageConfig>, component: Parameters<typeof createVptPageConfig>[0], route: string, initialData: PageData): PageData;

package/dist/runtime/mini/capsule/prerender-to-data.js

@@ -0,0 +1,39 @@
+import { flushSync } from 'vite-plugin-taro-runtime/react';
+import { addLeadingSlash, Current, document, getOnHideEventKey, getOnReadyEventKey, getOnShowEventKey, getPath, hydrate, incrementId } from 'vite-plugin-taro-runtime/runtime/mini';
+import { getPageQuery } from '../amphibious/bootstrap.js';
+// One counter distinguishes native instances even when their route, query and creation timestamp match.
+const pageId = incrementId();
+/** Commits one Page into the existing App root and returns its initial native data without dispatching lifecycles. */
+export function prerenderToData(config, component, route, initialData) {
+    if (!Current.app?.mount) {
+        return initialData;
+    }
+    const params = { ...getPageQuery(), $taroTimestamp: Date.now() };
+    const path = getPath(route, { ...params, $vptPage: pageId() });
+    // Retain this instance identity until native onLoad consumes it without remounting the Page.
+    config.__vpt_meta.prerenderIdentity = { path, params };
+    Current.router = {
+        params,
+        path: addLeadingSlash(route),
+        $taroPath: path,
+        onReady: getOnReadyEventKey(route),
+        onShow: getOnShowEventKey(route),
+        onHide: getOnHideEventKey(route)
+    };
+    flushSync(() => {
+        Current.app.mount(component, path, () => { });
+    });
+    const page = document.getElementById(path);
+    const app = page?.parentNode?._root;
+    // Cold App startup or Suspense without a committed fallback keeps the seed until a later React commit.
+    if (!page || !app) {
+        return initialData;
+    }
+    // Both hosts are elements; hydrate's shared return type also includes text nodes.
+    const appData = hydrate(app);
+    const pageData = hydrate(page);
+    return {
+        app: { ...initialData.app, cn: appData.cn },
+        page: { ...initialData.page, cn: pageData.cn }
+    };
+}

package/dist/runtime/mini/capsule/taro-runtime.d.ts

@@ -4,4 +4,5 @@ import '\0vpt:taro-target-runtime';
 import 'vite-plugin-taro-runtime/plugin-html/runtime';
 export { createReactApp } from 'vite-plugin-taro-runtime/plugin-framework-react/runtime';
 export { default as ReactDOM } from 'vite-plugin-taro-runtime/react';
-export { createPageConfig, createRecursiveComponentConfig } from 'vite-plugin-taro-runtime/runtime/mini';
+export { createRecursiveComponentConfig } from 'vite-plugin-taro-runtime/runtime/mini';
+export { createVptPageConfig } from './create-vpt-page-config.ts';

package/dist/runtime/mini/capsule/taro-runtime.js

@@ -8,8 +8,9 @@ import '\0vpt:taro-target-runtime';
 import 'vite-plugin-taro-runtime/plugin-html/runtime';
 export { createReactApp } from 'vite-plugin-taro-runtime/plugin-framework-react/runtime';
 export { default as ReactDOM } from 'vite-plugin-taro-runtime/react';
-export { createPageConfig, createRecursiveComponentConfig } from 'vite-plugin-taro-runtime/runtime/mini';
+export { createRecursiveComponentConfig } from 'vite-plugin-taro-runtime/runtime/mini';
 import { customWrapperCache } from 'vite-plugin-taro-runtime/runtime/mini';
+export { createVptPageConfig } from './create-vpt-page-config.js';
 // DevTools HMR runs in the bootstrap chunk, so publish the application graph's cache once on the language global.
 if (process.env.NODE_ENV === 'development') {
     Reflect.set(globalThis, Symbol.for('customWrapperCache'), customWrapperCache);

package/dist/runtime/mini/dev/mini-hmr-runtime.d.ts

@@ -26,7 +26,10 @@ declare class MiniHotContext {
     /** Stable module identity and shared sparse index used only when this context accepts. */
     private readonly moduleId;
     private readonly acceptingContexts;
-    constructor(moduleId: string, acceptingContexts: Map<string, MiniHotContext>);
+    private readonly disposeCallbacks;
+    constructor(moduleId: string, acceptingContexts: Map<string, MiniHotContext>, disposeCallbacks: Map<string, Array<() => void>>);
+    /** Cleanup registration is independent of accepting updates; passive dependencies ay own native listenemrs. */
+    dispose(callback: () => void): void;
     accept(callback?: AcceptCallback): void;
     /** Invokes this old context's callbacks; invalidation aborts the update synchronously. */
     runAccept(moduleExports: unknown): void;
@@ -67,6 +70,7 @@ export declare class MiniHmrRuntime extends DevRuntime {
      * the new one. Passive contexts are never retained, so space is O(number of boundaries).
      */
     private readonly moduleHotContexts;
+    private readonly moduleDisposeCallbacks;
     /** Immutable platform socket constructor retained until the running App initializes. */
     private readonly connectSocket;
     constructor(connectSocket: ConnectMiniSocket);
@@ -76,6 +80,9 @@ export declare class MiniHmrRuntime extends DevRuntime {
      * calling accept registers the new context after the apply plan captured old callbacks.
      */
     createModuleHotContext(moduleId: string): MiniHotContext;
+    /** Native listener cleanup runs before the old exports are evicted, including cold-capsule replacement. */
+    removeModuleCache(moduleId: string): void;
+    private disposeModule;
     /** Resolves a cold Page against patches installed before its physical capsule first executed. */
     resolvePageComponent(moduleId: string, baseline: ElementType): ElementType;
     /** Computes accepting boundaries and every executed module that must be re-armed. */

package/dist/runtime/mini/dev/mini-hmr-runtime.js

@@ -29,9 +29,21 @@ class MiniHotContext {
     /** Stable module identity and shared sparse index used only when this context accepts. */
     moduleId;
     acceptingContexts;
-    constructor(moduleId, acceptingContexts) {
+    disposeCallbacks;
+    constructor(moduleId, acceptingContexts, disposeCallbacks) {
         this.moduleId = moduleId;
         this.acceptingContexts = acceptingContexts;
+        this.disposeCallbacks = disposeCallbacks;
+    }
+    /** Cleanup registration is independent of accepting updates; passive dependencies ay own native listenemrs. */
+    dispose(callback) {
+        const callbacks = this.disposeCallbacks.get(this.moduleId);
+        if (callbacks) {
+            callbacks.push(callback);
+        }
+        else {
+            this.disposeCallbacks.set(this.moduleId, [callback]);
+        }
     }
     accept(callback) {
         if (!this.acceptCallbacks) {
@@ -76,6 +88,8 @@ export class MiniHmrRuntime extends DevRuntime {
      * the new one. Passive contexts are never retained, so space is O(number of boundaries).
      */
     moduleHotContexts = new Map();
+    // Retain only modules that registered cleanup; eviction consumes their callbacks before replacement factories execute.
+    moduleDisposeCallbacks = new Map();
     /** Immutable platform socket constructor retained until the running App initializes. */
     connectSocket;
     constructor(connectSocket) {
@@ -94,8 +108,21 @@ export class MiniHmrRuntime extends DevRuntime {
      */
     createModuleHotContext(moduleId) {
         // A new execution supersedes the old boundary before it decides whether to accept.
+        this.disposeModule(moduleId);
         this.moduleHotContexts.delete(moduleId);
-        return new MiniHotContext(moduleId, this.moduleHotContexts);
+        return new MiniHotContext(moduleId, this.moduleHotContexts, this.moduleDisposeCallbacks);
+    }
+    /** Native listener cleanup runs before the old exports are evicted, including cold-capsule replacement. */
+    removeModuleCache(moduleId) {
+        this.disposeModule(moduleId);
+        super.removeModuleCache(moduleId);
+    }
+    disposeModule(moduleId) {
+        const callbacks = this.moduleDisposeCallbacks.get(moduleId);
+        this.moduleDisposeCallbacks.delete(moduleId);
+        for (const callback of callbacks ?? []) {
+            callback();
+        }
     }
     /** Resolves a cold Page against patches installed before its physical capsule first executed. */
     resolvePageComponent(moduleId, baseline) {

package/dist/runtime/mini/dev/modes/devtools/devtools-runtime.d.ts

@@ -1,5 +1,5 @@
 import { type ConnectMiniSocket, MiniHmrRuntime, type RuntimePatch } from '../../mini-hmr-runtime.ts';
-import { injectPageHmr as injectDevtoolsPageHmr } from './page-hmr.ts';
+import { injectPageHmr as injectDevtoolsPageHmr } from './inject-page-hmr.ts';
 /**
  * One physical DevTools patch. DevTools compiles `factory` as native project JavaScript; invoking it registers updated Rolldown
  * factories but does not execute application modules, allowing the shared runtime to install a complete batch before one render.

package/dist/runtime/mini/dev/modes/devtools/devtools-runtime.js

@@ -4,7 +4,7 @@
  * what allows module and React state to survive repeated native Page registration.
  */
 import { MiniHmrRuntime } from '../../mini-hmr-runtime.js';
-import { injectPageHmr as injectDevtoolsPageHmr } from './page-hmr.js';
+import { injectPageHmr as injectDevtoolsPageHmr } from './inject-page-hmr.js';
 /** Adapts physical DevTools patch modules and Page replacement onto the shared Mini Program HMR runtime. */
 class DevtoolsHmrRuntime extends MiniHmrRuntime {
     /** Applies one Page-delivered payload before the native shell imports its route capsule. */

package/dist/runtime/mini/dev/modes/devtools/{page-hmr.d.ts → inject-page-hmr.d.ts}

@@ -1,5 +1,6 @@
 type NativePage = {
     data: Record<string, unknown>;
+    groupUpdates?: unknown;
 };
 declare const pageHmrStateKey: unique symbol;
 type PageHmrState = {
@@ -9,7 +10,7 @@ type PageHmrState = {
     mountedPage: NativePage | undefined;
 };
 type HmrPageConfig = {
-    data: Record<string, unknown>;
+    data: Record<string, unknown> | (() => Record<string, unknown>);
     onUnload?: unknown;
     onLoad?: unknown;
     onShow?: unknown;

package/dist/runtime/mini/dev/modes/devtools/{page-hmr.js → inject-page-hmr.js}

@@ -1,10 +1,15 @@
 // A symbol cannot collide with native or Taro string-named Page options, and it lets a later injection recover the exact
 // config-local state without a route map or runtime-global WeakMap.
 const pageHmrStateKey = Symbol('vpt.pageHmrState');
+/** Detects the active glass-easel framework through its native instance API, not compiler configuration. */
+function isGlassEasel(page) {
+    return typeof page.groupUpdates === 'function';
+}
 /** Calls a native lifecycle with the same Page bound to `this` and the same arguments. */
 function forward(handler, page, args) {
-    if (typeof handler === 'function')
+    if (typeof handler === 'function') {
         handler.apply(page, args);
+    }
 }
 /** Tracks the mounted native Page and prepares its static config for DevTools re-registration. */
 export function injectPageHmr(config) {
@@ -15,20 +20,15 @@ export function injectPageHmr(config) {
          * The static config can outlive a native Page instance. Before its first ordinary onLoad, or after a real onUnload,
          * there is no mounted Page or current view-model to carry into another registration. Leave the lifecycle gate unarmed
          * and preserve the config's existing initial data so a future real onLoad still enters Taro normally.
+         * Glass-easel retains native instances without replaying lifecycles, so it needs neither suppression nor snapshot handoff.
          */
-        if (!mountedPage) {
+        if (!mountedPage || isGlassEasel(mountedPage)) {
             return config;
         }
-        /*
-         * Arm the lifecycle wrappers on this exact static config before it is passed back to `Page(config)`. DevTools then
-         * triggers an unload/load/show sequence for that native re-registration: unload and load observe `true` and return before
-         * entering Taro, preserving the mounted React tree and its original Page connection; show consumes the one-shot gate by
-         * restoring `false`. Ordinary navigation never enters this branch, and every Page config owns an independent state, so
-         * no route map, global phase, or Page identity comparison participates in the decision.
-         */
+        // Legacy hosts replay unload/load/show; onShow ends that native cycle.
         existingState.isReregistering = true;
         /*
-         * `Page(config)` reads `config.data` as the initial native view-model for this registration. The Page owns current app
+         * Native registration reads `config.data` as the initial view-model for this registration. The Page owns current app
          * and ordinary Page fields, while each mounted CustomWrapper owns the current snapshot below its native boundary. Join
          * those already-serialized snapshots before registration so the native host never publishes the stale initial placeholder tree.
          * This lifecycle handoff performs no setData call and runs before React Refresh can publish another logical tree.
@@ -43,14 +43,16 @@ export function injectPageHmr(config) {
     /*
      * This mutable config-local state spans ordinary Page mount/unmount and one DevTools re-registration lifecycle. Lifecycle
      * wrappers close over this exact object, while a later `injectPageHmr(config)` retrieves it through the symbol and avoids
-     * wrapping twice. Config-local ownership avoids route maps, runtime-global phase flags, and state shared by independent Page
+     * wrapping twice. Only legacy hosts need the re-registration lifecycle gate.
+     * Config-local ownership avoids route maps, runtime-global phase flags, and state shared by independent Page
      * registrations; the state becomes unreachable together with its static config.
      */
     const state = {
         isReregistering: false,
         mountedPage: undefined
     };
-    config[pageHmrStateKey] = state;
+    // Handoff state belongs to the static config, not the properties copied into native registration.
+    Object.defineProperty(config, pageHmrStateKey, { value: state });
     config.onUnload = function (...args) {
         if (state.isReregistering) {
             return;
@@ -67,8 +69,7 @@ export function injectPageHmr(config) {
     };
     config.onShow = function (...args) {
         if (state.isReregistering) {
-            // DevTools' synthetic unload/load/show cycle ends here. Consume the gate exactly once so the next real navigation
-            // forwards ordinary Taro lifecycles instead of being mistaken for the same registration.
+            // DevTools' synthetic unload/load/show cycle ends here; the next real navigation forwards lifecycles.
             state.isReregistering = false;
             return;
         }

package/dist/runtime/mini/native/app.js

@@ -1,3 +1,4 @@
+// Initialize the VPT runtime before loading the native configuration capsule.
 import '../amphibious/bootstrap.js';
 import appConfig from '../capsule/app.js';
 App(appConfig);

package/dist/runtime/mini/native/component.js

@@ -1,3 +1,4 @@
+// Initialize the VPT runtime before loading the native configuration capsule.
 import '../amphibious/bootstrap.js';
 import { componentConfig } from '../capsule/component.js';
 Component(componentConfig);

package/dist/runtime/mini/native/custom-wrapper.js

@@ -1,3 +1,4 @@
+// Initialize the VPT runtime before loading the native configuration capsule.
 import '../amphibious/bootstrap.js';
 import { customWrapperConfig } from '../capsule/component.js';
 Component(customWrapperConfig);

package/dist/runtime/mini/native/page.js

@@ -1,4 +1,4 @@
+// biome-ignore assist/source/organizeImports: VPT runtime must initialize before the Page capsule.
 import '../amphibious/bootstrap.js';
-// @ts-expect-error: The active Mini contract resolves the route-specific Page capsule.
 import pageConfig from '\0vpt:page-capsule';
 Page(pageConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.7.10",
+  "version": "0.7.12-beta.0",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat, Alipay, TikTok, and H5 targets.",
   "type": "module",
@@ -64,10 +64,10 @@
     "core-js": "^3.50.0",
     "lightningcss": "1.33.0",
     "react-reconciler": "0.34.0",
-    "rolldown": "1.2.11",
+    "rolldown": "1.2.12",
     "sval": "0.6.12",
     "tailwindcss": "^4.3.3",
-    "vite-plugin-taro-runtime": "0.7.10"
+    "vite-plugin-taro-runtime": "0.7.12-beta.0"
   },
   "peerDependencies": {
     "react": "^19.3.0",
@@ -98,8 +98,8 @@
   },
   "scripts": {
     "build": "node ../../scripts/sync-plugin-readme.ts && node ./scripts/build.ts",
-    "test": "node --test --test-concurrency=2 --test-reporter=dot",
-    "test:coverage": "c8 node --test --test-concurrency=2",
+    "test": "node --test --test-concurrency=4 --test-reporter=dot",
+    "test:coverage": "c8 node --test --test-concurrency=4",
     "typecheck": "tsc --project tsconfig.json --noEmit"
   }
 }

package/dist/node/utils/assert-runtime-versions.d.ts

@@ -1,3 +0,0 @@
-/** Verifies that Vite uses the versions pinned by VPT. */
-export declare function assertRuntimeVersions(): void;
-export declare function assertRuntimeVersionValues(actualViteVersion: string, actualRolldownVersion: string): void;