vite-plugin-taro 0.6.20 → 0.7.0

package/dist/runtime/{wx/dev/wx-hmr-runtime.d.ts → mini/dev/mini-hmr-runtime.d.ts}

@@ -1,5 +1,5 @@
 import type { DevRuntime as RolldownDevRuntime } from 'rolldown/experimental/runtime-types';
-import { type HmrInfo } from './wx-hmr-protocol.ts';
+import { type HmrInfo } from './hmr-protocol.ts';
 /** Lexical base class injected into the runtime chunk by Rolldown; typed via the contract. */
 declare const DevRuntime: new (clientId: string) => RolldownDevRuntime;
 /** Mode-independent patch metadata consumed by the shared sequence and graph reducer. */
@@ -13,7 +13,7 @@ type AcceptCallback = (moduleExports: unknown) => void;
  * 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.
  */
-declare class WxHotContext {
+declare class MiniHotContext {
     readonly _internal: Readonly<{
         updateStyle(): void;
         removeStyle(): void;
@@ -27,15 +27,30 @@ declare class WxHotContext {
     /** 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, WxHotContext>);
+    constructor(moduleId: string, acceptingContexts: Map<string, MiniHotContext>);
     accept(callback?: AcceptCallback): void;
     /** Invokes this old context's callbacks; invalidation aborts the update synchronously. */
     runAccept(moduleExports: unknown): void;
     invalidate(reason?: string): never;
     prune(_callback?: () => void): void;
 }
-/** Shared WX host mechanics extending the Rolldown contract instead of reimplementing it. */
-export declare class WxHmrRuntime extends DevRuntime {
+/** Task-scoped socket surface shared by the WX and Alipay Mini Program APIs. */
+export type MiniSocketTask = Readonly<{
+    send(options: Readonly<{
+        data: string;
+    }>): void;
+    close(options: Readonly<{
+        code: number;
+        reason: string;
+    }>): void;
+    onMessage(listener: (result: Readonly<{
+        data: unknown;
+    }>) => void): void;
+}>;
+/** Connects one App-level HMR socket using the active platform API. */
+export type ConnectMiniSocket = (endpoint: string) => MiniSocketTask;
+/** Shared Mini Program host mechanics extending the Rolldown contract instead of reimplementing it. */
+export declare class MiniHmrRuntime extends DevRuntime {
     /**
      * One session for this App heap. Undefined only before the mode-selected entry initializes the runtime; its identity then
      * stays fixed while appliedSeq records the committed frontier.
@@ -50,13 +65,15 @@ export declare class WxHmrRuntime extends DevRuntime {
      * the new one. Passive contexts are never retained, so space is O(number of boundaries).
      */
     private readonly moduleHotContexts;
-    constructor();
+    /** Immutable platform socket constructor retained for the App heap's first initialization. */
+    private readonly connectSocket;
+    constructor(connectSocket: ConnectMiniSocket);
     /**
      * Generated code always calls this before registerModule and reads `_internal` from the
      * 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: string): WxHotContext;
+    createModuleHotContext(moduleId: string): MiniHotContext;
     /** Computes accepting boundaries and every executed module that must be re-armed. */
     private computeHmrUpdate;
     /** Walks executed importers until an accepting boundary is found. */

package/dist/runtime/{wx/dev/wx-hmr-runtime.js → mini/dev/mini-hmr-runtime.js}

@@ -1,12 +1,13 @@
 /*
- * Shared WX HMR runtime, bundled into the mode-selected entry and injected into Rolldown's generated runtime chunk.
+ * Shared Mini Program HMR runtime, bundled into the mode-selected entry and injected into Rolldown's generated runtime chunk.
  * Rolldown provides the lexical `DevRuntime` base class; this file extends that registry instead of duplicating module loading.
  *
  * Concrete modes decide how executable registrations arrive—native project JavaScript or interpreted source—and provide only a
  * synchronous installer. This class owns the invariant that installation, graph propagation, cache eviction, boundary execution,
  * and ACK form one application transaction; it has no file-delivery or interpreter policy of its own.
  */
-import { runtimeControlEvent, runtimeReportEvent } from './wx-hmr-protocol.js';
+import { runtimeControlEvent, runtimeReportEvent } from './hmr-protocol.js';
+import { polyfillQueueMicrotask } from './polyfill/polyfill-queue-microtask.js';
 /** Shared no-op CSS contract because physical rebuilds replace styles wholesale. */
 const hotContextInternals = Object.freeze({
     updateStyle() { },
@@ -16,7 +17,7 @@ const hotContextInternals = Object.freeze({
  * 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 {
+class MiniHotContext {
     _internal = hotContextInternals;
     /**
      * Callbacks registered by this module execution. The array is allocated on first accept,
@@ -56,8 +57,8 @@ class WxHotContext {
     // rebuild replaces styles wholesale, so it is a no-op.
     prune(_callback) { }
 }
-/** Shared WX host mechanics extending the Rolldown contract instead of reimplementing it. */
-export class WxHmrRuntime extends DevRuntime {
+/** Shared Mini Program host mechanics extending the Rolldown contract instead of reimplementing it. */
+export class MiniHmrRuntime extends DevRuntime {
     /**
      * One session for this App heap. Undefined only before the mode-selected entry initializes the runtime; its identity then
      * stays fixed while appliedSeq records the committed frontier.
@@ -72,10 +73,17 @@ export class WxHmrRuntime extends DevRuntime {
      * the new one. Passive contexts are never retained, so space is O(number of boundaries).
      */
     moduleHotContexts = new Map();
-    constructor() {
+    /** Immutable platform socket constructor retained for the App heap's first initialization. */
+    connectSocket;
+    constructor(connectSocket) {
         // The base has no messenger: the engine tracks per-client shipped payloads instead
-        // of executed module ids, so the wx host registers the client session itself.
+        // of executed module ids, so the Mini Program host registers the client session itself.
         super('');
+        // Rolldown schedules each generated React Refresh boundary with queueMicrotask. This shared runtime is constructed before
+        // any application factory, so installing the language-global fallback here covers every Mini target and development mode
+        // at the one common execution boundary while leaving production output untouched.
+        polyfillQueueMicrotask(globalThis);
+        this.connectSocket = connectSocket;
     }
     /**
      * Generated code always calls this before registerModule and reads `_internal` from the
@@ -85,7 +93,7 @@ export class WxHmrRuntime extends DevRuntime {
     createModuleHotContext(moduleId) {
         // A new execution supersedes the old boundary before it decides whether to accept.
         this.moduleHotContexts.delete(moduleId);
-        return new WxHotContext(moduleId, this.moduleHotContexts);
+        return new MiniHotContext(moduleId, this.moduleHotContexts);
     }
     /** Computes accepting boundaries and every executed module that must be re-armed. */
     computeHmrUpdate(changedIds) {
@@ -163,7 +171,7 @@ export class WxHmrRuntime extends DevRuntime {
         if (this.session)
             return;
         this.session = { buildId: info.buildId, appliedSeq: 0 };
-        const socket = wx.connectSocket({ url: info.endpoint, protocols: ['vite-hmr'] });
+        const socket = this.connectSocket(info.endpoint);
         this.socket = socket;
         socket.onMessage(({ data }) => {
             if (typeof data !== 'string')
@@ -185,7 +193,7 @@ export class WxHmrRuntime extends DevRuntime {
     sendSocketEvent(event, data) {
         const socket = this.socket;
         if (!socket) {
-            throw new Error('WX HMR socket is not initialized');
+            throw new Error('Mini Program HMR socket is not initialized');
         }
         socket.send({ data: JSON.stringify({ type: 'custom', event: event, data: data }) });
     }
@@ -193,7 +201,7 @@ export class WxHmrRuntime extends DevRuntime {
     stopSocket(reason) {
         const socket = this.socket;
         if (!socket) {
-            throw new Error('WX HMR socket is not initialized');
+            throw new Error('Mini Program HMR socket is not initialized');
         }
         socket.close({ code: 1000, reason: reason });
     }
@@ -277,7 +285,7 @@ export class WxHmrRuntime extends DevRuntime {
             console.warn('[vpt] patch batch failed; apply stopped', error);
             void this.sendReport({
                 kind: 'rebuild',
-                reason: Error.isError(error) ? error.message : String(error)
+                reason: error instanceof Error ? error.message : String(error)
             });
             return false;
         }
@@ -288,7 +296,7 @@ export class WxHmrRuntime extends DevRuntime {
         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');
+            throw new Error('Mini Program dev runtime is not initialized');
         }
         const report = { buildId: session.buildId, ...data };
         this.sendSocketEvent(runtimeReportEvent, report);

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

@@ -0,0 +1,23 @@
+import { type ConnectMiniSocket, MiniHmrRuntime, type RuntimePatch } from '../../mini-hmr-runtime.ts';
+import { injectPageHmr as injectDevtoolsPageHmr } from './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.
+ */
+type DevtoolsPatch = RuntimePatch & {
+    readonly factory: () => void;
+};
+type HmrPageConfig = Parameters<typeof injectDevtoolsPageHmr>[0];
+/** Adapts physical DevTools patch modules and Page replacement onto the shared Mini Program HMR runtime. */
+declare class DevtoolsHmrRuntime extends MiniHmrRuntime {
+    /** Applies one Page-delivered payload before the native shell imports its route capsule. */
+    applyPatches(payload: Readonly<{
+        buildId: string;
+        patches: readonly DevtoolsPatch[];
+    }> | undefined): void;
+    /** Preserves the mounted Page connection while DevTools re-registers its static config. */
+    injectPageHmr(config: HmrPageConfig): HmrPageConfig;
+}
+/** Creates one platform-connected adapter for installation by a thin target runtime entry. */
+export declare function createDevtoolsHmrRuntime(connectSocket: ConnectMiniSocket): DevtoolsHmrRuntime;
+export {};

package/dist/runtime/{wx → mini}/dev/modes/devtools/devtools-runtime.js

@@ -3,10 +3,10 @@
  * before its route capsule, while this singleton survives Page JavaScript hot reload in the App heap. That lifetime difference is
  * what allows module and React state to survive repeated native Page registration.
  */
-import { WxHmrRuntime } from '../../wx-hmr-runtime.js';
+import { MiniHmrRuntime } from '../../mini-hmr-runtime.js';
 import { injectPageHmr as injectDevtoolsPageHmr } from './page-hmr.js';
-/** Adapts physical DevTools patch modules and Page replacement onto the shared WX HMR runtime. */
-class DevtoolsHmrRuntime extends WxHmrRuntime {
+/** 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. */
     applyPatches(payload) {
         // The initial physical dependency exports undefined until the host has a patch range. Once present, apply synchronously:
@@ -20,11 +20,11 @@ class DevtoolsHmrRuntime extends WxHmrRuntime {
         return injectDevtoolsPageHmr(config);
     }
 }
-/** Executes only the native registration program; graph application remains owned by `WxHmrRuntime`. */
+/** Executes only the native registration program; graph application remains owned by `MiniHmrRuntime`. */
 function installDevtoolsPatch(patch) {
     patch.factory();
 }
-// Generated modules already address this App-global name. Install exactly one adapter with the runtime chunk rather than one per
-// Page, because Page hot reload re-evaluates shells while the App heap and its module registry remain alive.
-const runtime = new DevtoolsHmrRuntime();
-globalThis.__rolldown_runtime__ = runtime;
+/** Creates one platform-connected adapter for installation by a thin target runtime entry. */
+export function createDevtoolsHmrRuntime(connectSocket) {
+    return new DevtoolsHmrRuntime(connectSocket);
+}

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

@@ -1,4 +1,4 @@
-// A symbol cannot collide with WeChat or Taro's string-named Page options, and it lets a later injection recover the exact
+// 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');
 /** Calls a native lifecycle with the same Page bound to `this` and the same arguments. */
@@ -30,7 +30,7 @@ export function injectPageHmr(config) {
         /*
          * `Page(config)` reads `config.data` as the initial native 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 WeChat never publishes the stale initial placeholder tree.
+         * 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.
          */
         config.data = mountedPage.data;
@@ -79,13 +79,13 @@ export function injectPageHmr(config) {
 const customWrapperCacheKey = Symbol.for('customWrapperCache');
 /**
  * Replaces stale Page.data placeholders with each mounted CustomWrapper's current native snapshot in at most one O(n)
- * traversal. This mutates only the registration data before WeChat reads it; it performs no setData call and does not
+ * traversal. This mutates only the registration data before the native host reads it; it performs no setData call and does not
  * inspect React.
  */
 function applyCustomWrapperSnapshots(data) {
-    const customWrapperCache = Reflect.get(global, customWrapperCacheKey);
+    const customWrapperCache = Reflect.get(globalThis, customWrapperCacheKey);
     if (!(customWrapperCache instanceof Map)) {
-        throw new Error('WX CustomWrapper cache is not installed in the App global.');
+        throw new Error('Mini Program CustomWrapper cache is not installed on the language global.');
     }
     if (customWrapperCache.size === 0) {
         return;

package/dist/runtime/{wx → mini}/dev/modes/interpreter/interpreter-protocol.d.ts

@@ -1,5 +1,5 @@
-import type { RuntimePatch } from '../../wx-hmr-runtime.ts';
-export declare const interpreterServerEvent = "vpt:wx-interpreter:source";
+import type { RuntimePatch } from '../../mini-hmr-runtime.ts';
+export declare const interpreterServerEvent = "vpt:hmr-interpreter:source";
 /** One Rolldown patch whose existing code field is interpreted instead of wrapped in a native factory. */
 export type InterpreterPatch = RuntimePatch & {
     readonly code: string;

package/dist/runtime/mini/dev/modes/interpreter/interpreter-protocol.js

@@ -0,0 +1 @@
+export const interpreterServerEvent = 'vpt:hmr-interpreter:source';

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

@@ -0,0 +1,12 @@
+import type { HmrInfo } from '../../hmr-protocol.ts';
+import { type ConnectMiniSocket, MiniHmrRuntime } from '../../mini-hmr-runtime.ts';
+/** Interprets cumulative patch source received by the shared App-level HMR socket. */
+declare class InterpreterHmrRuntime extends MiniHmrRuntime {
+    /** One installer and Sval scope retain interpreted factory closures for this App heap. */
+    private readonly installPatch;
+    constructor(connectSocket: ConnectMiniSocket);
+    protected onSocketEvent(info: HmrInfo, event: string, data: unknown): void;
+}
+/** Creates one platform-connected interpreter for installation by a thin target runtime entry. */
+export declare function createInterpreterHmrRuntime(connectSocket: ConnectMiniSocket): InterpreterHmrRuntime;
+export {};

package/dist/runtime/{wx → mini}/dev/modes/interpreter/interpreter-runtime.js

@@ -3,16 +3,22 @@
  * registration source, Sval evaluates it, and the shared runtime owns the retained socket, graph application, and reports.
  */
 import Sval from 'sval';
-import { WxHmrRuntime } from '../../wx-hmr-runtime.js';
+import { MiniHmrRuntime } from '../../mini-hmr-runtime.js';
 import { interpreterServerEvent } from './interpreter-protocol.js';
 /** Interprets cumulative patch source received by the shared App-level HMR socket. */
-class InterpreterHmrRuntime extends WxHmrRuntime {
+class InterpreterHmrRuntime extends MiniHmrRuntime {
     /** One installer and Sval scope retain interpreted factory closures for this App heap. */
     installPatch;
-    constructor() {
-        super();
+    constructor(connectSocket) {
+        super(connectSocket);
         const interpreter = new Sval();
         interpreter.import('__rolldown_runtime__', this);
+        /*
+         * Sval snapshots its sandbox built-ins while its module evaluates, before this runtime's base constructor can install
+         * Mini polyfills. Import the resulting host function explicitly so interpreted Rolldown Refresh wrappers resolve the
+         * same queue as physical chunks; otherwise their first free `queueMicrotask` lookup aborts the patch before registration.
+         */
+        interpreter.import('queueMicrotask', globalThis.queueMicrotask);
         this.installPatch = (patch) => interpreter.run(patch.code);
     }
     onSocketEvent(info, event, data) {
@@ -24,6 +30,7 @@ class InterpreterHmrRuntime extends WxHmrRuntime {
         }
     }
 }
-// The App-global singleton owns interpreted factory closures while its base owns socket, module cache, and Refresh boundaries.
-const runtime = new InterpreterHmrRuntime();
-globalThis.__rolldown_runtime__ = runtime;
+/** Creates one platform-connected interpreter for installation by a thin target runtime entry. */
+export function createInterpreterHmrRuntime(connectSocket) {
+    return new InterpreterHmrRuntime(connectSocket);
+}

package/dist/runtime/mini/dev/polyfill/polyfill-queue-microtask.d.ts

@@ -0,0 +1,14 @@
+type QueueMicrotask = (callback: () => void) => void;
+type QueueMicrotaskGlobal = {
+    queueMicrotask?: QueueMicrotask;
+};
+/**
+ * Polyfills the microtask primitive required by Rolldown's development React Refresh boundaries.
+ *
+ * Mini Program AppService engines do not share a `queueMicrotask` compatibility baseline, while every supported engine provides
+ * Promise jobs. Every target adapter constructs its selected development runtime before any application factory evaluates, so
+ * defining the primitive there covers WX and ZFB in every development mode. Reusing one resolved Promise preserves FIFO ordering
+ * without rewriting generated modules, delaying registration to a timer task, or adding unused code to production builds.
+ */
+export declare function polyfillQueueMicrotask(runtimeGlobal: QueueMicrotaskGlobal): void;
+export {};

package/dist/runtime/mini/dev/polyfill/polyfill-queue-microtask.js

@@ -0,0 +1,18 @@
+/**
+ * Polyfills the microtask primitive required by Rolldown's development React Refresh boundaries.
+ *
+ * Mini Program AppService engines do not share a `queueMicrotask` compatibility baseline, while every supported engine provides
+ * Promise jobs. Every target adapter constructs its selected development runtime before any application factory evaluates, so
+ * defining the primitive there covers WX and ZFB in every development mode. Reusing one resolved Promise preserves FIFO ordering
+ * without rewriting generated modules, delaying registration to a timer task, or adding unused code to production builds.
+ */
+export function polyfillQueueMicrotask(runtimeGlobal) {
+    if (runtimeGlobal.queueMicrotask !== undefined)
+        return;
+    const resolvedPromise = Promise.resolve();
+    // This is the one intentional global mutation: every independently bundled development chunk must resolve the same host
+    // primitive, and assigning the real global is the only scope shared by the injected runtime and later application factories.
+    runtimeGlobal.queueMicrotask = (callback) => {
+        void resolvedPromise.then(callback);
+    };
+}

package/dist/runtime/{wx → mini}/native/page.js

@@ -1,4 +1,4 @@
 import '../amphibious/bootstrap.js';
-// @ts-expect-error: The wx build resolves the route-specific Page capsule.
+// @ts-expect-error: The active Mini contract resolves the route-specific Page capsule.
 import pageConfig from '\0vpt:page-capsule';
 Page(pageConfig);

package/dist/runtime/{wx → mini}/systemjs/system-core.js

@@ -14,7 +14,6 @@
  * Core comes with no System.prototype.resolve or
  * System.prototype.instantiate implementations
  */
-var envGlobal = global;
 var hasSymbol = typeof Symbol !== 'undefined';
 function createMissingRegistrationError(id) {
     return Error('Module did not instantiate: ' + id);
@@ -36,7 +35,7 @@ systemJSPrototype.import = function (id, parentId, meta) {
 /**
  * Instantiates, links, and evaluates a graph without yielding the current JavaScript turn.
  *
- * WX placement guarantees that every registration in a synchronous graph uses the main-package transport. Encountering
+ * Mini Program placement guarantees that every registration in a synchronous graph uses the main-package transport. Encountering
  * a thenable therefore indicates a fatal placement invariant violation. No rollback is attempted: rows already published
  * to the shared registry remain there and the current runtime heap must not be reused.
  */
@@ -327,5 +326,5 @@ function postOrderExec(loader, load, seen) {
         }
     }
 }
-envGlobal.System = new SystemJS();
+globalThis.System = new SystemJS();
 // biome-ignore-end lint: vendored SystemJS core

package/dist/runtime/wx/dev/connect-wx-socket.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectMiniSocket } from '../../mini/dev/mini-hmr-runtime.ts';
+/** Opens the task-scoped Vite socket through the WeChat native API. */
+export declare const connectWxSocket: ConnectMiniSocket;

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

@@ -0,0 +1,2 @@
+/** Opens the task-scoped Vite socket through the WeChat native API. */
+export const connectWxSocket = (endpoint) => wx.connectSocket({ url: endpoint, protocols: ['vite-hmr'] });

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

@@ -0,0 +1,5 @@
+import { createDevtoolsHmrRuntime } from '../../mini/dev/modes/devtools/devtools-runtime.js';
+import { connectWxSocket } from './connect-wx-socket.js';
+// Rolldown reads this singleton as a free identifier, so install it on the language global. It survives Page shell
+// re-evaluation and owns the retained module graph.
+Reflect.set(globalThis, '__rolldown_runtime__', createDevtoolsHmrRuntime(connectWxSocket));

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

@@ -0,0 +1,5 @@
+import { createInterpreterHmrRuntime } from '../../mini/dev/modes/interpreter/interpreter-runtime.js';
+import { connectWxSocket } from './connect-wx-socket.js';
+// Rolldown reads this singleton as a free identifier, so install it on the language global. It retains interpreted factories,
+// the socket, module cache, and Refresh boundaries.
+Reflect.set(globalThis, '__rolldown_runtime__', createInterpreterHmrRuntime(connectWxSocket));

package/dist/runtime/zfb/dev/connect-zfb-socket.d.ts

@@ -0,0 +1,10 @@
+import type { ConnectMiniSocket } from '../../mini/dev/mini-hmr-runtime.ts';
+/**
+ * Opens an independent Alipay socket and adapts its receive envelope to the shared Mini runtime.
+ *
+ * Alipay reports inbound text as `{ message }`, whereas WeChat and the internal socket contract use `{ data }`. Without this
+ * adapter the WebSocket frame remains visible in DevTools, but the shared listener reads `undefined`, classifies it as non-text,
+ * and returns without evaluating the interpreter patch or logging an error. Vite sends only JSON text, so no binary conversion is
+ * needed here.
+ */
+export declare const connectZfbSocket: ConnectMiniSocket;

package/dist/runtime/zfb/dev/connect-zfb-socket.js

@@ -0,0 +1,18 @@
+/**
+ * Opens an independent Alipay socket and adapts its receive envelope to the shared Mini runtime.
+ *
+ * Alipay reports inbound text as `{ message }`, whereas WeChat and the internal socket contract use `{ data }`. Without this
+ * adapter the WebSocket frame remains visible in DevTools, but the shared listener reads `undefined`, classifies it as non-text,
+ * and returns without evaluating the interpreter patch or logging an error. Vite sends only JSON text, so no binary conversion is
+ * needed here.
+ */
+export const connectZfbSocket = (endpoint) => {
+    const socket = my.connectSocket({ url: endpoint, multiple: true, protocols: ['vite-hmr'] });
+    return {
+        send: (options) => socket.send(options),
+        close: (options) => socket.close(options),
+        onMessage: (listener) => {
+            socket.onMessage(({ message }) => listener({ data: message }));
+        }
+    };
+};

package/dist/runtime/zfb/dev/devtools-runtime.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/zfb/dev/devtools-runtime.js

@@ -0,0 +1,5 @@
+import { createDevtoolsHmrRuntime } from '../../mini/dev/modes/devtools/devtools-runtime.js';
+import { connectZfbSocket } from './connect-zfb-socket.js';
+// Rolldown reads this singleton as a free identifier, so install it on the language global. It survives Page shell
+// re-evaluation and owns the retained module graph.
+Reflect.set(globalThis, '__rolldown_runtime__', createDevtoolsHmrRuntime(connectZfbSocket));

package/dist/runtime/zfb/dev/interpreter-runtime.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/zfb/dev/interpreter-runtime.js

@@ -0,0 +1,5 @@
+import { createInterpreterHmrRuntime } from '../../mini/dev/modes/interpreter/interpreter-runtime.js';
+import { connectZfbSocket } from './connect-zfb-socket.js';
+// Rolldown reads this singleton as a free identifier, so install it on the language global. It retains interpreted factories,
+// the socket, module cache, and Refresh boundaries.
+Reflect.set(globalThis, '__rolldown_runtime__', createInterpreterHmrRuntime(connectZfbSocket));

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.6.20",
+  "version": "0.7.0",
   "author": "sep2",
-  "description": "Vite 8 plugin for building one React/Taro codebase for WeChat Mini Program and H5 targets.",
+  "description": "Vite 8 plugin for building one React/Taro codebase for WeChat, Alipay, and H5 targets.",
   "type": "module",
   "repository": {
     "type": "git",
@@ -42,6 +42,7 @@
     "vite-plugin",
     "taro",
     "wechat",
+    "alipay",
     "mini-program",
     "react"
   ],
@@ -58,16 +59,17 @@
     "@tailwindcss/vite": "4.3.3",
     "@tarojs/components": "4.2.1",
     "@tarojs/helper": "4.2.1",
-    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.6.20",
+    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.7.0",
+    "@tarojs/plugin-platform-alipay": "4.2.1",
     "@tarojs/plugin-platform-h5": "4.2.1",
     "@tarojs/plugin-platform-weapp": "4.2.1",
-    "@tarojs/react": "npm:vite-plugin-taro-react@0.6.20",
+    "@tarojs/react": "npm:vite-plugin-taro-react@0.7.0",
     "@tarojs/router": "4.2.1",
-    "@tarojs/runtime": "npm:vite-plugin-taro-runtime@0.6.20",
+    "@tarojs/runtime": "npm:vite-plugin-taro-runtime@0.7.0",
     "@tarojs/taro": "4.2.1",
-    "@vitejs/plugin-react": "^6.1.0",
+    "@vitejs/plugin-react": "^6.1.1",
     "react-reconciler": "0.33.0",
-    "rolldown": "1.2.5",
+    "rolldown": "1.2.7",
     "sval": "0.6.12",
     "tailwindcss": "^4.3.3"
   },
@@ -83,7 +85,7 @@
     "@babel/plugin-transform-modules-commonjs": "^8.0.1",
     "@babel/plugin-transform-modules-systemjs": "^8.0.1",
     "@babel/types": "^8.0.4",
-    "@oxc-project/types": "0.147.0",
+    "@oxc-project/types": "0.148.0",
     "@rolldown/plugin-babel": "^0.2.3",
     "@tailwindcss-mangle/engine": "0.2.0",
     "@types/node": "^26.3.0",

package/dist/node/plugins/wx/dev/dev-host.d.ts

@@ -1,29 +0,0 @@
-import type { ViteDevServer } from 'vite';
-import type { VptOptions } from '../../../../options.ts';
-import { type RuntimeControlMessage, type RuntimeReport } from '../../../../runtime/wx/dev/wx-hmr-protocol.ts';
-import type { WxStylePlugin } from '../styles/plugins.ts';
-import type { WxHmrMode } from './hmr-mode.ts';
-declare module 'vite' {
-    interface CustomEventMap {
-        'vpt:wx-hmr:control': RuntimeControlMessage;
-        'vpt:wx-hmr:report': RuntimeReport;
-    }
-}
-export type WxDevHost = Readonly<{
-    close: () => Promise<void>;
-}>;
-/**
- * Creates the WX dev host: the adapter that owns the physical Rolldown DevEngine, shared patch journal, and selected mode effects.
- * It replaces Vite's browser-oriented `bundledDev.listen()` because a Mini Program cannot execute Vite's browser module graph;
- * its engine must write a complete native project while the selected mode supplies an environment-valid patch mechanism.
- *
- * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
- * every live import edge. Keeping those responsibilities in the same serialized host transaction prevents JavaScript factories,
- * physical WXSS, and Rolldown's published frontier from describing different source generations.
- */
-export declare function createWxDevHost({ server, options, styles, hmrMode }: {
-    server: ViteDevServer;
-    options: VptOptions;
-    styles: WxStylePlugin;
-    hmrMode: WxHmrMode;
-}): Promise<WxDevHost>;

package/dist/node/plugins/wx/dev/hmr-mode.d.ts

@@ -1,31 +0,0 @@
-import type { Plugin } from 'vite';
-import type { VptHmrOptions } from '../../../../options.ts';
-import type { PatchPublication } from './hmr-protocol.ts';
-/** One mode-selected effect executed by the development host. */
-export type WxHmrAction = Readonly<{
-    kind: 'event';
-    event: string;
-    data: unknown;
-}> | Readonly<{
-    kind: 'write';
-    fileName: string;
-    source: string;
-}>;
-/**
- * The behavior that genuinely differs between WX HMR implementations.
- *
- * The descriptor is selected once during plugin composition and returns declarative effects. The shared host alone performs
- * physical writes and event transport, so neither mode receives a Vite server or owns asynchronous infrastructure.
- */
-export type WxHmrMode = Readonly<{
-    runtimeFile: string;
-    plugins: readonly Plugin[];
-    reset: () => WxHmrAction | undefined;
-    publish: (publication: PatchPublication) => WxHmrAction;
-    createEntryBanner: (pageFiles: ReadonlySet<string>) => (chunk: Readonly<{
-        name: string;
-        fileName: string;
-    }>) => string;
-}>;
-/** Resolves exactly one implementation before the WX development host is created. */
-export declare function createWxHmrMode(options: VptHmrOptions | undefined): WxHmrMode;

package/dist/node/plugins/wx/dev/modes/interpreter/interpreter-hmr-mode.d.ts

@@ -1,3 +0,0 @@
-import type { WxHmrMode } from '../../hmr-mode.ts';
-/** Creates the pure interpreter adapter whose events are dispatched by the shared development host. */
-export declare function createInterpreterHmrMode(): WxHmrMode;

package/dist/node/plugins/wx/dev/plugins.d.ts

@@ -1,32 +0,0 @@
-import { type PluginOption } from 'vite';
-import type { VptOptions } from '../../../../options.ts';
-import type { WxStylePlugin } from '../styles/plugins.ts';
-/** Selects the sole Vite environment that owns the physical Mini Program development project. */
-export declare function isWxClientEnvironment(environment: Readonly<{
-    name: string;
-}>): boolean;
-/**
- * Adds the serve-only bundled-development plugin set for the wx target: the shared dev adapter, selected HMR mode, and React
- * Refresh adaptation transforms.
- *
- * The shared style pipeline already owns the resolver's ordered App/Page cascade policy, so the host does not reconstruct it
- * from unrelated Rolldown shell and transport entries.
- */
-export declare function createWxDevelopmentPlugin(options: VptOptions, styles: WxStylePlugin): PluginOption[];
-/**
- * Transfers development ownership of `app.wxss` from complete output to the dev host.
- *
- * The ordinary WX output hook emits the static production wrapper during every complete build. In development, the existing
- * physical wrapper instead contains the previous build ID. If the static asset remained in this bundle, the DevEngine would:
- *
- * 1. replace the versioned wrapper with static production bytes while JavaScript and HMR metadata are still being finalized;
- * 2. let DevTools observe that root-style change and reload the App against the previous build identity;
- * 3. let the host replace the wrapper again with the new build ID, causing a second App reload.
- *
- * Deleting only the in-memory bundle entry avoids both premature writes. Development sets `emptyOutDir: false`, so the prior
- * physical `app.wxss` remains available while the complete output is written. The host replaces it exactly once after the
- * selected mode has reset and the matching `hmr/info.js` identity is durable. Incremental HMR never enters this complete-
- * output hook and changes only `assets/global.wxss`; rewriting the App root would reload the heap while a JavaScript patch is
- * awaiting acknowledgement. The serve-only plugin leaves production output unchanged.
- */
-export declare function removeDevelopmentAppWxss(bundle: Record<string, unknown>): void;