vite-plugin-taro 0.5.4 → 0.5.6

package/src/runtime/wx/capsule/page.ts

@@ -26,18 +26,23 @@ function forward(handler: unknown, receiver: unknown, args: unknown[]): void {
     ;(handler as LifecycleHandler | undefined)?.apply(receiver, args)
 }
 
-/** The surviving page identity: its unique path and params. */
-type PageIdentity = {
+/** The old native projection retained while DevTools replaces its Page instance. */
+type PageSnapshot = {
     $taroPath: string
     $taroParams: Record<string, unknown>
+    data: Record<string, unknown>
+}
+
+type NativePage = PageSnapshot & {
+    setData(data: Record<string, unknown>): void
 }
 
 // DevTools re-executes the page and replays the replacement lifecycle on every edit. Taro's
 // onUnload unmounts the React tree and onLoad mounts a fresh one, destroying state. While
 // the runtime says a patch was just delivered, the pair is intercepted instead: onUnload
-// captures the surviving page identity, and onLoad restores it onto the replacement native
-// instance and rebinds the retained tree to it (pageElement.ctx + a full re-render). The
-// capsule module is cached across re-executions, so this closure holds the capture.
+// captures the surviving page identity and its current native render data, and onLoad
+// immediately paints that snapshot before rebinding and fully synchronizing the retained
+// tree. The capsule module is cached across re-executions, so this closure holds the capture.
 // Ordinary navigation (no patch) passes through unchanged. The wrappers are regular
 // functions so the native page instance (`this`) reaches the original handlers.
 if (typeof __rolldown_runtime__ !== 'undefined') {
@@ -45,14 +50,19 @@ if (typeof __rolldown_runtime__ !== 'undefined') {
     const originalOnLoad = config.onLoad
     const originalOnShow = config.onShow
 
-    let captured: PageIdentity | undefined
+    // This is the sole cross-instance handoff. It is mutable because DevTools destroys the
+    // old native Page before creating its replacement; ordinary navigation never reads it.
+    let captured: PageSnapshot | undefined
 
     config.onUnload = function (this: unknown, ...args: unknown[]) {
         if (__rolldown_runtime__.isHotReloading()) {
-            const instance = this as unknown as PageIdentity
+            const instance = this as unknown as NativePage
             captured = {
                 $taroPath: instance.$taroPath,
-                $taroParams: instance.$taroParams
+                $taroParams: instance.$taroParams,
+                // WeChat owns this serializable view-model snapshot. Retaining it is cheaper
+                // than deep-cloning the complete recursive Taro node tree before every edit.
+                data: instance.data
             }
             return
         }
@@ -60,10 +70,14 @@ if (typeof __rolldown_runtime__ !== 'undefined') {
     }
     config.onLoad = function (this: unknown, ...args: unknown[]) {
         if (__rolldown_runtime__.isHotReloading() && captured) {
+            const instance = this as unknown as NativePage
+            // Paint the last native projection as the first bridge operation. Taro's full
+            // performUpdate below runs in a timer, so this direct setData removes most of the
+            // empty-page interval without delaying synchronization to the current tree.
+            instance.setData(captured.data)
             // Restore the surviving page identity onto the replacement native instance: the
             // re-loaded $taroPath embeds a fresh timestamp, so without this the tree and the
             // native side would disagree on the page key.
-            const instance = this as unknown as PageIdentity
             instance.$taroPath = captured.$taroPath
             instance.$taroParams = captured.$taroParams
             // Rebind the retained tree to the replacement receiver and resync the native

package/src/runtime/wx/dev/dev-runtime.ts

@@ -5,9 +5,8 @@
 // The `DevRuntime` base class is injected into the chunk by Rolldown's dev-mode
 // transform, so the WX host only extends it.
 //
-// Delivery is passive: every valid hmr/patches.js suffix is acknowledged by Rolldown
-// sequence, then applied synchronously before the Page continues evaluating. Already-applied
-// sequences are ignored when another Page requires the same physical file.
+// 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.
 
 import type { DevRuntime as RolldownDevRuntime } from 'rolldown/experimental/runtime-types'
 
@@ -110,7 +109,7 @@ class WxDevRuntime extends DevRuntime {
     }
 
     /** Computes accepting boundaries and every executed module that must be re-armed. */
-    private computeHmrUpdate(changedIds: readonly string[]): HmrUpdate | undefined {
+    private computeHmrUpdate(changedIds: Iterable<string>): HmrUpdate | undefined {
         // Mutable traversal accumulators are confined to one synchronous update plan.
         const boundaries: string[] = []
         const updateSet = new Set<string>()
@@ -166,7 +165,7 @@ class WxDevRuntime extends DevRuntime {
      * 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(changedIds: readonly string[]): void {
+    private applyHmrUpdate(changedIds: Iterable<string>): void {
         const update = this.computeHmrUpdate(changedIds)
         if (!update) return
 
@@ -195,14 +194,12 @@ class WxDevRuntime extends DevRuntime {
         }
     }
 
-    /** Consumed once per App heap from hmr/info.js; the host buildId is the delivery identity. */
+    /** Consumed once per App heap from hmr/info.js; the host buildId identifies its cumulative patch history. */
     initialize(info: HmrInfo): void {
         if (this.hmrInfo) {
             return
         }
         this.hmrInfo = info
-        // Anchor: the host publishes only after the runtime reports its delivery position.
-        void this.sendReport({ kind: 'delivery', seq: this.appliedSeq })
     }
 
     /** True between a patch delivery and the next page show: a hot reload is in progress. */
@@ -218,17 +215,17 @@ class WxDevRuntime extends DevRuntime {
         this.hotReloading = false
     }
 
-    /** The only direct effect of hmr/patches.js: validate, store, acknowledge, and apply. */
-    storePatches(payload: PatchPayload): void {
+    /** Applies one Page-delivered payload before that Page imports its capsule. */
+    applyPatches(payload: PatchPayload | undefined): void {
+        // 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) {
             console.warn('[vpt] patches for a stale build')
             return
         }
 
-        const deliveredSeq = Math.max(this.appliedSeq, payload.patches.at(-1)?.seq ?? 0)
-        void this.sendReport({ kind: 'delivery', seq: deliveredSeq })
-
         // 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.
@@ -236,27 +233,82 @@ class WxDevRuntime extends DevRuntime {
 
         // 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.
-        this.applyPatches(payload.patches)
+        if (this.applyPatchBatch(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 })
+        }
     }
 
-    /** Applies one physical suffix in Rolldown sequence order. */
-    private applyPatches(patches: readonly PatchProgram[]): void {
-        for (const patch of patches) {
-            if (patch.seq <= this.appliedSeq) continue
+    /**
+     * Folds one cumulative physical patch file into a single logical HMR update.
+     *
+     * `hmr/patches.js` can contain several unacknowledged Rolldown 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.
+     *
+     * 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.
+     */
+    private applyPatchBatch(patches: readonly PatchProgram[]): boolean {
+        // 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
+
+        // 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
+        const changedIds = new Set<string>()
+
+        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.
+                if (patch.seq <= previousSeq) {
+                    continue
+                }
 
-            try {
-                const expectedSeq = this.appliedSeq + 1
-                if (patch.seq !== expectedSeq) {
-                    throw new Error(`missing patch sequence ${expectedSeq}`)
+                // 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.
+                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()
-                this.applyHmrUpdate(patch.changedIds)
-                this.appliedSeq = patch.seq
-            } catch (error) {
-                console.warn(`[vpt] patch sequence ${patch.seq} failed; apply stopped`, error)
-                void this.sendReport({ kind: 'rebuild' })
-                return
+
+                for (const changedId of patch.changedIds) {
+                    changedIds.add(changedId)
+                }
+
+                nextSeq++
             }
+
+            // A payload containing only replayed sequences requires no graph work and must not alter the application watermark.
+            if (nextSeq === previousSeq + 1) {
+                return true
+            }
+
+            // 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.
+            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
+            return true
+        } catch (error) {
+            console.warn('[vpt] patch batch failed; apply stopped', error)
+            void this.sendReport({
+                kind: 'rebuild',
+                reason: Error.isError(error) ? error.message : String(error)
+            })
+            return false
         }
     }