vite-plugin-taro 0.5.12 → 0.5.13

package/dist/node/plugins/h5/plugins.js

@@ -1,14 +1,35 @@
 import babel, { defineRolldownBabelPreset } from '@rolldown/plugin-babel';
+import { WeappTailwindcss } from 'weapp-tailwindcss/vite';
 import { esTarget } from '../../utils/constant.js';
 import { toViteFileImportPath } from '../../utils/modules.js';
 import { packageRequire } from '../../utils/packages.js';
 import { clientTaroApiId } from '../client/client-taro.js';
+import { tailwindcssBasedir } from '../tailwind/tailwind-css.js';
 import { h5AppPath } from './constant.js';
 import { createStencilClientAdapter } from './create-stencil-client-adapter.js';
 import { createModuleResolver } from './resolver/module-resolver.js';
 /** Creates the plugins that own the H5 target. */
 export function createH5TargetPlugins(options) {
-    return [...createH5SupportPlugins(), createH5TargetPlugin(options)];
+    return [
+        WeappTailwindcss({
+            appType: 'weapp-vite',
+            rewriteCssImports: false,
+            platform: 'web',
+            tailwindcssBasedir,
+            generator: {
+                target: 'web'
+            },
+            cssOptions: {
+                cssCalc: false,
+                autoprefixer: true,
+                rem2rpx: true,
+                px2rpx: true
+            },
+            logLevel: 'warn'
+        }),
+        ...createH5SupportPlugins(),
+        createH5TargetPlugin(options)
+    ];
 }
 /** Configures H5 resolution and supplies the specialized physical application entry. */
 function createH5TargetPlugin(options) {

package/dist/node/plugins/tailwind/tailwind-css.d.ts

@@ -0,0 +1 @@
+export declare const tailwindcssBasedir: string;

package/dist/node/plugins/tailwind/tailwind-css.js

@@ -0,0 +1,3 @@
+import path from 'node:path';
+import { packageRequire } from '../../utils/packages.js';
+export const tailwindcssBasedir = path.dirname(packageRequire.resolve('tailwindcss/package.json'));

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

@@ -1,4 +1,4 @@
-import type { ViteDevServer } from 'vite';
+import { type ViteDevServer } from 'vite';
 import type { VitePluginTaroOptions } from '../../../../options.ts';
 export type WxDevHost = Readonly<{
     close: () => Promise<void>;
@@ -8,8 +8,12 @@ export type WxDevHost = Readonly<{
  * with dev(...)) and the patch publisher, and replaces Vite's bundledDev.listen so the
  * engine writes directly to the Mini Program output directory instead of serving browser
  * HMR over HTTP.
+ *
+ * `applicationEntryIds` is the resolver's immutable cascade policy, not a second graph: it selects the App capsule followed
+ * by configured Page capsules from Rolldown's larger entry set. Rolldown remains the authority for every live import edge.
  */
-export declare function createWxDevHost({ server, options }: {
+export declare function createWxDevHost({ server, options, applicationEntryIds }: {
     server: ViteDevServer;
     options: VitePluginTaroOptions;
+    applicationEntryIds: readonly string[];
 }): Promise<WxDevHost>;

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

@@ -1,25 +1,49 @@
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import colors from 'picocolors';
 import { dev } from 'rolldown/experimental';
+import { isCSSRequest } from 'vite';
 import { SerializedTaskQueue } from '../../../utils/serialized-task-queue.js';
-import { hmrControlPath, hmrInfoFileName, hmrPatchesFileName, renderHmrInfo, renderInitialHmrPatches, writeHmrFile } from './hmr-files.js';
+import { createGraphStylePlan, isGlobalStyleRequest } from '../styles/utils.js';
+import { developmentAppWxssFileName, hmrControlPath, hmrInfoFileName, hmrPatchesFileName, renderDevelopmentAppWxss, renderHmrInfo, renderInitialHmrPatches, writeHmrFile } from './hmr-files.js';
 import { PatchPublisher } from './patch-publisher.js';
+import { createStyleCapturePlugin } from './styles/create-style-capture-plugin.js';
+import { globalWxssFileName, publishStyleHmr, refreshTailwindStyles } from './styles/publish-style-hmr.js';
 import { installWxDevOptions, requireSingleOutput } from './wx-dev-options.js';
 /**
  * Creates the wx dev host: the adapter that owns the physical Rolldown DevEngine (created
  * with dev(...)) and the patch publisher, and replaces Vite's bundledDev.listen so the
  * engine writes directly to the Mini Program output directory instead of serving browser
  * HMR over HTTP.
+ *
+ * `applicationEntryIds` is the resolver's immutable cascade policy, not a second graph: it selects the App capsule followed
+ * by configured Page capsules from Rolldown's larger entry set. Rolldown remains the authority for every live import edge.
  */
-export async function createWxDevHost({ server, options }) {
+export async function createWxDevHost({ server, options, applicationEntryIds }) {
     const bundledDev = getBundledDev(server);
+    // This is the host's mutable style projection: CSS absent from Rolldown, the live graph capability rebound by each
+    // complete build, and the last durable WXSS bytes used only to suppress identical filesystem publications. Style capture
+    // remains O(1); derived order and reachability stay local to each HMR transaction.
+    const styleState = {
+        getModuleInfo: undefined,
+        processedStyles: new Map(),
+        publishedWxss: undefined
+    };
+    const styleCapturePlugin = createStyleCapturePlugin({
+        captureGraph(reader) {
+            styleState.getModuleInfo = reader;
+        },
+        captureStyle(id, style) {
+            styleState.processedStyles.set(id, style);
+        }
+    });
     // Rolldown invokes output callbacks without awaiting their promises. This queue is the single owner of mutable HMR host
     // state and physical metadata writes, preventing a later patch or build identity from being overwritten by older work.
     const hostTasks = new SerializedTaskQueue((operation, error) => logWxError(server.config.logger, operation, error));
     const publisher = new PatchPublisher((content) => writeHmrFile(server.config.build.outDir, hmrPatchesFileName, content));
     // DevEngine does not reject run() after an initial plugin failure. The options layer owns a first-build buildEnd barrier
     // and exposes only its result; later build errors continue independently through onOutput and onHmrUpdates.
-    const initialBuild = installWxDevOptions({ bundledDev, server, options });
+    const initialBuild = installWxDevOptions({ bundledDev, server, options, hostPlugins: [styleCapturePlugin] });
     const engine = await createEngine();
     // The wx dev host owns the only DevEngine. Vite's default listen() would create a second
     // skip-write engine that renders into memory for browser HMR; instead the physical
@@ -134,12 +158,42 @@ export async function createWxDevHost({ server, options }) {
         if (batch.length === 0) {
             return;
         }
+        // `onHmrUpdates` is the transaction boundary after every affected transform has updated graph and candidate state.
+        // Every non-CSS edit may alter imports or Tailwind classes; rendering broadly and comparing finalized bytes avoids
+        // source scanning while preventing unrelated JavaScript edits from notifying DevTools through an identical rename.
+        await publishChangedStyles(batch);
+        // Publish global.wxss before the matching JavaScript patch so DevTools observes a coherent HMR transaction.
         // The physical file must exist before Rolldown advances: once committed, later patches may be generated relative to
         // this batch even if DevTools has not observed its file event yet. PatchPublisher keeps the unapplied range cumulative,
         // so any later file generation still carries every factory needed to bridge the runtime's older application frontier.
         await publisher.produce(batch);
         await commitPublishedBatch(batch);
     }
+    /** Publishes the style projection for one completed patch transaction when its source or topology may have changed. */
+    async function publishChangedStyles(batch) {
+        const changedIds = batch.flatMap((patch) => patch.changedIds);
+        const styleChanged = changedIds.some(isGlobalStyleRequest);
+        const candidatesChanged = changedIds.some((id) => !isCSSRequest(id));
+        if (!styleChanged && !candidatesChanged) {
+            return;
+        }
+        // buildStart installs this reader before Rolldown can produce either a complete output or an incremental batch.
+        const getModuleInfo = styleState.getModuleInfo;
+        if (!getModuleInfo) {
+            throw new Error('WX style graph is unavailable before HMR publication');
+        }
+        // Traverse topology exactly once; root refresh and final rendering consume this immutable transaction plan.
+        const styleIds = createGraphStylePlan(applicationEntryIds, getModuleInfo, (styleId) => styleState.processedStyles.has(styleId));
+        if (candidatesChanged) {
+            await refreshTailwindStyles(styleIds, styleState.processedStyles, async (rootId, requestId) => server.environments.client.pluginContainer.transform(await readFile(rootId, 'utf8'), requestId));
+        }
+        styleState.publishedWxss = await publishStyleHmr({
+            styleIds: styleIds,
+            outDir: server.config.build.outDir,
+            processedStyles: styleState.processedStyles,
+            publishedWxss: styleState.publishedWxss
+        });
+    }
     /**
      * Advances Rolldown's published frontier in the same sequence order materialized in the cumulative physical file.
      *
@@ -161,7 +215,12 @@ export async function createWxDevHost({ server, options }) {
             logWxError(server.config.logger, 'wx dev build failed', result);
             return;
         }
-        hostTasks.enqueue('wx dev build finalization failed', rotateBuildSession);
+        hostTasks.enqueue('wx dev build finalization failed', finalizeDevOutput);
+    }
+    /** Rebinds the byte frontier after a complete build replaces the physical stylesheet outside HMR publication. */
+    async function finalizeDevOutput() {
+        styleState.publishedWxss = await readFile(path.join(server.config.build.outDir, globalWxssFileName), 'utf8');
+        await rotateBuildSession();
     }
 }
 /** The bound HTTP port, or undefined before Vite's server is listening. */
@@ -176,7 +235,7 @@ function boundPort(server) {
     }
     return address.port;
 }
-/** Resets physical patches before exposing the matching immutable build identity to a new App heap. */
+/** Resets physical patches and then exposes one coherent build identity to a freshly compiled App heap. */
 async function publishBuildMetadata(server, buildId, port) {
     const info = {
         buildId,
@@ -184,6 +243,12 @@ async function publishBuildMetadata(server, buildId, port) {
     };
     await writeHmrFile(server.config.build.outDir, hmrPatchesFileName, renderInitialHmrPatches());
     await writeHmrFile(server.config.build.outDir, hmrInfoFileName, renderHmrInfo(info));
+    // `removeDevelopmentAppWxss` kept the previous physical wrapper in place while the complete output was written. Replace
+    // it only now, after the empty patch frontier and matching identity are durable. DevTools treats `app.wxss` as an App root,
+    // so this write intentionally causes the one full refresh allowed at a complete-build boundary; the refreshed App reads
+    // the new info above. Incremental updates must never write this file because an App refresh could destroy the heap while
+    // its JavaScript patch is being acknowledged. They publish only the imported `assets/global.wxss` stylesheet instead.
+    await writeHmrFile(server.config.build.outDir, developmentAppWxssFileName, renderDevelopmentAppWxss(buildId));
 }
 /** Replaces browser server URLs with the physical project directory consumed by WeChat DevTools. */
 function installDevToolsPrinter(server) {

package/dist/node/plugins/wx/dev/hmr-files.d.ts

@@ -1,4 +1,5 @@
 import type { BindingClientHmrUpdate } from 'rolldown/experimental';
+export declare const developmentAppWxssFileName = "app.wxss";
 export declare const hmrInfoFileName = "hmr/info.js";
 export declare const hmrPatchesFileName = "hmr/patches.js";
 /** Report endpoint path served by the wx dev control edge. */
@@ -16,6 +17,14 @@ export type PatchUpdate = Extract<BindingClientHmrUpdate['update'], {
 export declare function renderHmrInfo(info: HmrInfo): string;
 /** Provides a valid dependency before the host has a patch range to publish. */
 export declare function renderInitialHmrPatches(): string;
+/**
+ * Renders the native App style entry for one complete development build.
+ *
+ * Imported global CSS can change while the entry remains byte-identical. DevTools may then reuse an older persistent compile
+ * cache after it restarts. Tying this inert comment to the build identity invalidates that cache once per complete build,
+ * while incremental style updates continue changing only the imported file and therefore preserve the App heap.
+ */
+export declare function renderDevelopmentAppWxss(buildId: string): string;
 /**
  * Renders the cumulative patch suffix as inert CommonJS data.
  *

package/dist/node/plugins/wx/dev/hmr-files.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+export const developmentAppWxssFileName = 'app.wxss';
 export const hmrInfoFileName = 'hmr/info.js';
 export const hmrPatchesFileName = 'hmr/patches.js';
 /** Report endpoint path served by the wx dev control edge. */
@@ -13,6 +14,16 @@ export function renderHmrInfo(info) {
 export function renderInitialHmrPatches() {
     return 'module.exports = undefined;\n';
 }
+/**
+ * Renders the native App style entry for one complete development build.
+ *
+ * Imported global CSS can change while the entry remains byte-identical. DevTools may then reuse an older persistent compile
+ * cache after it restarts. Tying this inert comment to the build identity invalidates that cache once per complete build,
+ * while incremental style updates continue changing only the imported file and therefore preserve the App heap.
+ */
+export function renderDevelopmentAppWxss(buildId) {
+    return `@import "./assets/global.wxss";\n/* vpt-build:${buildId} */\n`;
+}
 /**
  * Renders the cumulative patch suffix as inert CommonJS data.
  *

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

@@ -1,10 +1,29 @@
-import type { PluginOption } from 'vite';
+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,
  * Page HMR activation, and React Refresh adaptation transforms.
+ *
+ * The ordered application entries cross this configuration boundary unchanged so the host can compose global CSS without
+ * reconstructing the resolver's App/Page ownership policy from unrelated Rolldown shell and transport entries.
  */
-export declare function createWxDevelopmentPlugin(options: VitePluginTaroOptions): PluginOption[];
+export declare function createWxDevelopmentPlugin(options: VitePluginTaroOptions, applicationEntryIds: readonly string[]): PluginOption[];
+/**
+ * Transfers development ownership of `app.wxss` from complete output to the dev host.
+ *
+ * The ordinary WX output hook emits the static production wrapper during every complete build. In development, the existing
+ * physical wrapper instead contains the previous build ID. If the static asset remained in this bundle, the DevEngine would:
+ *
+ * 1. replace the versioned wrapper with static production bytes while JavaScript and HMR metadata are still being finalized;
+ * 2. let DevTools observe that root-style change and reload the App against the previous build identity;
+ * 3. let the host replace the wrapper again with the new build ID, causing a second App reload.
+ *
+ * Deleting only the in-memory bundle entry avoids both premature writes. Development sets `emptyOutDir: false`, so the prior
+ * physical `app.wxss` remains available while the complete output is written. The host replaces it exactly once after
+ * `hmr/patches.js` and `hmr/info.js` are durable. Incremental HMR never enters this complete-output hook and continues changing
+ * only `assets/global.wxss`, which preserves the App heap. The serve-only plugin leaves production output unchanged.
+ */
+export declare function removeDevelopmentAppWxss(bundle: Record<string, unknown>): void;
 /** Ensures the Refresh hook exists before React's renderer evaluates and injects itself. */
 export declare function injectReactRefreshBootstrap(code: string): {
     code: string;

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

@@ -4,13 +4,18 @@ import { memoize } from '../../../utils/memoize.js';
 import { normalizeModuleId } from '../../../utils/modules.js';
 import { appCapsulePath, pageCapsulePath, rolldownRuntimeId, taroRuntimePath } from '../module.js';
 import { createWxDevHost } from './dev-host.js';
+import { developmentAppWxssFileName } from './hmr-files.js';
 import { createWxReactRefreshTransforms } from './react-refresh.js';
 const taroRuntimeId = '@tarojs/runtime';
 /**
  * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
  * Page HMR activation, and React Refresh adaptation transforms.
+ *
+ * The ordered application entries cross this configuration boundary unchanged so the host can compose global CSS without
+ * reconstructing the resolver's App/Page ownership policy from unrelated Rolldown shell and transport entries.
  */
-export function createWxDevelopmentPlugin(options) {
+export function createWxDevelopmentPlugin(options, applicationEntryIds) {
+    // This mutable handle transfers ownership from configureServer to closeBundle; at most one host exists per plugin instance.
     let host = null;
     // Portable hook filters stay broad; these exact identities exclude similarly named user modules.
     const normalizedAppCapsulePath = normalizeModuleId(appCapsulePath);
@@ -47,7 +52,20 @@ export function createWxDevelopmentPlugin(options) {
                 // asks bundledDev to create its hard-coded skip-write DevEngine.
                 order: 'post',
                 async handler(server) {
-                    host = await createWxDevHost({ server, options });
+                    host = await createWxDevHost({
+                        server: server,
+                        options: options,
+                        applicationEntryIds: applicationEntryIds
+                    });
+                }
+            },
+            generateBundle: {
+                order: 'post',
+                handler(_, bundle) {
+                    // `vpt:wx` emits the production App wrapper during every complete build: initial startup and each
+                    // recovery build, not just once when this plugin instance is created. Development transfers that file
+                    // to the host so its only physical write happens after the matching build identity is durable.
+                    removeDevelopmentAppWxss(bundle);
                 }
             },
             closeBundle() {
@@ -117,6 +135,24 @@ export function createWxDevelopmentPlugin(options) {
         ...createWxReactRefreshTransforms()
     ];
 }
+/**
+ * Transfers development ownership of `app.wxss` from complete output to the dev host.
+ *
+ * The ordinary WX output hook emits the static production wrapper during every complete build. In development, the existing
+ * physical wrapper instead contains the previous build ID. If the static asset remained in this bundle, the DevEngine would:
+ *
+ * 1. replace the versioned wrapper with static production bytes while JavaScript and HMR metadata are still being finalized;
+ * 2. let DevTools observe that root-style change and reload the App against the previous build identity;
+ * 3. let the host replace the wrapper again with the new build ID, causing a second App reload.
+ *
+ * Deleting only the in-memory bundle entry avoids both premature writes. Development sets `emptyOutDir: false`, so the prior
+ * physical `app.wxss` remains available while the complete output is written. The host replaces it exactly once after
+ * `hmr/patches.js` and `hmr/info.js` are durable. Incremental HMR never enters this complete-output hook and continues changing
+ * only `assets/global.wxss`, which preserves the App heap. The serve-only plugin leaves production output unchanged.
+ */
+export function removeDevelopmentAppWxss(bundle) {
+    delete bundle[developmentAppWxssFileName];
+}
 /** Ensures the Refresh hook exists before React's renderer evaluates and injects itself. */
 export function injectReactRefreshBootstrap(code) {
     return {

package/dist/node/plugins/wx/dev/styles/create-style-capture-plugin.d.ts

@@ -0,0 +1,12 @@
+import type { GetModuleInfo, Plugin } from 'rolldown';
+export type ProcessedStyle = Readonly<{
+    css: string;
+    isTailwindRoot: boolean;
+}>;
+type StyleCaptureOptions = Readonly<{
+    captureGraph: (getModuleInfo: GetModuleInfo) => void;
+    captureStyle: (id: string, style: ProcessedStyle) => void;
+}>;
+/** Captures Vite's final development CSS and Rolldown's live graph without running the style pipeline twice. */
+export declare function createStyleCapturePlugin({ captureGraph, captureStyle }: StyleCaptureOptions): Plugin;
+export {};

package/dist/node/plugins/wx/dev/styles/create-style-capture-plugin.js

@@ -0,0 +1,21 @@
+import { normalizeModuleId } from '../../../../utils/modules.js';
+import { extractViteCss, isGlobalStyleRequest } from '../../styles/utils.js';
+/** Captures Vite's final development CSS and Rolldown's live graph without running the style pipeline twice. */
+export function createStyleCapturePlugin({ captureGraph, captureStyle }) {
+    return {
+        name: 'vpt:wx-dev-style-capture',
+        buildStart() {
+            captureGraph((moduleId) => this.getModuleInfo(moduleId));
+        },
+        transform(code, id) {
+            if (!isGlobalStyleRequest(id)) {
+                return;
+            }
+            const css = extractViteCss(code, id);
+            captureStyle(normalizeModuleId(id), {
+                css: css,
+                isTailwindRoot: css.includes('weapp-tailwindcss vite-generated-css:')
+            });
+        }
+    };
+}

package/dist/node/plugins/wx/dev/styles/publish-style-hmr.d.ts

@@ -0,0 +1,27 @@
+import type { ProcessedStyle } from './create-style-capture-plugin.ts';
+export declare const globalWxssFileName = "assets/global.wxss";
+type StyleHmrOptions = Readonly<{
+    styleIds: readonly string[];
+    outDir: string;
+    processedStyles: ReadonlyMap<string, ProcessedStyle>;
+    publishedWxss: string | undefined;
+}>;
+/** Regenerates reachable Tailwind roots concurrently from upstream's current candidate state. */
+export declare function refreshTailwindStyles(styleIds: readonly string[], processedStyles: Map<string, ProcessedStyle>, transformRoot: (rootId: string, requestId: string) => Promise<Readonly<{
+    code: string;
+}> | null>): Promise<void>;
+/**
+ * Materializes one host-owned style snapshot for a completed HMR transaction.
+ *
+ * Rolldown owns topology but does not retain Vite's final CSS module payload, while `processedStyles` owns those payloads but
+ * deliberately retains no topology. The caller supplies the transaction's one ordered graph plan; both Tailwind refresh and
+ * this renderer consume that same snapshot, so sidecar generation cannot cause a second topology traversal.
+ *
+ * Ordinary CSS is never transformed again here: capture already observed it after Vite/PostCSS. The composed stylesheet alone
+ * receives the same final WX conversion as complete builds. Byte equality with the host's physical publication frontier skips
+ * an atomic rename that would otherwise notify DevTools despite no style change. The returned bytes advance that frontier only
+ * after any required write succeeds. The caller awaits this before exposing the corresponding JavaScript patch.
+ * Complexity is O(styles + CSS bytes), after the caller's O(V + E) plan traversal.
+ */
+export declare function publishStyleHmr({ styleIds, outDir, processedStyles, publishedWxss }: StyleHmrOptions): Promise<string>;
+export {};

package/dist/node/plugins/wx/dev/styles/publish-style-hmr.js

@@ -0,0 +1,48 @@
+import { transformWxStyle } from '../../styles/transform-wx-style.js';
+import { composeGraphStyleCss, createTailwindSidecarId, extractViteCss } from '../../styles/utils.js';
+import { writeHmrFile } from '../hmr-files.js';
+export const globalWxssFileName = 'assets/global.wxss';
+/** Regenerates reachable Tailwind roots concurrently from upstream's current candidate state. */
+export async function refreshTailwindStyles(styleIds, processedStyles, transformRoot) {
+    const roots = styleIds.filter((styleId) => requireProcessedStyle(processedStyles, styleId).isTailwindRoot);
+    const refreshedStyles = await Promise.all(roots.map(async (rootId) => {
+        const requestId = createTailwindSidecarId(rootId);
+        const result = await transformRoot(rootId, requestId);
+        if (!result) {
+            throw new Error(`Tailwind sidecar transform produced no result: ${requestId}`);
+        }
+        return [rootId, { css: extractViteCss(result.code, requestId), isTailwindRoot: true }];
+    }));
+    // Commit the cache generation only after every independent root succeeds; a failed sibling cannot leave a mixed snapshot.
+    refreshedStyles.forEach(([rootId, style]) => {
+        processedStyles.set(rootId, style);
+    });
+}
+/**
+ * Materializes one host-owned style snapshot for a completed HMR transaction.
+ *
+ * Rolldown owns topology but does not retain Vite's final CSS module payload, while `processedStyles` owns those payloads but
+ * deliberately retains no topology. The caller supplies the transaction's one ordered graph plan; both Tailwind refresh and
+ * this renderer consume that same snapshot, so sidecar generation cannot cause a second topology traversal.
+ *
+ * Ordinary CSS is never transformed again here: capture already observed it after Vite/PostCSS. The composed stylesheet alone
+ * receives the same final WX conversion as complete builds. Byte equality with the host's physical publication frontier skips
+ * an atomic rename that would otherwise notify DevTools despite no style change. The returned bytes advance that frontier only
+ * after any required write succeeds. The caller awaits this before exposing the corresponding JavaScript patch.
+ * Complexity is O(styles + CSS bytes), after the caller's O(V + E) plan traversal.
+ */
+export async function publishStyleHmr({ styleIds, outDir, processedStyles, publishedWxss }) {
+    const css = composeGraphStyleCss(styleIds, (styleId) => requireProcessedStyle(processedStyles, styleId).css);
+    const wxss = (await transformWxStyle(css)).css;
+    if (wxss !== publishedWxss) {
+        await writeHmrFile(outDir, globalWxssFileName, wxss);
+    }
+    return wxss;
+}
+function requireProcessedStyle(processedStyles, styleId) {
+    const style = processedStyles.get(styleId);
+    if (!style) {
+        throw new Error(`WX style plan references uncaptured CSS: ${styleId}`);
+    }
+    return style;
+}

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

@@ -1,4 +1,4 @@
-import type { InputOptions, OutputOptions } from 'rolldown';
+import type { InputOptions, OutputOptions, Plugin } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
 import type { VitePluginTaroOptions } from '../../../../options.ts';
@@ -16,10 +16,11 @@ export type BundledDev = {
     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 }: {
+export declare function installWxDevOptions({ bundledDev, server, options, hostPlugins }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
     options: VitePluginTaroOptions;
+    hostPlugins: Plugin[];
 }): 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

@@ -6,7 +6,7 @@ import { resolvePackageFile } from '../../../utils/packages.js';
 import { appShellFileName } from '../module.js';
 import { createWxDevMode } from './create-wx-dev-mode.js';
 /** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
-export function installWxDevOptions({ bundledDev, server, options }) {
+export function installWxDevOptions({ bundledDev, server, options, hostPlugins }) {
     // 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();
@@ -47,7 +47,12 @@ export function installWxDevOptions({ bundledDev, server, options }) {
         };
         // Preserve the physical paths watched by WeChat DevTools across host restarts; the complete build overwrites every
         // active output without disrupting the hot-reload watcher.
-        rolldownOptions.plugins = [rolldownOptions.plugins, reportInitialBuildPlugin, createViteReporter(server)];
+        rolldownOptions.plugins = [
+            rolldownOptions.plugins,
+            hostPlugins,
+            reportInitialBuildPlugin,
+            createViteReporter(server)
+        ];
         disableViteOxcSourcemap(rolldownOptions.plugins);
         return rolldownOptions;
     };

package/dist/node/plugins/wx/output/files.d.ts

@@ -1,7 +1,7 @@
 import type { Rolldown } from 'vite';
 import type { VitePluginTaroOptions } from '../../../../options.ts';
 import type { GeneratedSubpackage } from '../placement/placer.ts';
-/** Creates every native companion file derived from the final Rolldown bundle. */
+/** Creates every compiler-owned WX file derived from the final Rolldown bundle. */
 export declare function createOutputFiles({ bundle, options, subpackages, getModuleInfo }: {
     bundle: Rolldown.OutputBundle;
     options: VitePluginTaroOptions;

package/dist/node/plugins/wx/output/files.js

@@ -1,10 +1,15 @@
 import { createNativeComponentOutput } from '../native/create-native-component-output.js';
 import { createJsonAssets } from './json.js';
 import { createTemplateAssets } from './templates.js';
-/** Creates every native companion file derived from the final Rolldown bundle. */
+/** Creates every compiler-owned WX file derived from the final Rolldown bundle. */
 export async function createOutputFiles({ bundle, options, subpackages, getModuleInfo }) {
     const nativeOutput = await createNativeComponentOutput({ bundle, getModuleInfo });
     return [
+        {
+            type: 'asset',
+            fileName: 'app.wxss',
+            source: '@import "./assets/global.wxss";\n'
+        },
         ...createJsonAssets({ options, subpackages, nativeComponents: nativeOutput.registrations }),
         ...createTemplateAssets(bundle, options, nativeOutput.registrations),
         ...nativeOutput.files

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

@@ -11,13 +11,20 @@ import { renderCapsule } from './render/capsule.js';
 import { renderNative } from './render/native.js';
 import { materializeTransport } from './render/transport.js';
 import { createResolver } from './resolve/resolver.js';
+import { createWxStylePlugins } from './styles/plugins.js';
 /** Creates the complete plugin set for the wx target. */
 export function createWxTargetPlugins(options) {
-    return [createWxPlugin(options), createWxDevelopmentPlugin(options)];
+    const resolver = createResolver(options);
+    // Reuse the resolver instance's ordered application subset. Rolldown's complete input also contains bootstrap, transport,
+    // shell, and component entries; entry membership alone cannot recover which roots define the App/Page CSS cascade.
+    return [
+        createWxStylePlugins(),
+        createWxPlugin(options, resolver),
+        createWxDevelopmentPlugin(options, resolver.applicationEntryIds)
+    ];
 }
 /** Configures the complete wx target build pipeline. */
-function createWxPlugin(options) {
-    const resolver = createResolver(options);
+function createWxPlugin(options, resolver) {
     const placer = createPlacer();
     return {
         name: 'vpt:wx',
@@ -103,10 +110,10 @@ function createWxPlugin(options) {
         },
         generateBundle: {
             /*
-             * This hook is registered after createCssPlugins() and shares hook-level `order: 'post'` with the adapted
+             * This hook is registered after createWxStylePlugins() and shares hook-level `order: 'post'` with the adapted
              * upstream hooks and VPT style finalizer. Registration order therefore guarantees that the imported global
-             * stylesheet is complete before native Page/component companions are emitted. Without this order, the finalizer could consume
-             * incomplete Tailwind output or mistake native WXSS companions for additional compiler styles.
+             * stylesheet is complete before native Page/component companions are emitted. Without this order, the finalizer
+             * could consume incomplete Tailwind output or mistake native WXSS companions for additional compiler styles.
              */
             order: 'post',
             async handler(_, bundle) {

package/dist/node/plugins/wx/resolve/resolver.d.ts

@@ -1,7 +1,8 @@
 import type { VitePluginTaroOptions } from '../../../../options.ts';
 /** Creates the resolver and source specializer for the wx module graph. */
 export declare function createResolver(options: VitePluginTaroOptions): {
-    input: Record<string, string>;
     resolveId(id: string, importer: string | undefined, projectRoot: string): string | undefined;
     specialize(code: string, id: string, sourcemap?: boolean): Promise<import("../../../utils/transform.ts").AstTransformResult> | undefined;
+    applicationEntryIds: string[];
+    input: any;
 };