vite-plugin-taro 0.5.3 → 0.5.5

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
         }
     }