vite-plugin-taro 0.6.20-beta.2 → 0.6.20

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

@@ -0,0 +1,107 @@
+import type { DevRuntime as RolldownDevRuntime } from 'rolldown/experimental/runtime-types';
+import { type HmrInfo } from './wx-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. */
+export type RuntimePatch = Readonly<{
+    seq: number;
+    /** Stable ids of the changed modules; synchronous application walks the graph from these roots. */
+    changedIds: readonly string[];
+}>;
+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 {
+    readonly _internal: Readonly<{
+        updateStyle(): void;
+        removeStyle(): void;
+    }>;
+    /**
+     * 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.
+     */
+    private acceptCallbacks;
+    /** 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>);
+    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 {
+    /**
+     * 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.
+     */
+    private session;
+    /** The App heap's sole SocketTask, assigned once by initialize and retained for its lifetime. */
+    private socket;
+    /**
+     * 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).
+     */
+    private readonly moduleHotContexts;
+    constructor();
+    /**
+     * 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;
+    /** Computes accepting boundaries and every executed module that must be re-armed. */
+    private computeHmrUpdate;
+    /** Walks executed importers until an accepting boundary is found. */
+    private bubble;
+    /**
+     * Applies one patch in three phases: capture old contexts, evict the whole update set,
+     * then re-run accepting modules and pass their fresh exports to the old contexts.
+     */
+    private applyHmrUpdate;
+    /**
+     * Initializes exactly once per App heap. Repeated entry evaluation must not replace the identity or reset `appliedSeq`, because
+     * either change could acknowledge factories against another host client or replay already committed application generations.
+     */
+    initialize(info: HmrInfo): void;
+    /** Receives mode-specific Vite custom events after shared control messages have been handled. */
+    protected onSocketEvent(_info: HmrInfo, _event: string, _data: unknown): void;
+    /** Sends one typed Vite custom event through the current App-level socket. */
+    protected sendSocketEvent(event: string, data: unknown): void;
+    /** Closes the sole socket after terminal host control or interpreter failure. */
+    protected stopSocket(reason: string): void;
+    /**
+     * Applies one mode-delivered cumulative payload through its mode-specific patch installer.
+     *
+     * Application is deliberately synchronous so every later message observes the committed module generation. The installer is
+     * the only mode seam; sequence validation and ACK reporting stay here so no mode can mistake delivery for application.
+     */
+    protected applyPatchPayload<Patch extends RuntimePatch>(payload: Readonly<{
+        buildId: string;
+        patches: readonly Patch[];
+    }>, installPatch: (patch: Patch) => void): boolean;
+    /**
+     * Folds one cumulative mode delivery into a single logical HMR update.
+     *
+     * A delivery may contain several unacknowledged application patches and may be replayed by its mode—for DevTools, every
+     * affected live Page evaluates the same physical file. The runtime therefore ignores old sequences, rejects a missing one,
+     * and moves directly from the live module generation to the latest published one without intermediate renders.
+     *
+     * For an appliedSeq of 4:
+     *
+     * - [5, 6, 7] installs every patch, applies their unioned changedIds, commits appliedSeq 7, and reports 7;
+     * - a replay of [5, 6, 7] leaves the latest factories untouched;
+     * - [5, 7] fails at expected sequence 6, keeps appliedSeq 4, and requests a complete rebuild.
+     */
+    private applyPatchBatch;
+    /** Sends one application-frontier or rebuild report through the shared Vite WebSocket. */
+    private sendReport;
+}
+export {};

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

@@ -1,18 +1,12 @@
-// WX dev runtime — bundled and injected verbatim at the end of the shared Rolldown
-// runtime chunk (`assets/rolldown-runtime.js`, required first by every chunk). Defines the
-// App-global `__rolldown_runtime__` that generated modules call.
-//
-// The `DevRuntime` base class is injected into the chunk by Rolldown's dev-mode
-// transform, so the WX host only extends it.
-//
-// Every Page explicitly passes the inert hmr/patches.js export here before native Page registration. The runtime applies that
-// cumulative suffix synchronously, reports its successful application frontier, and ignores sequences replayed by other Pages.
-const pageHmrStateKey = Symbol('vpt.pageHmrState');
-/** Calls a native lifecycle with the same Page bound to `this` and the same arguments. */
-function forward(handler, page, args) {
-    if (typeof handler === 'function')
-        handler.apply(page, args);
-}
+/*
+ * Shared WX 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';
 /** Shared no-op CSS contract because physical rebuilds replace styles wholesale. */
 const hotContextInternals = Object.freeze({
     updateStyle() { },
@@ -62,13 +56,15 @@ class WxHotContext {
     // rebuild replaces styles wholesale, so it is a no-op.
     prune(_callback) { }
 }
-/** The WX host: extends the Rolldown contract instead of reimplementing it. */
-class WxDevRuntime extends DevRuntime {
+/** Shared WX host mechanics extending the Rolldown contract instead of reimplementing it. */
+export class WxHmrRuntime extends DevRuntime {
     /**
-     * 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.
+     * 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.
      */
     session;
+    /** The App heap's sole SocketTask, assigned once by initialize and retained for its lifetime. */
+    socket;
     /**
      * Sparse current-generation accepting boundaries keyed by module id. Entries alone must
      * outlive Rolldown module-cache eviction so old callbacks can receive fresh exports.
@@ -159,112 +155,82 @@ class WxDevRuntime extends DevRuntime {
             hotContext?.runAccept(this.initModule(moduleId));
         }
     }
-    /** Consumed once per App heap from hmr/info.js; the host buildId identifies its cumulative patch history. */
+    /**
+     * Initializes exactly once per App heap. Repeated entry evaluation must not replace the identity or reset `appliedSeq`, because
+     * either change could acknowledge factories against another host client or replay already committed application generations.
+     */
     initialize(info) {
         if (this.session)
             return;
-        this.session = { ...info, appliedSeq: 0 };
-    }
-    /** Tracks the mounted native Page and prepares its static config for HMR re-registration. */
-    injectPageHmr(config) {
-        const existingState = config[pageHmrStateKey];
-        if (existingState) {
-            const mountedPage = existingState.mountedPage;
-            /*
-             * 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.
-             */
-            if (!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 object, so no route map, global phase, or Page identity comparison participates in the decision.
-             */
-            existingState.isReregistering = true;
-            /*
-             * `Page(config)` reads `config.data` as the initial native view-model for this registration. Supplying the mounted
-             * Page's latest data before that call prevents the temporary Page used for re-registration callbacks from starting
-             * empty. This is an O(1) reference assignment in vpt: it does not clone the recursive data tree, call `setData`, move
-             * React state, or rebind Taro. The ordinary Taro lifecycle remains suppressed until re-registration onShow, so its
-             * React tree and output connection stay attached to `mountedPage`; every later registration reads its latest data.
-             */
-            config.data = mountedPage.data;
-            return config;
-        }
-        const originalOnUnload = config.onUnload;
-        const originalOnLoad = config.onLoad;
-        const originalOnShow = config.onShow;
-        const state = {
-            isReregistering: false,
-            mountedPage: undefined
-        };
-        /*
-         * Attach the one mutable HMR state object to this exact static config. The lifecycle wrappers below close over the same
-         * object, while a later `injectPageHmr(config)` call finds it through the symbol and knows wrapping is already complete.
-         * A symbol cannot collide with WeChat or Taro's string-named Page options, and config-local ownership avoids route maps,
-         * a runtime-wide WeakMap, or state shared by two Page configs. The state becomes unreachable together with the config.
-         */
-        config[pageHmrStateKey] = state;
-        config.onUnload = function (...args) {
-            if (state.isReregistering) {
+        this.session = { buildId: info.buildId, appliedSeq: 0 };
+        const socket = wx.connectSocket({ url: info.endpoint, protocols: ['vite-hmr'] });
+        this.socket = socket;
+        socket.onMessage(({ data }) => {
+            if (typeof data !== 'string')
                 return;
-            }
-            forward(originalOnUnload, this, args);
-            state.mountedPage = undefined;
-        };
-        config.onLoad = function (...args) {
-            if (state.isReregistering) {
+            const message = JSON.parse(data);
+            if (message.type !== 'custom' || !message.event)
                 return;
-            }
-            forward(originalOnLoad, this, args);
-            state.mountedPage = this;
-        };
-        config.onShow = function (...args) {
-            if (state.isReregistering) {
-                state.isReregistering = false;
+            if (message.event === runtimeControlEvent) {
+                const control = message.data;
+                this.stopSocket(control.reason);
                 return;
             }
-            forward(originalOnShow, this, args);
-        };
-        return config;
+            this.onSocketEvent(info, message.event, message.data);
+        });
     }
-    /** Applies one Page-delivered payload before its native shell registers the static route configuration. */
-    applyPatches(payload) {
-        // The initial physical dependency exports undefined until the host has a patch range.
-        if (!payload)
-            return;
+    /** Receives mode-specific Vite custom events after shared control messages have been handled. */
+    onSocketEvent(_info, _event, _data) { }
+    /** Sends one typed Vite custom event through the current App-level socket. */
+    sendSocketEvent(event, data) {
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error('WX HMR socket is not initialized');
+        }
+        socket.send({ data: JSON.stringify({ type: 'custom', event: event, data: data }) });
+    }
+    /** Closes the sole socket after terminal host control or interpreter failure. */
+    stopSocket(reason) {
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error('WX HMR socket is not initialized');
+        }
+        socket.close({ code: 1000, reason: reason });
+    }
+    /**
+     * Applies one mode-delivered cumulative payload through its mode-specific patch installer.
+     *
+     * Application is deliberately synchronous so every later message observes the committed module generation. The installer is
+     * the only mode seam; sequence validation and ACK reporting stay here so no mode can mistake delivery for application.
+     */
+    applyPatchPayload(payload, installPatch) {
         const session = this.session;
         if (!session || payload.buildId !== session.buildId) {
             console.warn('[vpt] patches for a stale build');
-            return;
+            return false;
         }
-        // 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(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.
+        const applied = this.applyPatchBatch(session, payload.patches, installPatch);
+        if (applied) {
+            // The host may publish later generations while synchronous application runs. Reporting only afterward makes this the
+            // application frontier: journal history is never pruned merely because a delivery became observable.
             void this.sendReport({ kind: 'applied', seq: session.appliedSeq });
         }
+        return applied;
     }
     /**
-     * Folds one cumulative physical patch file into a single logical HMR update.
+     * Folds one cumulative mode delivery into a single logical HMR update.
      *
-     * `hmr/patches.js` can contain several unacknowledged application patches and can be required by several Page shells. The
-     * runtime must therefore ignore replayed sequences, reject a missing sequence, and move directly from the currently live
-     * module generation to the latest published generation without rendering intermediate generations.
+     * A delivery may contain several unacknowledged application patches and may be replayed by its mode—for DevTools, every
+     * affected live Page evaluates the same physical file. The runtime therefore ignores old sequences, rejects a missing one,
+     * and moves directly from the live module generation to the latest published one without intermediate renders.
      *
      * For an appliedSeq of 4:
      *
-     * - [5, 6, 7] registers every factory, performs one update using their unioned changedIds, commits appliedSeq 7, and reports 7;
-     * - 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.
+     * - [5, 6, 7] installs every patch, applies their unioned changedIds, commits appliedSeq 7, and reports 7;
+     * - a replay of [5, 6, 7] leaves the latest factories untouched;
+     * - [5, 7] fails at expected sequence 6, keeps appliedSeq 4, and requests a complete rebuild.
      */
-    applyPatchBatch(session, patches) {
+    applyPatchBatch(session, patches, installPatch) {
         // 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 = session.appliedSeq;
@@ -274,19 +240,19 @@ class WxDevRuntime extends DevRuntime {
         const changedIds = new Set();
         try {
             for (const patch of patches) {
-                // The same physical file is evaluated once per affected Page. Those later evaluations replay its prefix and
-                // must not let an old factory overwrite the newer factory already stored in the Rolldown runtime.
+                // Replayed delivery prefixes must not let an old installation overwrite newer factories already stored in the
+                // Rolldown runtime.
                 if (patch.seq <= previousSeq) {
                     continue;
                 }
-                // Every patch is incremental: if one physical write was missed, later factories cannot reconstruct modules
-                // changed only by that missing patch. Rebuilding is safer than silently running a mixed module generation.
+                // Every patch is incremental: if one delivery was missed, later patches cannot reconstruct modules changed only
+                // by that missing sequence. Rebuilding is safer than silently running a mixed module generation.
                 if (patch.seq !== nextSeq) {
                     throw new Error(`missing patch sequence ${nextSeq}`);
                 }
-                // A patch factory only registers module graphs and module factories; it does not execute application modules.
-                // Running all of them first leaves the registry at the latest generation while avoiding intermediate renders.
-                patch.factory();
+                // Mode installation registers module graphs and factories without executing application modules. Running every
+                // installer first leaves the registry at the latest generation while avoiding intermediate renders.
+                installPatch(patch);
                 for (const changedId of patch.changedIds) {
                     changedIds.add(changedId);
                 }
@@ -298,7 +264,7 @@ class WxDevRuntime extends DevRuntime {
             }
             // Apply once after every factory is registered. React Refresh arms a newly executed module's hot.accept callback
             // in a microtask; applying consecutive patches separately would inspect that intermediate context too early and
-            // incorrectly bubble through the capsule to the native Page shell as though no HMR boundary existed.
+            // incorrectly bubble through the accepting capsule as though no HMR boundary existed.
             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.
@@ -306,6 +272,8 @@ class WxDevRuntime extends DevRuntime {
             return true;
         }
         catch (error) {
+            // An installer may already have replaced some factories and the module registry has no inverse operation. Keep the
+            // old application watermark unacknowledged and request a complete build, the only coherent rollback boundary.
             console.warn('[vpt] patch batch failed; apply stopped', error);
             void this.sendReport({
                 kind: 'rebuild',
@@ -314,7 +282,7 @@ class WxDevRuntime extends DevRuntime {
             return false;
         }
     }
-    /** Sends one metadata-only report to the host; executable code never travels over HTTP. */
+    /** Sends one application-frontier or rebuild report through the shared Vite WebSocket. */
     sendReport(data) {
         const session = this.session;
         if (!session) {
@@ -322,22 +290,7 @@ class WxDevRuntime extends DevRuntime {
             // silently dropping the sync traffic.
             throw new Error('WX dev runtime is not initialized');
         }
-        return new Promise((resolve, reject) => {
-            wx.request({
-                url: session.endpoint,
-                method: 'POST',
-                data: { buildId: session.buildId, ...data },
-                header: { 'content-type': 'application/json' },
-                success() {
-                    resolve();
-                },
-                fail(error) {
-                    reject(error);
-                }
-            });
-        });
+        const report = { buildId: session.buildId, ...data };
+        this.sendSocketEvent(runtimeReportEvent, report);
     }
 }
-const runtime = new WxDevRuntime();
-globalThis.__rolldown_runtime__ = runtime;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.6.20-beta.2",
+  "version": "0.6.20",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat Mini Program and H5 targets.",
   "type": "module",
@@ -58,16 +58,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-beta.2",
+    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.6.20",
     "@tarojs/plugin-platform-h5": "4.2.1",
     "@tarojs/plugin-platform-weapp": "4.2.1",
-    "@tarojs/react": "npm:vite-plugin-taro-react@0.6.20-beta.2",
+    "@tarojs/react": "npm:vite-plugin-taro-react@0.6.20",
     "@tarojs/router": "4.2.1",
-    "@tarojs/runtime": "npm:vite-plugin-taro-runtime@0.6.20-beta.2",
+    "@tarojs/runtime": "npm:vite-plugin-taro-runtime@0.6.20",
     "@tarojs/taro": "4.2.1",
     "@vitejs/plugin-react": "^6.1.0",
     "react-reconciler": "0.33.0",
     "rolldown": "1.2.5",
+    "sval": "0.6.12",
     "tailwindcss": "^4.3.3"
   },
   "peerDependencies": {

package/dist/node/plugins/wx/dev/patch-publisher.d.ts

@@ -1,42 +0,0 @@
-import { type PatchUpdate } from './hmr-files.ts';
-/** Abstracts the physical patches write; the engine owns the file destination. */
-type WritePatches = (content: string) => Promise<void>;
-/**
- * Owns the cumulative sequence range between the host's published frontier and the runtime's applied frontier.
- *
- * For example, if the runtime has applied sequence 4:
- *
- * 1. produce([5, 6]) writes [5, 6];
- * 2. produce([7]) before an application report writes [5, 6, 7], so DevTools may miss the first file event safely;
- * 3. acknowledge(6) retains [7];
- * 4. produce([8]) then writes [7, 8], exactly the suffix the runtime still needs.
- *
- * The host may advance Rolldown's published frontier through 8 immediately after those writes, but this history is pruned only
- * through 6 until the runtime reports successful application. Published sequence and applied sequence are deliberately distinct.
- */
-export declare class PatchPublisher {
-    private readonly writePatches;
-    private buildId;
-    private readonly pendingPatches;
-    constructor(writePatches: WritePatches);
-    /** True when the buildId belongs to the current full build. */
-    isCurrentBuild(buildId: string): boolean;
-    /** Begins a fresh build and returns both sides of the client-session rotation. */
-    startBuild(): Readonly<{
-        buildId: string;
-        previousBuildId: string | undefined;
-    }>;
-    /**
-     * Appends a Rolldown batch and publishes the complete range not yet applied by the runtime.
-     *
-     * Resolution means the cumulative JavaScript generation is physically visible. The host may then advance Rolldown's
-     * published frontier immediately; pendingPatches remains intact until an application report proves the runtime caught up.
-     */
-    produce(patches: readonly PatchUpdate[]): Promise<void>;
-    /**
-     * Removes only the prefix covered by the runtime's successful application frontier. Publication alone never calls this:
-     * retaining the gap between published and applied frontiers is what lets DevTools safely miss intermediate file events.
-     */
-    acknowledge(seq: number): void;
-}
-export {};

package/dist/node/plugins/wx/dev/runtime-reports.d.ts

@@ -1,27 +0,0 @@
-import { type SchedulerLike, Subject } from 'rxjs';
-type AppliedReport = Readonly<{
-    kind: 'applied';
-    buildId: string;
-    seq: number;
-}>;
-/** The runtime hit an unrecoverable state and needs a complete build. */
-type RebuildReport = Readonly<{
-    kind: 'rebuild';
-    buildId: string;
-    reason: string;
-}>;
-export type RuntimeReport = AppliedReport | RebuildReport;
-/**
- * Conflates runtime receipts without weakening their build identity or recovery semantics.
- *
- * Reports are metadata frontiers rather than executable deltas: for one build, the highest applied sequence subsumes lower and
- * duplicate acknowledgements. A rebuild does not subsume reports from a different build, because delayed Pages may still POST
- * after session rotation, but it dominates every acknowledgement for its own build. The host validates each retained build ID
- * against the physical publisher only when its serialized task executes, preserving rotation order.
- *
- * Completing the Subject flushes the active window synchronously so shutdown can include its host task before closing Rolldown.
- * Reduction is O(reports) time and O(distinct builds) retained space per quiet window.
- */
-export declare function createRuntimeReportsStream(settleMilliseconds: number, scheduler: SchedulerLike, publish: (reports: readonly RuntimeReport[]) => void): Subject<RuntimeReport>;
-export declare function reduceRuntimeReportWindow(window: readonly RuntimeReport[]): readonly RuntimeReport[];
-export {};