vite-plugin-taro 0.5.6 → 0.5.7

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

@@ -3,7 +3,7 @@ import './app.ts'
 
 // @ts-expect-error: The wx build replaces this private import with the configured Page component.
 import PageComponent from '\0vpt:page-component'
-import { Current, createPageConfig, document, injectPageInstance } from './taro-runtime.ts'
+import { createPageConfig } from './taro-runtime.ts'
 
 declare const __VITE_PLUGIN_TARO_PAGE_PATH__: string
 declare const __VITE_PLUGIN_TARO_PAGE_CONFIG__: Record<string, unknown>
@@ -16,95 +16,3 @@ const config = createPageConfig(
 )
 
 export default config
-
-// HMR
-
-type LifecycleHandler = (this: unknown, ...args: unknown[]) => void
-
-/** Forwards a call with the native page instance as `this`, matching Taro's invocation. */
-function forward(handler: unknown, receiver: unknown, args: unknown[]): void {
-    ;(handler as LifecycleHandler | undefined)?.apply(receiver, args)
-}
-
-/** 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 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') {
-    const originalOnUnload = config.onUnload
-    const originalOnLoad = config.onLoad
-    const originalOnShow = config.onShow
-
-    // 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 NativePage
-            captured = {
-                $taroPath: instance.$taroPath,
-                $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
-        }
-        forward(originalOnUnload, this, args)
-    }
-    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.
-            instance.$taroPath = captured.$taroPath
-            instance.$taroParams = captured.$taroParams
-            // Rebind the retained tree to the replacement receiver and resync the native
-            // data: updateChildNodes enqueues the full hydrated node tree (root.cn) — the
-            // surviving tree's mutations were consumed long ago, so without it the payload
-            // queue is empty and the new receiver renders nothing.
-            injectPageInstance(instance as unknown as Parameters<typeof injectPageInstance>[0], captured.$taroPath)
-            Current.page = instance as unknown as typeof Current.page
-            const pageElement = document.getElementById(captured.$taroPath) as unknown as {
-                ctx: unknown
-                updateChildNodes: () => void
-                performUpdate: (initRender?: boolean) => void
-            }
-            pageElement.ctx = instance
-            pageElement.updateChildNodes()
-            pageElement.performUpdate(true)
-            return
-        }
-        forward(originalOnLoad, this, args)
-    }
-    config.onShow = function (this: unknown, ...args: unknown[]) {
-        if (__rolldown_runtime__.isHotReloading()) {
-            // The window ends at the first show; the user's onShow must not re-run on a
-            // synthetic re-execution (it could reset state).
-            __rolldown_runtime__.clearHotReloading()
-            return
-        }
-        forward(originalOnShow, this, args)
-    }
-}

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

@@ -19,6 +19,20 @@ type HmrInfo = Readonly<{
     endpoint: string
 }>
 
+/** App-heap HMR identity; only the committed application frontier mutates. */
+type HmrSession = {
+    /** Rejects delayed patch files and identifies reports after a newer full build exists. */
+    readonly buildId: string
+    /** Fixed control URL discovered from the Vite server that produced this full build. */
+    readonly endpoint: string
+    /**
+     * Highest contiguous Rolldown sequence whose factories, graph propagation, and accept
+     * callbacks all succeeded. Replayed Page shells read this watermark; it advances only
+     * after an atomic batch succeeds and resets only with a new App heap.
+     */
+    appliedSeq: number
+}
+
 /** One physical hmr/patches.js payload: the build identity plus one patch program per update. */
 type PatchPayload = Readonly<{
     buildId: string
@@ -40,40 +54,108 @@ type HmrUpdate = Readonly<{
 
 type AcceptCallback = (moduleExports: unknown) => void
 
+type PageSnapshot = Readonly<{
+    $taroPath: string
+    $taroParams: Record<string, unknown>
+    data: Record<string, unknown>
+}>
+
+type NativePage = {
+    $taroPath: string
+    $taroParams: Record<string, unknown>
+    data: Record<string, unknown>
+    setData(data: Record<string, unknown>): void
+}
+
+type HmrPageConfig = {
+    onUnload?: unknown
+    onLoad?: unknown
+    onShow?: unknown
+}
+
+type TaroRoot = {
+    ctx: unknown
+}
+
+/** Immutable bridge references plus replacement transactions owned by one Taro singleton. */
+type TaroState = {
+    /** Taro's existing current-page source of truth; replacement onLoad switches its receiver. */
+    readonly current: { page: NativePage | null }
+    /** Taro's virtual document, used to find the retained root by its preserved unique path. */
+    readonly document: { getElementById(path: string): unknown }
+    /** Replaces Taro's native lifecycle receiver without remounting the retained React subtree. */
+    readonly injectPageInstance: (instance: unknown, path: string) => void
+    /**
+     * Short-lived route transactions. Absence means ordinary lifecycle; null means armed
+     * before onUnload or snapshot-consumed before onShow; a snapshot exists only between
+     * replacement onUnload and onLoad. The large data reference is therefore released in
+     * onLoad, while the null marker remains just long enough to suppress synthetic onShow.
+     */
+    readonly pageReplacements: Map<string, PageSnapshot | null>
+}
+
+/** Forwards a native lifecycle with its original Page receiver. */
+function forward(handler: unknown, receiver: unknown, args: unknown[]): void {
+    if (typeof handler === 'function') handler.apply(receiver, args)
+}
+
+/** Narrows the untyped element returned across the Taro connection boundary. */
+function isTaroRoot(value: unknown): value is TaroRoot {
+    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(): void {},
+    removeStyle(): 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.
  */
 class WxHotContext {
-    readonly _internal = {
-        updateStyle(): void {},
-        removeStyle(): void {}
-    }
+    readonly _internal = hotContextInternals
 
-    /** Registered self-accept callbacks; a bare accept is represented by a no-op callback. */
-    private readonly acceptCallbacks: AcceptCallback[] = []
+    /**
+     * 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: Array<AcceptCallback | undefined> | undefined
 
-    /** Set when a callback rejects a Refresh boundary; the current update then rebuilds. */
-    private invalidationReason: string | undefined
+    /** Stable module identity and shared sparse index used only when this context accepts. */
+    private readonly moduleId: string
+    private readonly acceptingContexts: Map<string, WxHotContext>
 
-    accept(callback?: AcceptCallback): void {
-        this.acceptCallbacks.push(callback ?? (() => {}))
+    constructor(moduleId: string, acceptingContexts: Map<string, WxHotContext>) {
+        this.moduleId = moduleId
+        this.acceptingContexts = acceptingContexts
     }
 
-    hasAccepts(): boolean {
-        return this.acceptCallbacks.length > 0
+    accept(callback?: AcceptCallback): void {
+        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. */
-    runAccept(moduleExports: unknown): string | undefined {
-        for (const callback of this.acceptCallbacks) {
-            callback(moduleExports)
+    /** Invokes this old context's callbacks; invalidation aborts the update synchronously. */
+    runAccept(moduleExports: unknown): void {
+        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?: string): void {
-        this.invalidationReason = reason ?? 'the accepting module invalidated the update'
+    invalidate(reason?: string): never {
+        throw new Error(reason ?? 'the accepting module invalidated the update')
     }
 
     // Vite's generated CSS module calls hot.prune with its style teardown; the physical
@@ -83,12 +165,18 @@ class WxHotContext {
 
 /** The WX host: extends the Rolldown contract instead of reimplementing it. */
 class WxDevRuntime extends DevRuntime {
-    private hmrInfo: HmrInfo | undefined
-
-    /** Highest Rolldown sequence successfully applied. */
-    private appliedSeq = 0
+    /**
+     * 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.
+     */
+    private session: HmrSession | undefined
 
-    /** Active hot contexts per module id; the propagation invokes their callbacks. */
+    /**
+     * 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 = new Map<string, WxHotContext>()
 
     constructor() {
@@ -99,13 +187,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.
      */
     override createModuleHotContext(moduleId: string): WxHotContext {
-        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. */
@@ -138,7 +226,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
         }
@@ -187,56 +275,140 @@ class WxDevRuntime extends DevRuntime {
         }
 
         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: HmrInfo): void {
-        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.
+     */
+    private taro: TaroState | undefined
+
+    /** Connects HMR to the same Taro singleton used by the application module graph. */
+    connectTaro(
+        current: TaroState['current'],
+        document: TaroState['document'],
+        injectPageInstance: TaroState['injectPageInstance']
+    ): void {
+        if (this.taro) {
             return
         }
-        this.hmrInfo = info
+
+        this.taro = {
+            current,
+            document,
+            injectPageInstance,
+            pageReplacements: new Map()
+        }
+    }
+
+    /** Injects snapshot-preserving behavior into one route-specific Taro Page configuration. */
+    injectPageHmr(config: HmrPageConfig, route: string): void {
+        const originalOnUnload = config.onUnload
+        const originalOnLoad = config.onLoad
+        const originalOnShow = config.onShow
+        const runtime = this
+
+        config.onUnload = function (this: NativePage, ...args: unknown[]) {
+            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 (this: NativePage, ...args: unknown[]) {
+            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 (this: NativePage, ...args: unknown[]) {
+            if (runtime.requireTaro().pageReplacements.delete(route)) {
+                // Synthetic shows must not repeat requests or reset application state.
+                return
+            }
+
+            forward(originalOnShow, this, args)
+        }
     }
 
-    /** True between a patch delivery and the next page show: a hot reload is in progress. */
-    private hotReloading = false
+    /** Returns the Taro connection or fails at the first incorrectly ordered use. */
+    private requireTaro(): TaroState {
+        if (!this.taro) throw new Error('[vpt] WX HMR used before the Taro runtime was connected')
+        return this.taro
+    }
 
-    /** The capsule wrapper asks this during the synthetic lifecycle of a hot reload. */
-    isHotReloading(): boolean {
-        return this.hotReloading
+    /** Returns a retained Taro root after normal Page mount has created it. */
+    private findRoot(path: string): TaroRoot | undefined {
+        const root = this.requireTaro().document.getElementById(path)
+        return isTaroRoot(root) ? root : undefined
     }
 
-    /** The wrapped onShow ends the hot reload after the replacement cycle. */
-    clearHotReloading(): void {
-        this.hotReloading = false
+    /** Rebinds a retained Taro tree to one replacement native Page without repainting. */
+    private bindPage(instance: NativePage, path: string): void {
+        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: PatchPayload | undefined): void {
+    /** Applies one Page-delivered payload and arms its route for native replacement. */
+    applyPatches(payload: PatchPayload | undefined, route?: string): 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) {
+        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 })
         }
     }
 
@@ -253,10 +425,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.
      */
-    private applyPatchBatch(patches: readonly PatchProgram[]): boolean {
+    private applyPatchBatch(session: HmrSession, 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
+        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.
@@ -300,7 +472,7 @@ class WxDevRuntime extends DevRuntime {
 
             // 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) {
             console.warn('[vpt] patch batch failed; apply stopped', error)
@@ -314,17 +486,17 @@ class WxDevRuntime extends DevRuntime {
 
     /** Sends one metadata-only report to the host; executable code never travels over HTTP. */
     private sendReport(data: Record<string, unknown>): Promise<void> {
-        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(): void {
                     resolve()
@@ -339,31 +511,3 @@ class WxDevRuntime extends DevRuntime {
 
 const runtime = new WxDevRuntime()
 ;(globalThis as { __rolldown_runtime__?: WxDevRuntime }).__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<number, unknown>(),
-    supportsFiber: true,
-    inject: (injected: unknown) => {
-        const id = reactDevtoolsHook.renderers.size
-        reactDevtoolsHook.renderers.set(id, injected)
-        return id
-    },
-    onScheduleFiberRoot: () => {},
-    onCommitFiberRoot: () => {},
-    onCommitFiberUnmount: () => {}
-}
-// node types declare `global` as typeof globalThis, so the WeChat global needs a cast.
-;(global as WeChatGlobal).__REACT_DEVTOOLS_GLOBAL_HOOK__ ??= reactDevtoolsHook

package/src/runtime/wx/wechat.d.ts

@@ -3,16 +3,13 @@
  * free lookup is undefined while `global.X` exists), so everything stored here must be
  * accessed as an explicit member expression.
  */
-type WeChatGlobal = {
-    /** React DevTools hook installed by the dev runtime; the renderer reads it via `global.`. */
-    __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown
-}
+type WeChatGlobal = object
 
 /** The App-global Rolldown dev runtime; present only in wx development builds. */
 declare const __rolldown_runtime__:
     | {
-          isHotReloading(): boolean
-          clearHotReloading(): void
+          connectTaro(current: object, document: object, injectPageInstance: (...args: unknown[]) => unknown): void
+          injectPageHmr(config: object, route: string): void
       }
     | undefined
 

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

@@ -1,7 +0,0 @@
-import type { PluginOption } from 'vite';
-import type { VitePluginTaroOptions } from '../../../../options.ts';
-/**
- * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter
- * (config, runtime lowering, dev host) plus the React Refresh adaptation transforms.
- */
-export declare function createWxDevelopmentPlugin(options: VitePluginTaroOptions): PluginOption[];

package/dist/node/plugins/wx/dev/plugin.js

@@ -1,73 +0,0 @@
-import { transformWithOxc } from 'vite';
-import { esTarget } from '../../../utils/constant.js';
-import { rolldownRuntimeId } from '../module.js';
-import { memoize } from '../../../utils/memoize.js';
-import { createWxDevHost } from './dev-host.js';
-import { createWxReactRefreshTransforms } from './react-refresh.js';
-/**
- * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter
- * (config, runtime lowering, dev host) plus the React Refresh adaptation transforms.
- */
-export function createWxDevelopmentPlugin(options) {
-    let host = null;
-    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
-                    }
-                };
-            },
-            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, id) {
-                    // The `setPublicClassFields` assumption emits plain `this.x = ...`
-                    // assignments instead of external helpers, whose references the later
-                    // minifier would mangle.
-                    return fixRolldownRuntime(code);
-                }
-            },
-            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();
-            }
-        },
-        ...createWxReactRefreshTransforms()
-    ];
-}
-// 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) => {
-    return transformWithOxc(code, rolldownRuntimeId, {
-        lang: 'js',
-        target: esTarget,
-        sourcemap: false,
-        assumptions: { setPublicClassFields: true }
-    });
-});