vite-plugin-taro 0.5.6 → 0.5.7

package/dist/runtime/wx/dev/dev-runtime.js

@@ -7,34 +7,59 @@
 //
 // Every Page explicitly passes the inert hmr/patches.js export here before importing its capsule. The runtime applies that
 // cumulative suffix synchronously, reports its successful application frontier, and ignores sequences replayed by other Pages.
+/** Forwards a native lifecycle with its original Page receiver. */
+function forward(handler, receiver, args) {
+    if (typeof handler === 'function')
+        handler.apply(receiver, args);
+}
+/** Narrows the untyped element returned across the Taro connection boundary. */
+function isTaroRoot(value) {
+    return typeof value === 'object' && value !== null && 'ctx' in value;
+}
+/** Shared no-op CSS contract because physical rebuilds replace styles wholesale. */
+const hotContextInternals = Object.freeze({
+    updateStyle() { },
+    removeStyle() { }
+});
 /**
  * Per-module hot state, mirroring Rolldown's web runtime: accept is a passive registration;
  * the propagation invokes the previous execution's callbacks with the fresh exports.
  */
 class WxHotContext {
-    _internal = {
-        updateStyle() { },
-        removeStyle() { }
-    };
-    /** Registered self-accept callbacks; a bare accept is represented by a no-op callback. */
-    acceptCallbacks = [];
-    /** Set when a callback rejects a Refresh boundary; the current update then rebuilds. */
-    invalidationReason;
-    accept(callback) {
-        this.acceptCallbacks.push(callback ?? (() => { }));
+    _internal = hotContextInternals;
+    /**
+     * Callbacks registered by this module execution. The array is allocated on first accept,
+     * remains attached to the old execution across cache eviction, and is invoked by the next
+     * boundary execution. Undefined means this context stays passive.
+     */
+    acceptCallbacks;
+    /** Stable module identity and shared sparse index used only when this context accepts. */
+    moduleId;
+    acceptingContexts;
+    constructor(moduleId, acceptingContexts) {
+        this.moduleId = moduleId;
+        this.acceptingContexts = acceptingContexts;
     }
-    hasAccepts() {
-        return this.acceptCallbacks.length > 0;
+    accept(callback) {
+        if (!this.acceptCallbacks) {
+            this.acceptCallbacks = [callback];
+            this.acceptingContexts.set(this.moduleId, this);
+            return;
+        }
+        this.acceptCallbacks.push(callback);
     }
-    /** Invokes this old context's callbacks and returns any requested invalidation. */
+    /** Invokes this old context's callbacks; invalidation aborts the update synchronously. */
     runAccept(moduleExports) {
-        for (const callback of this.acceptCallbacks) {
-            callback(moduleExports);
+        const callbacks = this.acceptCallbacks;
+        if (!callbacks) {
+            throw new Error(`passive hot context reached as boundary: ${this.moduleId}`);
+        }
+        for (const callback of callbacks) {
+            callback?.(moduleExports);
         }
-        return this.invalidationReason;
     }
     invalidate(reason) {
-        this.invalidationReason = reason ?? 'the accepting module invalidated the update';
+        throw new Error(reason ?? 'the accepting module invalidated the update');
     }
     // Vite's generated CSS module calls hot.prune with its style teardown; the physical
     // rebuild replaces styles wholesale, so it is a no-op.
@@ -42,10 +67,17 @@ class WxHotContext {
 }
 /** The WX host: extends the Rolldown contract instead of reimplementing it. */
 class WxDevRuntime extends DevRuntime {
-    hmrInfo;
-    /** Highest Rolldown sequence successfully applied. */
-    appliedSeq = 0;
-    /** Active hot contexts per module id; the propagation invokes their callbacks. */
+    /**
+     * One session for this App heap. Undefined only before app.js consumes hmr/info.js; its
+     * identity and endpoint then stay fixed while appliedSeq records the committed frontier.
+     */
+    session;
+    /**
+     * Sparse current-generation accepting boundaries keyed by module id. Entries alone must
+     * outlive Rolldown module-cache eviction so old callbacks can receive fresh exports.
+     * createModuleHotContext removes the prior generation immediately; first accept inserts
+     * the new one. Passive contexts are never retained, so space is O(number of boundaries).
+     */
     moduleHotContexts = new Map();
     constructor() {
         // The base has no messenger: the engine tracks per-client shipped payloads instead
@@ -54,13 +86,13 @@ class WxDevRuntime extends DevRuntime {
     }
     /**
      * Generated code always calls this before registerModule and reads `_internal` from the
-     * return value. Mirrors Rolldown's web runtime: each execution immediately replaces the
-     * module's hot context; the apply plan has already captured the previous callbacks.
+     * return value. Each execution immediately retires its previous accepting boundary;
+     * calling accept registers the new context after the apply plan captured old callbacks.
      */
     createModuleHotContext(moduleId) {
-        const hotContext = new WxHotContext();
-        this.moduleHotContexts.set(moduleId, hotContext);
-        return hotContext;
+        // A new execution supersedes the old boundary before it decides whether to accept.
+        this.moduleHotContexts.delete(moduleId);
+        return new WxHotContext(moduleId, this.moduleHotContexts);
     }
     /** Computes accepting boundaries and every executed module that must be re-armed. */
     computeHmrUpdate(changedIds) {
@@ -84,7 +116,7 @@ class WxDevRuntime extends DevRuntime {
         if (updateSet.has(moduleId))
             return undefined;
         updateSet.add(moduleId);
-        if (this.moduleHotContexts.get(moduleId)?.hasAccepts()) {
+        if (this.moduleHotContexts.has(moduleId)) {
             boundaries.push(moduleId);
             return undefined;
         }
@@ -127,49 +159,120 @@ class WxDevRuntime extends DevRuntime {
             this.removeModuleCache(moduleId);
         }
         for (const { moduleId, hotContext } of applies) {
-            const invalidationReason = hotContext?.runAccept(this.initModule(moduleId));
-            if (invalidationReason) {
-                throw new Error(`${moduleId}: ${invalidationReason}`);
-            }
+            hotContext?.runAccept(this.initModule(moduleId));
         }
     }
     /** Consumed once per App heap from hmr/info.js; the host buildId identifies its cumulative patch history. */
     initialize(info) {
-        if (this.hmrInfo) {
+        if (this.session)
+            return;
+        this.session = { ...info, appliedSeq: 0 };
+    }
+    /**
+     * One-shot bridge to the application's Taro singleton. It cannot be imported into this
+     * separately bundled global runtime without creating a second Taro identity. Undefined
+     * only before the serve-only facade connection; route transactions share its lifetime.
+     */
+    taro;
+    /** Connects HMR to the same Taro singleton used by the application module graph. */
+    connectTaro(current, document, injectPageInstance) {
+        if (this.taro) {
             return;
         }
-        this.hmrInfo = info;
+        this.taro = {
+            current,
+            document,
+            injectPageInstance,
+            pageReplacements: new Map()
+        };
     }
-    /** True between a patch delivery and the next page show: a hot reload is in progress. */
-    hotReloading = false;
-    /** The capsule wrapper asks this during the synthetic lifecycle of a hot reload. */
-    isHotReloading() {
-        return this.hotReloading;
+    /** Injects snapshot-preserving behavior into one route-specific Taro Page configuration. */
+    injectPageHmr(config, route) {
+        const originalOnUnload = config.onUnload;
+        const originalOnLoad = config.onLoad;
+        const originalOnShow = config.onShow;
+        const runtime = this;
+        config.onUnload = function (...args) {
+            const taro = runtime.requireTaro();
+            if (taro.pageReplacements.has(route)) {
+                taro.pageReplacements.set(route, {
+                    $taroPath: this.$taroPath,
+                    $taroParams: this.$taroParams,
+                    // WeChat owns this serializable view-model. Keeping its reference is O(1),
+                    // unlike cloning the complete recursive projection before every edit.
+                    data: this.data
+                });
+                return;
+            }
+            forward(originalOnUnload, this, args);
+        };
+        config.onLoad = function (...args) {
+            const taro = runtime.requireTaro();
+            const snapshot = taro.pageReplacements.get(route);
+            if (snapshot) {
+                // Replace the transaction before native work so exceptions cannot retain the
+                // large data snapshot while the route waits for its synthetic onShow.
+                taro.pageReplacements.set(route, null);
+                // Snapshot paint is the first bridge operation and removes the empty-page gap.
+                this.setData(snapshot.data);
+                this.$taroPath = snapshot.$taroPath;
+                this.$taroParams = snapshot.$taroParams;
+                runtime.bindPage(this, snapshot.$taroPath);
+                return;
+            }
+            forward(originalOnLoad, this, args);
+        };
+        config.onShow = function (...args) {
+            if (runtime.requireTaro().pageReplacements.delete(route)) {
+                // Synthetic shows must not repeat requests or reset application state.
+                return;
+            }
+            forward(originalOnShow, this, args);
+        };
+    }
+    /** Returns the Taro connection or fails at the first incorrectly ordered use. */
+    requireTaro() {
+        if (!this.taro)
+            throw new Error('[vpt] WX HMR used before the Taro runtime was connected');
+        return this.taro;
+    }
+    /** Returns a retained Taro root after normal Page mount has created it. */
+    findRoot(path) {
+        const root = this.requireTaro().document.getElementById(path);
+        return isTaroRoot(root) ? root : undefined;
     }
-    /** The wrapped onShow ends the hot reload after the replacement cycle. */
-    clearHotReloading() {
-        this.hotReloading = false;
+    /** Rebinds a retained Taro tree to one replacement native Page without repainting. */
+    bindPage(instance, path) {
+        const taro = this.requireTaro();
+        taro.injectPageInstance(instance, path);
+        taro.current.page = instance;
+        const pageElement = this.findRoot(path);
+        if (!pageElement) {
+            throw new Error(`[vpt] retained Taro page not found: ${path}`);
+        }
+        pageElement.ctx = instance;
     }
-    /** Applies one Page-delivered payload before that Page imports its capsule. */
-    applyPatches(payload) {
+    /** Applies one Page-delivered payload and arms its route for native replacement. */
+    applyPatches(payload, route) {
         // The initial physical dependency exports undefined until the host has a patch range.
         if (!payload)
             return;
-        const info = this.hmrInfo;
-        if (!info || payload.buildId !== info.buildId) {
+        const session = this.session;
+        if (!session || payload.buildId !== session.buildId) {
             console.warn('[vpt] patches for a stale build');
             return;
         }
-        // A delivered patch means DevTools is about to replay the page lifecycle on the
-        // re-executing Pages; the capsule wrapper suppresses the synthetic unmount/mount so
-        // the React tree survives and Refresh swaps the code in place.
-        this.hotReloading = true;
+        // A replayed payload still causes DevTools to replace this physical Page. Arm the
+        // route independently of whether this App heap already applied its patch sequence.
+        if (route) {
+            this.requireTaro().pageReplacements.set(route, null);
+        }
         // Apply synchronously: the page's imports below the require resolve against the
         // freshly registered modules, so the re-executed Page evaluates with the new code.
-        if (this.applyPatchBatch(payload.patches)) {
+        if (this.applyPatchBatch(session, payload.patches)) {
             // The host may publish later generations while this synchronous apply runs. Reporting only afterward makes this
             // the application frontier: publisher history is never pruned merely because its JavaScript file was observed.
-            void this.sendReport({ kind: 'applied', seq: this.appliedSeq });
+            void this.sendReport({ kind: 'applied', seq: session.appliedSeq });
         }
     }
     /**
@@ -185,10 +288,10 @@ class WxDevRuntime extends DevRuntime {
      * - a second Page evaluating [5, 6, 7] skips the complete replay and leaves the latest factories untouched;
      * - [5, 7] fails at the expected sequence 6, keeps appliedSeq 4, and requests a full rebuild because factory 6 is unrecoverable.
      */
-    applyPatchBatch(patches) {
+    applyPatchBatch(session, patches) {
         // Keep the initial watermark immutable throughout the fold. Comparing replays against a moving watermark would allow
         // a duplicate new sequence in the same payload to masquerade as an already-applied patch.
-        const previousSeq = this.appliedSeq;
+        const previousSeq = session.appliedSeq;
         // Mutable only during this synchronous pass. `nextSeq` validates continuity while `changedIds` unions every incremental
         // patch's roots for the one final graph traversal; neither value escapes into persistent runtime state.
         let nextSeq = previousSeq + 1;
@@ -223,7 +326,7 @@ class WxDevRuntime extends DevRuntime {
             this.applyHmrUpdate(changedIds);
             // Commit application only after graph propagation and boundary callbacks succeed. A failure leaves the old watermark
             // intact and requests a full rebuild below, so a partially applied batch is never acknowledged as healthy.
-            this.appliedSeq = nextSeq - 1;
+            session.appliedSeq = nextSeq - 1;
             return true;
         }
         catch (error) {
@@ -237,17 +340,17 @@ class WxDevRuntime extends DevRuntime {
     }
     /** Sends one metadata-only report to the host; executable code never travels over HTTP. */
     sendReport(data) {
-        const info = this.hmrInfo;
-        if (!info) {
+        const session = this.session;
+        if (!session) {
             // A report without initialize is a programming error; fail loudly instead of
             // silently dropping the sync traffic.
             throw new Error('WX dev runtime is not initialized');
         }
         return new Promise((resolve, reject) => {
             wx.request({
-                url: info.endpoint,
+                url: session.endpoint,
                 method: 'POST',
-                data: { buildId: info.buildId, ...data },
+                data: { buildId: session.buildId, ...data },
                 header: { 'content-type': 'application/json' },
                 success() {
                     resolve();
@@ -261,30 +364,4 @@ class WxDevRuntime extends DevRuntime {
 }
 const runtime = new WxDevRuntime();
 globalThis.__rolldown_runtime__ = runtime;
-// Install the React DevTools hook before the Taro renderer injects itself: the runtime chunk
-// is the first module of the App heap, and the renderer checks the hook when it evaluates at
-// App mount. The refresh runtime's own injection (see react-refresh.ts) replays this hook's
-// renderers, so the hook must store what inject receives — a real DevTools hook keeps the
-// renderer in the renderers Map; without the stored renderer the replay captures nothing and
-// Refresh has no renderer helpers to schedule re-renders on.
-//
-// The hook lives on `global`, and every free `__REACT_DEVTOOLS_GLOBAL_HOOK__` reference in
-// react-family modules is rewritten to `global.__REACT_DEVTOOLS_GLOBAL_HOOK__`: the
-// The WeChat runtime scope does not resolve free variables against `global` (verified: the free
-// lookup is undefined while the member access exists), so the renderer would never inject
-// otherwise. `??=` keeps a pre-installed hook (e.g. a real DevTools integration) intact; the
-// runtime chunk's own lowering keeps the operator es2018-compatible.
-const reactDevtoolsHook = {
-    renderers: new Map(),
-    supportsFiber: true,
-    inject: (injected) => {
-        const id = reactDevtoolsHook.renderers.size;
-        reactDevtoolsHook.renderers.set(id, injected);
-        return id;
-    },
-    onScheduleFiberRoot: () => { },
-    onCommitFiberRoot: () => { },
-    onCommitFiberUnmount: () => { }
-};
-global.__REACT_DEVTOOLS_GLOBAL_HOOK__ ??= reactDevtoolsHook;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat Mini Program and H5 targets.",
   "type": "module",
@@ -75,8 +75,8 @@
     "rolldown": "1.2.3",
     "tailwindcss": "^4.3.3",
     "weapp-tailwindcss": "^5.2.11",
-    "@tarojs/react": "npm:vite-plugin-taro-react@0.5.6",
-    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.5.6"
+    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.5.7",
+    "@tarojs/react": "npm:vite-plugin-taro-react@0.5.7"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/node/plugins/wx/dev/plugins.ts

@@ -0,0 +1,170 @@
+import type { PluginOption } from 'vite'
+import { transformWithOxc } from 'vite'
+import type { VitePluginTaroOptions } from '../../../../options.ts'
+import { esTarget } from '../../../utils/constant.ts'
+import { memoize } from '../../../utils/memoize.ts'
+import { normalizeModuleId } from '../../../utils/modules.ts'
+import { appCapsulePath, pageCapsulePath, rolldownRuntimeId, taroRuntimePath } from '../module.ts'
+import { createWxDevHost, type WxDevHost } from './dev-host.ts'
+import { createWxReactRefreshTransforms } from './react-refresh.ts'
+
+const taroRuntimeId = '@tarojs/runtime'
+
+/**
+ * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
+ * Page HMR activation, and React Refresh adaptation transforms.
+ */
+export function createWxDevelopmentPlugin(options: VitePluginTaroOptions): PluginOption[] {
+    let host: WxDevHost | null = null
+    // Portable hook filters stay broad; these exact identities exclude similarly named user modules.
+    const normalizedAppCapsulePath = normalizeModuleId(appCapsulePath)
+    const normalizedPageCapsulePath = normalizeModuleId(pageCapsulePath)
+    const normalizedTaroRuntimePath = normalizeModuleId(taroRuntimePath)
+
+    return [
+        {
+            name: 'vpt:wx-dev',
+            apply: 'serve',
+
+            config() {
+                return {
+                    build: {
+                        // Disable maps in resolved environment config as well as final output so Oxc and Babel skip producing
+                        // intermediate maps that Rolldown would discard.
+                        sourcemap: false
+                    },
+                    experimental: {
+                        // Ask Vite to resolve its bundled-development graph and expose the private adapter instance. The wx
+                        // configureServer hook replaces only its startup method with the directly writing DevEngine.
+                        bundledDev: true
+                    }
+                }
+            },
+
+            configureServer: {
+                // Install after Vite and user plugins have finished configuring the environment, but before server.listen()
+                // asks bundledDev to create its hard-coded skip-write DevEngine.
+                order: 'post',
+                async handler(server) {
+                    host = await createWxDevHost({ server, options })
+                }
+            },
+
+            closeBundle() {
+                return host?.close()
+            }
+        },
+        {
+            name: 'vpt:wx-runtime-lowering',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                // The dev-mode transform assembles the runtime chunk (Rolldown's base runtime
+                // plus our injected implement) as this module's transform output, which
+                // bypasses the build's es2018 lowering. Real-device engines and WeChat's
+                // upload parser predate class fields and nullish operators, so the assembled
+                // runtime is lowered here — the only module that needs it. The exact id
+                // filter needs no code scan; the id must stay in sync with rolldownRuntimeId
+                // in module.ts (kept as a regex for the Rolldown-side filter).
+                filter: { id: /^\0rolldown\/runtime\.js(?:\?|$)/ },
+                handler(code) {
+                    // The `setPublicClassFields` assumption emits plain `this.x = ...`
+                    // assignments instead of external helpers, whose references the later
+                    // minifier would mangle.
+                    return fixRolldownRuntime(code)
+                }
+            }
+        },
+        {
+            name: 'vpt:wx-react-refresh-bootstrap',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                filter: { id: /\/runtime\/wx\/capsule\/app\.js(?:\?|$)/ },
+                handler(code, id) {
+                    if (normalizeModuleId(id) !== normalizedAppCapsulePath) return
+                    return injectReactRefreshBootstrap(code)
+                }
+            }
+        },
+        {
+            name: 'vpt:wx-page-hmr',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                filter: { id: /\/runtime\/wx\/capsule\/page\.js(?:\?|$)/ },
+                handler(code, id) {
+                    if (normalizeModuleId(id) !== normalizedPageCapsulePath) return
+                    return injectPageHmr(code, getPageRoute(id))
+                }
+            }
+        },
+        {
+            name: 'vpt:wx-taro-hmr',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                filter: { id: /\/runtime\/wx\/capsule\/taro-runtime\.js(?:\?|$)/ },
+                handler(code, id) {
+                    if (normalizeModuleId(id) !== normalizedTaroRuntimePath) return
+                    return injectTaroConnection(code)
+                }
+            }
+        },
+        ...createWxReactRefreshTransforms()
+    ]
+}
+
+/** Ensures the Refresh hook exists before React's renderer evaluates and injects itself. */
+export function injectReactRefreshBootstrap(code: string): { code: string; map: null } {
+    return {
+        code: `import ${JSON.stringify('/@react-refresh')};\n${code}`,
+        map: null
+    }
+}
+
+/** Connects the shared WX dev runtime to the application graph's Taro runtime instance. */
+export function injectTaroConnection(code: string): { code: string; map: null } {
+    if (!/\bCurrent\b/.test(code) || !/\bdocument\b/.test(code) || !/\binjectPageInstance\b/.test(code)) {
+        throw new Error('WX Taro runtime must expose Current, document, and injectPageInstance for HMR')
+    }
+
+    const taroImport = `import { Current as __vptCurrent, document as __vptDocument, injectPageInstance as __vptInjectPageInstance } from ${JSON.stringify(taroRuntimeId)};`
+
+    return {
+        code: `${code}\n${taroImport}\n__rolldown_runtime__.connectTaro(__vptCurrent, __vptDocument, __vptInjectPageInstance);`,
+        map: null
+    }
+}
+
+/** Activates development-only lifecycle handling for one plugin-owned Page capsule. */
+export function injectPageHmr(code: string, route: string): { code: string; map: null } {
+    if (!/\bconst\s+config\s*=/.test(code) || !/\bexport\s+default\s+config\b/.test(code)) {
+        throw new Error('WX Page capsule must declare and default-export config before HMR injection')
+    }
+
+    return {
+        code: `${code}\n__rolldown_runtime__.injectPageHmr(config, ${JSON.stringify(route)});`,
+        map: null
+    }
+}
+
+/** Reads the stable route carried by every specialized Page capsule ID. */
+function getPageRoute(id: string): string {
+    const queryIndex = id.indexOf('?')
+    const route = queryIndex < 0 ? null : new URLSearchParams(id.slice(queryIndex + 1)).get('route')
+    if (!route) throw new Error(`WX Page capsule is missing its route: ${id}`)
+    return route
+}
+
+// The assembled runtime chunk is byte-identical on every build (the base runtime and the
+// bundled implement are immutable for the server's lifetime), so the lowering runs once
+// and every build reuses it.
+const fixRolldownRuntime = memoize((code: string) => {
+    return transformWithOxc(code, rolldownRuntimeId, {
+        lang: 'js',
+        target: esTarget,
+        sourcemap: false,
+        assumptions: { setPublicClassFields: true }
+    })
+})

package/src/node/plugins/wx/dev/react-refresh.ts

@@ -25,8 +25,7 @@ const refreshRuntimeWindowGlobals = ['__registerBeforePerformReactRefresh', '__g
  * @vitejs/plugin-react's generated refresh code assumes the web HTML preamble and a browser
  * global scope; wx has neither. Each transform adapts one piece of that contract:
  * - the refresh runtime module (id-filtered): the vendored runtime reads and assigns
- *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation
- *   — the preamble's `injectIntoGlobalHook` call has no HTML home in wx;
+ *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation;
  * - react-family modules (filtered on free references): the DevTools hook is read as a free
  *   variable, which the WeChat runtime scope never resolves against `global` — every free
  *   reference becomes an explicit member access;
@@ -93,7 +92,7 @@ export function createWxReactRefreshTransforms(): Plugin[] {
  * The protocol name is unique, but only reference identifiers are rewritten. Declaration
  * keys and explicit members such as `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` must remain
  * untouched; rewriting those would either produce invalid syntax or double-prefix the hook.
- * The hook itself is created on `global` by the dev runtime chunk in `dev-runtime.ts`.
+ * The eagerly evaluated refresh runtime creates the hook on `global` before the renderer loads.
  */
 function createReactDevtoolsHookVisitor(editor: RolldownMagicString): WalkerEnter {
     return function enter(node, parent) {
@@ -139,20 +138,18 @@ function createRefreshRuntimeVisitor(editor: RolldownMagicString): WalkerEnter {
 
     return function enter(node) {
         if (
-            node.type !== 'MemberExpression' ||
-            node.computed ||
-            node.object.type !== 'Identifier' ||
-            node.object.name !== 'window' ||
-            node.property.type !== 'Identifier' ||
-            !refreshRuntimeWindowGlobals.some((globalName) => globalName === node.property.name)
+            node.type === 'MemberExpression' &&
+            !node.computed &&
+            node.object.type === 'Identifier' &&
+            node.object.name === 'window' &&
+            node.property.type === 'Identifier' &&
+            refreshRuntimeWindowGlobals.some((globalName) => globalName === node.property.name)
         ) {
-            return
+            // `global` is the shared wx App heap used by the dev runtime and hook injection. Only
+            // replacing the object range preserves the vendored runtime byte-for-byte otherwise
+            // and prevents unrelated `window` expressions from being silently adapted.
+            editor.overwrite(node.object.start, node.object.end, 'global')
         }
-
-        // `global` is the shared wx App heap used by the dev runtime and hook injection. Only
-        // replacing the object range preserves the vendored runtime byte-for-byte otherwise
-        // and prevents unrelated `window` expressions from being silently adapted.
-        editor.overwrite(node.object.start, node.object.end, 'global')
     }
 }
 

package/src/node/plugins/wx/dev/wx-dev-options.ts

@@ -136,7 +136,8 @@ function createEntryBanner(pageFiles: ReadonlySet<string>): (chunk: { name: stri
         }
         if (pageFiles.has(chunk.name)) {
             const patchesPath = path.posix.relative(path.posix.dirname(chunk.fileName), 'hmr/patches.js')
-            return `__rolldown_runtime__.applyPatches(require('${patchesPath}'));\n`
+            const route = chunk.name.slice(0, -'.js'.length)
+            return `__rolldown_runtime__.applyPatches(require('${patchesPath}'), ${JSON.stringify(route)});\n`
         }
         return ''
     }

package/src/node/plugins/wx/module.ts

@@ -47,6 +47,9 @@ export const pageCapsuleId = '\0vpt:page-capsule'
 /** Provides the Page capsule source specialized through a stable route query. */
 export const pageCapsulePath = resolvePackageFile('dist/runtime/wx/capsule/page.js')
 
+/** Identifies the Taro facade shared by the App, Page, and recursive Component capsules. */
+export const taroRuntimePath = resolvePackageFile('dist/runtime/wx/capsule/taro-runtime.js')
+
 /** Identifies the reusable synchronous native Page shell source. */
 export const pageShellPath = resolvePackageFile('dist/runtime/wx/native/page.js')
 

package/src/node/plugins/wx/plugins.ts

@@ -3,7 +3,7 @@ import type { VitePluginTaroOptions } from '../../../options.ts'
 import { esTarget } from '../../utils/constant.ts'
 import { packageRequire } from '../../utils/packages.ts'
 import { clientTaroNativeId } from '../client/constant.ts'
-import { createWxDevelopmentPlugin } from './dev/plugin.ts'
+import { createWxDevelopmentPlugin } from './dev/plugins.ts'
 import { getWxExecutionKind, isTransportModule } from './module.ts'
 import { compileNativeComponentInterface } from './native/compile-native-component-interface.ts'
 import { getNativeComponentAssetBytes } from './native/native-component-assets.ts'