vite-plugin-taro 0.5.4 → 0.5.6

package/dist/node/plugins/wx/dev/react-refresh.js

@@ -1,8 +1,19 @@
-import { types } from '@babel/core';
+import { isReferenceIdentifier } from 'oxc-walker';
 import { memoize } from '../../../utils/memoize.js';
-import { transformWithBabel } from '../../../utils/transform.js';
+import { transformWithOxcWalker } from '../../../utils/oxc-transform.js';
 /** The React DevTools hook protocol name; free references must target `global` in wx. */
 const reactDevtoolsHookProtocol = '__REACT_DEVTOOLS_GLOBAL_HOOK__';
+/**
+ * Refresh protocol globals that must live on the WeChat `global` object:
+ * - `__registerBeforePerformReactRefresh` is assigned at module evaluation so the HMR client can register work that
+ *   must finish before a refresh. Leaving it on `window` throws before the refresh runtime can initialize.
+ * - `__getReactRefreshIgnoredExports` is an optional extension point read while validating a refresh boundary.
+ *   Leaving that read on the nonexistent `window` crashes every update validation pass.
+ *
+ * Keeping this list explicit prevents the adapter from rewriting unrelated browser accesses if the vendored runtime
+ * gains new code. Any future React Refresh protocol addition therefore requires a deliberate compatibility decision.
+ */
+const refreshRuntimeWindowGlobals = ['__registerBeforePerformReactRefresh', '__getReactRefreshIgnoredExports'];
 /**
  * Creates the serve-only React Refresh adaptation transforms for the wx target.
  *
@@ -58,7 +69,7 @@ export function createWxReactRefreshTransforms() {
                 // occurrence, in boundary modules.
                 filter: { code: /window\.\$RefreshReg\$/ },
                 handler(code, id) {
-                    return transformWithBabel(code, id, [removeRefreshPreambleGuard], false);
+                    return removeRefreshPreambleGuard({ code, id });
                 }
             }
         }
@@ -70,129 +81,121 @@ export function createWxReactRefreshTransforms() {
  * The renderer checks the hook with `typeof __REACT_DEVTOOLS_GLOBAL_HOOK__` and injects via
  * `hook.inject(...)` — but in the WeChat runtime, free-variable reads never resolve against
  * `global`'s properties (verified: the free lookup is undefined while
- * `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` exists), so the renderer would silently skip
- * injection and React Refresh would have no renderer to schedule re-renders on.
+ * `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` exists). The renderer would therefore silently
+ * skip injection, leaving React Refresh with no renderer on which to schedule re-renders.
  *
- * The name is unique to the React DevTools protocol, so rewriting every free reference to an
- * explicit member access is precise. The hook itself is created on `global` by the dev
- * runtime chunk (see dev-runtime.ts).
+ * The protocol name is unique, but only reference identifiers are rewritten. Declaration
+ * keys and explicit members such as `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` must remain
+ * untouched; rewriting those would either produce invalid syntax or double-prefix the hook.
+ * The hook itself is created on `global` by the dev runtime chunk in `dev-runtime.ts`.
  */
-function rewriteReactDevtoolsHookGlobal() {
-    return {
-        name: 'vpt:wx-react-devtools-hook-global',
-        visitor: {
-            Identifier(identifierPath) {
-                const node = identifierPath.node;
-                if (!types.isIdentifier(node, { name: reactDevtoolsHookProtocol })) {
-                    return;
-                }
-                const parent = identifierPath.parentPath;
-                // A member expression property (e.g. `global.__REACT_DEVTOOLS_GLOBAL_HOOK__`)
-                // is already explicit and must not be rewritten again.
-                if (parent.isMemberExpression() && parent.node.property === node) {
-                    return;
-                }
-                identifierPath.replaceWith(types.memberExpression(types.identifier('global'), types.identifier(node.name)));
-            }
+function createReactDevtoolsHookVisitor(editor) {
+    return function enter(node, parent) {
+        if (node.type !== 'Identifier' ||
+            node.name !== reactDevtoolsHookProtocol ||
+            !isReferenceIdentifier(node, parent)) {
+            return;
         }
+        // An explicit member access is required because WeChat does not expose properties of
+        // its global object as free lexical bindings. Removing this edit disables renderer
+        // registration even though the hook object itself still exists.
+        editor.overwrite(node.start, node.end, `global.${reactDevtoolsHookProtocol}`);
     };
 }
 /**
- * Refresh runtime module: self-inject at evaluation — the wx App heap has no HTML preamble.
+ * Refresh runtime module: self-inject at evaluation and rewrite its browser protocol globals.
  *
- * In web Vite, the HTML preamble calls `injectIntoGlobalHook(window)` before any module
- * loads; nothing does that in wx. The call must live in this module itself:
- * - its closure owns the refresh state (helpersByRendererID, mountedRoots), so the same
- *   instance that the generated boundary code imports must bootstrap itself;
- * - the dev runtime chunk cannot reach it: the module is in a lazily-loaded chunk that
- *   requires the runtime chunk first, so it does not exist when the runtime evaluates.
+ * In web Vite, an HTML preamble calls `injectIntoGlobalHook(window)` before application
+ * modules load. wx has no HTML document or preamble, so nothing performs that bootstrap.
+ * The call must live in the refresh runtime module itself:
+ * - this module's closure owns `helpersByRendererID`, mounted roots, and the update helpers;
+ * - the wx dev-runtime chunk cannot call into it because the refresh module is in a later,
+ *   lazily loaded chunk and does not exist when the dev-runtime chunk evaluates.
  *
- * Unlike the preamble's `$RefreshReg$` globals (removed by removeRefreshPreambleGuard
- * because boundary modules define local wrappers), the hook machinery has no local
- * equivalent — without it the refresh runtime never learns the renderer or the mounted
- * roots, so the injection is the one preamble responsibility that must be replicated.
+ * Unlike the preamble's `$RefreshReg$` globals, which boundary modules replace with local
+ * wrappers, the renderer-hook machinery has no local equivalent. Without this injected call,
+ * the runtime never learns about the renderer or mounted roots and updates cannot refresh UI.
  *
- * Timing is safe because injectIntoGlobalHook replays hook.renderers: the renderer already
- * injected into the hook (created by the dev runtime chunk) when the App mounted, and the
- * replay captures it; the patched commit hooks then track every later mount, including the
- * remounts on re-execution.
+ * Appending the call is safe even when React has already registered its renderer: the refresh
+ * runtime replays `hook.renderers` during injection, then its patched commit hooks observe all
+ * later mounts and remounts. The same module also contains two browser-only `window` protocol
+ * accesses; those must point at `global` or evaluation/update validation throws in WeChat.
  */
-function injectRefreshGlobalHook() {
-    return {
-        name: 'vpt:wx-refresh-global-hook-injection',
-        visitor: {
-            Program(programPath) {
-                // The renderer already injected into the hook (created by the dev runtime
-                // chunk) when the App mounted; injectIntoGlobalHook replays its renderers.
-                programPath.pushContainer('body', types.expressionStatement(types.callExpression(types.identifier('injectIntoGlobalHook'), [types.identifier('global')])));
-            }
+function createRefreshRuntimeVisitor(editor) {
+    // The declarations must execute before self-injection, so the call is appended instead of
+    // prepended. Removing it would leave the web preamble's only essential responsibility
+    // unimplemented in wx.
+    editor.append('\ninjectIntoGlobalHook(global);');
+    return function enter(node) {
+        if (node.type !== 'MemberExpression' ||
+            node.computed ||
+            node.object.type !== 'Identifier' ||
+            node.object.name !== 'window' ||
+            node.property.type !== 'Identifier' ||
+            !refreshRuntimeWindowGlobals.some((globalName) => globalName === node.property.name)) {
+            return;
         }
+        // `global` is the shared wx App heap used by the dev runtime and hook injection. Only
+        // replacing the object range preserves the vendored runtime byte-for-byte otherwise
+        // and prevents unrelated `window` expressions from being silently adapted.
+        editor.overwrite(node.object.start, node.object.end, 'global');
     };
 }
 /**
- * Refresh runtime module: rewrites the generated `window.<protocol>` accesses to `global`.
- *
- * The vendored refresh runtime is written for browsers and uses `window` for its protocol
- * globals, but the WeChat runtime has no `window` — the free identifier is undefined — so the
- * top-level assignment would throw at module evaluation, and the ignored-exports read
- * inside the refresh validator would crash every update pass.
+ * Removes the web-only `if (!window.$RefreshReg$) throw Error(...)` assertion from boundary modules.
  *
- * Only the exact known protocol names are rewritten, one by one, so unrelated `window`
- * accesses are never touched and future protocol additions are deliberate.
+ * The assertion verifies that Vite's HTML preamble installed global registration helpers.
+ * wx has no preamble and evaluating `window` itself fails. The assertion is unnecessary here:
+ * @vitejs/plugin-react generates local `$RefreshReg$` and `$RefreshSig$` wrappers that delegate
+ * directly to the imported refresh runtime. Removing the whole statement therefore removes
+ * only an invalid platform check; component registration continues through those local wrappers.
+ * If this edit is removed, every transformed refresh boundary crashes before its module body runs.
  */
-function rewriteRefreshRuntimeWindowAccess() {
-    /**
-     * Refresh protocol globals that must land on the WeChat `global`:
-     * - `__registerBeforePerformReactRefresh`: assigned at module scope; in web, the HMR
-     *   client registers pre-refresh callbacks through it — the assignment throws on
-     *   undefined `window`;
-     * - `__getReactRefreshIgnoredExports`: read in validateRefreshBoundaryAndEnqueueUpdate
-     *   as an optional extension point — a read on undefined `window` crashes.
-     */
-    const refreshRuntimeWindowGlobals = ['__registerBeforePerformReactRefresh', '__getReactRefreshIgnoredExports'];
-    return {
-        name: 'vpt:wx-refresh-runtime-window-access',
-        visitor: {
-            MemberExpression(memberPath) {
-                const member = memberPath.node;
-                if (!types.isIdentifier(member.object, { name: 'window' }) ||
-                    !types.isIdentifier(member.property) ||
-                    !refreshRuntimeWindowGlobals.includes(member.property.name)) {
-                    return;
-                }
-                // `global` is the WeChat global object — the same one the hook injection
-                // and the rest of the wx glue speak — so the protocol globals land on the
-                // App heap like any other global hook.
-                member.object = types.identifier('global');
-            }
+function createRefreshPreambleGuardVisitor(editor) {
+    return function enter(node) {
+        if (node.type !== 'IfStatement' ||
+            node.test.type !== 'UnaryExpression' ||
+            node.test.operator !== '!' ||
+            node.test.argument.type !== 'MemberExpression' ||
+            node.test.argument.computed ||
+            node.test.argument.object.type !== 'Identifier' ||
+            node.test.argument.object.name !== 'window' ||
+            node.test.argument.property.type !== 'Identifier' ||
+            node.test.argument.property.name !== '$RefreshReg$') {
+            return;
         }
+        // Matching the complete AST shape prevents an unrelated `$RefreshReg$` use from being
+        // removed. Skipping descendants is required because their ranges disappear with the
+        // parent and must not receive overlapping MagicString edits.
+        editor.remove(node.start, node.end);
+        this.skip();
     };
 }
-/** Boundary modules: remove the generated `if (!window.$RefreshReg$) throw Error(...)` guard. */
-function removeRefreshPreambleGuard() {
-    return {
-        name: 'vpt:wx-refresh-preamble-guard',
-        visitor: {
-            IfStatement(ifPath) {
-                // The guard is a web-only sanity check that the HTML preamble installed the
-                // `$RefreshReg$` global. wx has no preamble and no such global — but the
-                // boundary module does not need it: the plugin transform generates local
-                // `$RefreshReg$`/`$RefreshSig$` wrappers that delegate to the imported
-                // refresh runtime, so registration works without the global. The guard
-                // itself only crashes on the undefined `window`, so it is removed.
-                const test = ifPath.node.test;
-                if (types.isUnaryExpression(test, { operator: '!' }) &&
-                    types.isMemberExpression(test.argument) &&
-                    types.isIdentifier(test.argument.object, { name: 'window' }) &&
-                    types.isIdentifier(test.argument.property, { name: '$RefreshReg$' })) {
-                    ifPath.remove();
-                }
-            }
-        }
-    };
+export function transformRefreshRuntime({ code, id }) {
+    return transformWithOxcWalker({
+        code,
+        filename: id,
+        sourcemap: false,
+        createVisitor: createRefreshRuntimeVisitor
+    });
+}
+export function transformReactDevtoolsHook({ code, id }) {
+    return transformWithOxcWalker({
+        code,
+        filename: id,
+        sourcemap: false,
+        createVisitor: createReactDevtoolsHookVisitor
+    });
+}
+export function removeRefreshPreambleGuard({ code, id }) {
+    return transformWithOxcWalker({
+        code,
+        filename: id,
+        sourcemap: false,
+        createVisitor: createRefreshPreambleGuardVisitor
+    });
 }
 // The refresh runtime module and the react-family modules are immutable for the server's
-// lifetime (they only change when the plugin is rebuilt), so their Babel transforms run once
-// per module and every build reuses the output.
-const fixRefreshRuntime = memoize(({ code, id }) => transformWithBabel(code, id, [rewriteRefreshRuntimeWindowAccess, injectRefreshGlobalHook], false), { getCacheKey: ({ code }) => code });
-const fixReactDevtoolsHook = memoize(({ code, id }) => transformWithBabel(code, id, [rewriteReactDevtoolsHookGlobal], false), { getCacheKey: ({ code }) => code });
+// lifetime, so their Oxc parses run once per module and every build reuses the output.
+const fixRefreshRuntime = memoize(transformRefreshRuntime, { getCacheKey: ({ code }) => code });
+const fixReactDevtoolsHook = memoize(transformReactDevtoolsHook, { getCacheKey: ({ code }) => code });

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

@@ -0,0 +1,25 @@
+import type { InputOptions, OutputOptions } from 'rolldown';
+import { type DevEngine } from 'rolldown/experimental';
+import type { ViteDevServer } from 'vite';
+import type { VitePluginTaroOptions } from '../../../../options.ts';
+export type BundledDevRolldownOptions = InputOptions & {
+    experimental?: {
+        [key: string]: unknown;
+        devMode?: boolean | Record<string, unknown>;
+    };
+    output?: OutputOptions | OutputOptions[];
+};
+export type BundledDev = {
+    _devEngine?: DevEngine;
+    getRolldownOptions(): Promise<BundledDevRolldownOptions>;
+    listen(): Promise<void>;
+    triggerBundleRegenerationIfStale(): Promise<boolean>;
+};
+/** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
+export declare function installWxDevOptions({ bundledDev, server, options }: {
+    bundledDev: BundledDev;
+    server: ViteDevServer;
+    options: VitePluginTaroOptions;
+}): Promise<void>;
+/** Returns the configured output after rejecting states unsupported by the physical WX engine. */
+export declare function requireSingleOutput(rolldownOptions: BundledDevRolldownOptions): OutputOptions;

package/dist/node/plugins/wx/dev/wx-dev-options.js

@@ -0,0 +1,147 @@
+import path from 'node:path';
+import { build } from 'rolldown';
+import { viteReporterPlugin } from 'rolldown/experimental';
+import { once } from '../../../utils/once.js';
+import { resolvePackageFile } from '../../../utils/packages.js';
+import { appShellFileName } from '../module.js';
+import { createWxDevMode } from './create-wx-dev-mode.js';
+import { emptyOutputDirectory } from './empty-output-directory.js';
+/** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
+export function installWxDevOptions({ bundledDev, server, options }) {
+    // The buildEnd hook and its one-shot result belong to the same abstraction. Consumers can await startup without receiving
+    // a resolver capable of settling it externally.
+    const initialBuild = Promise.withResolvers();
+    const settleInitialBuild = once((error) => {
+        if (error) {
+            initialBuild.reject(error);
+        }
+        else {
+            initialBuild.resolve();
+        }
+    });
+    const original = bundledDev.getRolldownOptions.bind(bundledDev);
+    bundledDev.getRolldownOptions = async () => {
+        const rolldownOptions = await original();
+        const output = ensureSingleOutput(rolldownOptions);
+        const configuredOutput = server.config.build.rolldownOptions.output;
+        if (Array.isArray(configuredOutput)) {
+            throw new Error('wx development supports one configured Rolldown output.');
+        }
+        const configured = configuredOutput ?? {};
+        // Every page entry must depend on hmr/patches.js: DevTools classifies a changed Page dependency as Page JavaScript
+        // hot reload and re-executes live Pages, which is the only physical patch trigger that preserves the App heap.
+        const pageFiles = new Set(options.pages.map((page) => `${page.path}.js`));
+        Object.assign(output, configured, {
+            assetFileNames: createStableFileNames(configured.assetFileNames, 'assets/[name][extname]'),
+            banner: createEntryBanner(pageFiles),
+            chunkFileNames: createStableFileNames(configured.chunkFileNames, 'assets/[name].js'),
+            entryFileNames: createStableFileNames(configured.entryFileNames, '[name]'),
+            format: 'es',
+            minify: true,
+            sourcemap: false
+        });
+        rolldownOptions.experimental ??= {};
+        rolldownOptions.experimental.devMode = createWxDevMode(rolldownOptions.experimental.devMode, await bundleRuntimeSource());
+        const emptyOutputDirectoryPlugin = {
+            name: 'vpt:wx-empty-output-directory',
+            renderStart: {
+                order: 'pre',
+                // DevEngine bypasses Vite's build-only output preparation. Preserve the watched directory itself while
+                // removing stale contents before each complete physical render.
+                handler: () => emptyOutputDirectory(server.config.build.outDir)
+            }
+        };
+        const reportInitialBuildPlugin = {
+            name: 'vpt:wx-report-initial-build',
+            buildEnd: settleInitialBuild
+        };
+        rolldownOptions.plugins = [
+            emptyOutputDirectoryPlugin,
+            rolldownOptions.plugins,
+            reportInitialBuildPlugin,
+            createViteReporter(server)
+        ];
+        disableViteOxcSourcemap(rolldownOptions.plugins);
+        return rolldownOptions;
+    };
+    return initialBuild.promise;
+}
+/** Returns the configured output after rejecting states unsupported by the physical WX engine. */
+export function requireSingleOutput(rolldownOptions) {
+    if (!rolldownOptions.output || Array.isArray(rolldownOptions.output)) {
+        throw new Error('wx development requires exactly one Rolldown output.');
+    }
+    return rolldownOptions.output;
+}
+/** Creates the one missing output object while rejecting a configured output array. */
+function ensureSingleOutput(rolldownOptions) {
+    if (Array.isArray(rolldownOptions.output)) {
+        throw new Error('wx development requires one configured Rolldown output.');
+    }
+    rolldownOptions.output ??= {};
+    return rolldownOptions.output;
+}
+/**
+ * Prepends entry banners after Rolldown's analysis so their native requires remain physical dependencies rather than chunk
+ * graph edges. The App initializes the runtime identity, while every Page explicitly applies the watched patch data before its
+ * capsule import continues.
+ */
+function createEntryBanner(pageFiles) {
+    return (chunk) => {
+        if (chunk.name === appShellFileName) {
+            return "__rolldown_runtime__.initialize(require('./hmr/info.js'));\n";
+        }
+        if (pageFiles.has(chunk.name)) {
+            const patchesPath = path.posix.relative(path.posix.dirname(chunk.fileName), 'hmr/patches.js');
+            return `__rolldown_runtime__.applyPatches(require('${patchesPath}'));\n`;
+        }
+        return '';
+    };
+}
+function createStableFileNames(addon, fallback) {
+    if (typeof addon === 'function') {
+        return (value) => toStableFileName(String(addon(value)));
+    }
+    return toStableFileName(typeof addon === 'string' ? addon : fallback);
+}
+function toStableFileName(fileName) {
+    return fileName
+        .replace(/(^|\/)\[hash(?::\d+)?\](?=\.|$)/g, '$1[name]')
+        .replace(/[-_.]\[hash(?::\d+)?\]/g, '')
+        .replace(/\[hash(?::\d+)?\]/g, '[name]');
+}
+function disableViteOxcSourcemap(pluginOption) {
+    if (Array.isArray(pluginOption)) {
+        pluginOption.forEach(disableViteOxcSourcemap);
+        return;
+    }
+    if (!pluginOption || typeof pluginOption !== 'object')
+        return;
+    const plugin = pluginOption;
+    if (plugin.name === 'builtin:vite-transform' && plugin._options?.transformOptions) {
+        plugin._options.transformOptions.sourcemap = false;
+    }
+}
+function createViteReporter(server) {
+    const { build, logger, root } = server.config;
+    return viteReporterPlugin({
+        assetsDir: path.join(build.assetsDir, '/'),
+        chunkLimit: 2000,
+        isLib: Boolean(build.lib),
+        isTty: Boolean(process.stdout.isTTY && !process.env.CI),
+        logInfo: (message) => logger.info(message),
+        reportCompressedSize: false,
+        root,
+        warnLargeChunks: false
+    });
+}
+// The runtime source is immutable for the host's lifetime, so the nested bundle is shared by every complete build.
+const bundleRuntimeSource = once(async function bundleRuntimeSource() {
+    // write: false keeps this nested helper build from creating a second dist directory in the application project.
+    const result = await build({
+        input: resolvePackageFile('dist/runtime/wx/dev/dev-runtime.js'),
+        output: { format: 'iife', minify: true, sourcemap: false },
+        write: false
+    });
+    return result.output[0].code;
+});

package/dist/node/utils/oxc-transform.d.ts

@@ -0,0 +1,21 @@
+import { type WalkerEnter } from 'oxc-walker';
+import { RolldownMagicString } from 'rolldown';
+import type { AstTransformResult } from './transform.ts';
+type OxcTransformOptions = {
+    code: string;
+    filename: string;
+    sourcemap: boolean;
+    createVisitor(editor: RolldownMagicString): WalkerEnter;
+};
+/**
+ * Parses once with Rolldown's Oxc parser and applies precise edits through its native Rust MagicString.
+ *
+ * These adapters previously used Babel plugins for one or two local range changes. Babel then
+ * cloned and regenerated the complete module, which was unnecessary work for large dependency
+ * sources and changed formatting outside the intended edit. Sharing Rolldown's parser and editor
+ * keeps one AST implementation across Vite's build engine and these transforms while preserving
+ * untouched source exactly. Callers provide only a visitor, so parsing, diagnostics, source-map
+ * policy, and result normalization cannot drift between adapters.
+ */
+export declare function transformWithOxcWalker({ code, filename, sourcemap, createVisitor }: OxcTransformOptions): AstTransformResult;
+export {};

package/dist/node/utils/oxc-transform.js

@@ -0,0 +1,58 @@
+import { walk } from 'oxc-walker';
+import { RolldownMagicString } from 'rolldown';
+import { parseSync } from 'rolldown/utils';
+/**
+ * Parses once with Rolldown's Oxc parser and applies precise edits through its native Rust MagicString.
+ *
+ * These adapters previously used Babel plugins for one or two local range changes. Babel then
+ * cloned and regenerated the complete module, which was unnecessary work for large dependency
+ * sources and changed formatting outside the intended edit. Sharing Rolldown's parser and editor
+ * keeps one AST implementation across Vite's build engine and these transforms while preserving
+ * untouched source exactly. Callers provide only a visitor, so parsing, diagnostics, source-map
+ * policy, and result normalization cannot drift between adapters.
+ */
+export function transformWithOxcWalker({ code, filename, sourcemap, createVisitor }) {
+    // `RolldownMagicString` stores edits in Rolldown's native layer. A separate `magic-string`
+    // instance would duplicate a dependency already supplied by the build engine and would make
+    // source-map generation cross the JavaScript boundary for every recorded segment.
+    const editor = new RolldownMagicString(code, { filename });
+    const result = parseSync(filename, code);
+    // Oxc can return a recoverable AST together with diagnostics. Walking that partial tree could
+    // let a visitor edit malformed input and hide the original syntax failure, so diagnostics are
+    // rejected before any caller-owned edits run.
+    if (result.errors.length > 0) {
+        const diagnostics = result.errors.map((error) => error.message).join('; ');
+        throw new Error(`Failed to parse ${filename} with Oxc: ${diagnostics}`);
+    }
+    // All visitor work is O(n) in AST size; range edits remain local and do not trigger a second
+    // parse or whole-file code-generation pass.
+    walk(result.program, { enter: createVisitor(editor) });
+    // Boundary-resolution maps retain exact mappings around edits without the much larger cost
+    // of mapping every character. Original content is required for Vite to compose this map with
+    // subsequent optimizer or application transforms.
+    const generatedMap = sourcemap
+        ? editor.generateMap({
+            file: filename,
+            hires: 'boundary',
+            includeContent: true,
+            source: filename
+        })
+        : null;
+    return {
+        code: editor.toString(),
+        map: generatedMap
+            ? {
+                // Return a plain source-map value instead of leaking Rolldown's native wrapper
+                // through Vite's plugin API. This also keeps the result identical in the normal
+                // application pipeline and the optimizer's independent Rolldown build.
+                version: generatedMap.version,
+                file: generatedMap.file,
+                sources: generatedMap.sources,
+                sourcesContent: generatedMap.sourcesContent,
+                names: generatedMap.names,
+                mappings: generatedMap.mappings,
+                ...(generatedMap.x_google_ignoreList ? { x_google_ignoreList: generatedMap.x_google_ignoreList } : {})
+            }
+            : null
+    };
+}

package/dist/node/utils/serialized-task-queue.d.ts

@@ -1,9 +1,13 @@
-/** Runs recoverable background tasks in insertion order and reports failures without blocking later work. */
+/** Runs asynchronous tasks in insertion order without letting one failure block later work. */
 export declare class SerializedTaskQueue {
+    /** Mutable promise tail confines ordering state to this queue. */
     private tail;
     private readonly reportError;
     constructor(reportError: (operation: string, error: unknown) => void);
-    enqueue(operation: string, task: () => Promise<void>): void;
+    /** Schedules a background task and reports its failure. */
+    enqueue(operation: string, task: () => void | PromiseLike<void>): void;
+    /** Schedules a task whose result and failure belong to the caller. */
+    run<Result>(task: () => Result | PromiseLike<Result>): Promise<Result>;
     /** Waits for every task that was queued when this method was called. */
     waitForIdle(): Promise<void>;
 }

package/dist/node/utils/serialized-task-queue.js

@@ -1,15 +1,23 @@
-/** Runs recoverable background tasks in insertion order and reports failures without blocking later work. */
+/** Runs asynchronous tasks in insertion order without letting one failure block later work. */
 export class SerializedTaskQueue {
+    /** Mutable promise tail confines ordering state to this queue. */
     tail = Promise.resolve();
     reportError;
     constructor(reportError) {
         this.reportError = reportError;
     }
+    /** Schedules a background task and reports its failure. */
     enqueue(operation, task) {
-        this.tail = this.tail.then(task).catch((error) => {
+        void this.run(task).catch((error) => {
             this.reportError(operation, error);
         });
     }
+    /** Schedules a task whose result and failure belong to the caller. */
+    run(task) {
+        const result = this.tail.then(task);
+        this.tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
     /** Waits for every task that was queued when this method was called. */
     async waitForIdle() {
         await this.tail;

package/dist/runtime/wx/capsule/page.js

@@ -13,22 +13,27 @@ function forward(handler, receiver, args) {
 // 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') {
     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;
     config.onUnload = function (...args) {
         if (__rolldown_runtime__.isHotReloading()) {
             const instance = this;
             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;
         }
@@ -36,10 +41,14 @@ if (typeof __rolldown_runtime__ !== 'undefined') {
     };
     config.onLoad = function (...args) {
         if (__rolldown_runtime__.isHotReloading() && captured) {
+            const instance = this;
+            // 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;
             instance.$taroPath = captured.$taroPath;
             instance.$taroParams = captured.$taroParams;
             // Rebind the retained tree to the replacement receiver and resync the native