vite-plugin-taro 0.5.12 → 0.5.14

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

@@ -0,0 +1,111 @@
+import { WeappTailwindcss } from 'weapp-tailwindcss/vite';
+import { transformVitePlugin } from '../../../utils/vite.js';
+import { tailwindcssBasedir } from '../../tailwind/tailwind-css.js';
+import { transformWxStyle, wxStyleOptions } from './transform-wx-style.js';
+/*
+ * WX style output order:
+ *
+ *   weapp-tailwindcss output hooks
+ *       → vpt:wx-style-finalizer
+ *       → vpt:wx native companion emission
+ *
+ * All three generateBundle hooks retain hook-level `order: 'post'` and therefore execute in registration order. The
+ * upstream plugin normally also uses plugin-level `enforce: 'post'`, which would move it behind both VPT plugins and
+ * break this sequence. `alignGenerateBundleOrder` removes only that broader phase from upstream output hooks.
+ */
+/** Creates the complete WX Tailwind and global-style pipeline. */
+export function createWxStylePlugins() {
+    const tailwindPlugins = WeappTailwindcss({
+        // VPT is a custom Vite compiler.
+        // Using Taro's adapter would import Taro-specific CSS ownership rules which we don't need.
+        appType: 'weapp-vite',
+        // WX generation rewrites Tailwind's split package imports before Vite tries to resolve them in the app.
+        // Without this, strict workspaces fail on imports such as `tailwindcss/theme.css`.
+        rewriteCssImports: true,
+        platform: 'weapp',
+        tailwindcssBasedir,
+        generator: {
+            target: 'weapp'
+        },
+        cssOptions: wxStyleOptions,
+        logLevel: 'warn'
+    }) ?? [];
+    return [transformVitePlugin(tailwindPlugins, alignGenerateBundleOrder), createWxStyleFinalizer(transformWxStyle)];
+}
+/**
+ * Finalizes the one global stylesheet after upstream Tailwind generation.
+ *
+ * `cssCodeSplit: false` makes the compiler style global, but upstream can name it `.css` or `.wxss` depending on build
+ * mode. This hook converts its complete final contents once and renames that compiler asset to `assets/global.wxss`. An
+ * application without styles receives an empty global asset at the same stable path. Running earlier loses CSS from
+ * dynamic chunks; running after native companion emission would also see Page and native-component WXSS files that must
+ * remain opaque.
+ */
+function createWxStyleFinalizer(transformStyle) {
+    /*
+     * DevEngine can omit an unchanged stylesheet from later complete output generations. Absence therefore has two meanings:
+     * the first clean output genuinely has no styles, or a later output is reusing the physical stylesheet already on disk.
+     * The Vite server creates a fresh plugin instance on a clean start, so this one lifecycle bit distinguishes those cases and
+     * resets naturally on restart. Deliberately retain no CSS bytes or graph projection here: memory remains O(1), changed CSS
+     * still arrives as a normal asset, and the dev host remains the only owner of incremental style preparation.
+     */
+    let hasFinalizedOutput = false;
+    return {
+        name: 'vpt:wx-style-finalizer',
+        generateBundle: {
+            order: 'post',
+            async handler(_, bundle) {
+                const styles = Object.values(bundle).filter(isStyleAsset);
+                // Multiple compiler styles mean cssCodeSplit was re-enabled. Choosing one would silently lose CSS.
+                if (styles.length > 1) {
+                    throw new Error('WX builds support at most one compiler-emitted stylesheet');
+                }
+                if (styles.length === 0) {
+                    /*
+                     * A clean first output must materialize the stable import target imported by app.wxss. On later complete
+                     * outputs, DevEngine's physical writer preserves files omitted from the bundle; emitting the same empty
+                     * placeholder would instead overwrite valid unchanged WXSS. Emit nothing in that later case. A source or
+                     * configuration change that really removes all styles is already published as empty by ordinary style HMR,
+                     * while a clean server restart reaches this first-output branch and also clears any stale prior file.
+                     */
+                    if (!hasFinalizedOutput) {
+                        this.emitFile({ type: 'asset', fileName: 'assets/global.wxss', source: '' });
+                    }
+                    hasFinalizedOutput = true;
+                    return;
+                }
+                const [style] = styles;
+                const source = typeof style.source === 'string' ? style.source : new TextDecoder().decode(style.source);
+                const transformedResult = await transformStyle(source);
+                // Preserve the compiler stylesheet as the real global asset so its bundle metadata and ownership remain
+                // intact. Only its finalized contents and stable WXSS identity change.
+                style.source = transformedResult.css;
+                style.fileName = 'assets/global.wxss';
+                hasFinalizedOutput = true;
+            }
+        }
+    };
+}
+/**
+ * Adapts upstream plugin descriptors without mutating `weapp-tailwindcss` or patching node_modules.
+ *
+ * Vite first groups whole plugins by `enforce`, then orders individual hooks. Upstream's output plugins specify both
+ * `enforce: 'post'` and `generateBundle.order: 'post'`. The plugin-level phase overrides their earlier registration and
+ * places them after VPT's normal plugins, so VPT observes incomplete CSS. Making all of VPT post-enforced would fix that
+ * one hook while unnecessarily reordering resolution and transforms.
+ *
+ * For upstream plugins that actually own generateBundle, clone the descriptor without plugin-level enforcement. Keep
+ * hook-level `order: 'post'`: it still waits for ordinary bundle generation, while registration order becomes the sole
+ * tie-breaker between upstream generation, VPT finalization and native output.
+ */
+function alignGenerateBundleOrder(plugin) {
+    if (plugin.enforce !== 'post' || plugin.generateBundle === undefined) {
+        return plugin;
+    }
+    // Clone rather than mutate: upstream may retain or reuse the descriptor returned by its factory.
+    return { ...plugin, enforce: undefined };
+}
+/** Selects only the compiler stylesheet; native WXSS assets are emitted by the later WX hook. */
+function isStyleAsset(output) {
+    return output.type === 'asset' && /\.(?:css|wxss)$/.test(output.fileName);
+}

package/dist/node/plugins/wx/styles/transform-wx-style.d.ts

@@ -0,0 +1,8 @@
+export declare const wxStyleOptions: {
+    readonly cssCalc: false;
+    readonly autoprefixer: false;
+    readonly rem2rpx: true;
+    readonly px2rpx: true;
+};
+/** Shared finalization policy for complete builds and host-owned style HMR. */
+export declare const transformWxStyle: import("@weapp-tailwindcss/postcss").StyleHandler;

package/dist/node/plugins/wx/styles/transform-wx-style.js

@@ -0,0 +1,9 @@
+import { createStyleHandler } from '@weapp-tailwindcss/postcss';
+export const wxStyleOptions = {
+    cssCalc: false,
+    autoprefixer: false,
+    rem2rpx: true,
+    px2rpx: true
+};
+/** Shared finalization policy for complete builds and host-owned style HMR. */
+export const transformWxStyle = createStyleHandler(wxStyleOptions);

package/dist/node/plugins/wx/styles/utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Creates an auxiliary style request without replacing the physical Rolldown graph module.
+ *
+ * `weapp-vite-sidecar` is an upstream protocol marker, not a cache-busting nonce. `weapp-tailwindcss` detects the query
+ * key, strips the complete query when resolving the physical CSS pipeline file, and excludes this synthetic request from
+ * transformed-source candidate collection. That lets the request use the latest candidate state without feeding generated
+ * CSS back into Tailwind's source memory. The descriptive `style` value is stable; upstream treats the presence of the key
+ * as the protocol contract.
+ */
+export declare function createTailwindSidecarId(rootId: string): string;
+/** Selects imported style modules whose Vite development output owns a runtime CSS payload. */
+export declare function isGlobalStyleRequest(id: string): boolean;
+/**
+ * Creates the ordered style plan for one completed HMR transaction.
+ *
+ * `entryIds` carries semantic cascade ownership from the WX resolver: the App capsule first, followed by Page capsules in
+ * configured route order. Each entry is traversed depth-first. Static imports retain source order and precede dynamic imports;
+ * dynamic branches are included because WX cannot inject lazy CSS at browser runtime. A style follows its dependencies,
+ * matching evaluation order.
+ *
+ * Graph IDs may contain queries while `hasStyle` reads physical IDs. Normalization lets aliases share one captured style.
+ * JavaScript and non-runtime CSS requests remain traversal nodes but do not enter the plan. All mutable traversal state is
+ * transaction-local, so import additions and removals need no invalidation bookkeeping. Complexity is O(modules + edges),
+ * with O(modules + styles) temporary memory.
+ */
+export declare function createGraphStylePlan(entryIds: readonly string[], getModuleInfo: (moduleId: string) => Readonly<{
+    importedIds: readonly string[];
+    dynamicallyImportedIds: readonly string[];
+}> | null, hasStyle: (styleId: string) => boolean): readonly string[];
+/** Renders one immutable graph plan after any Tailwind roots in that same plan have been refreshed. */
+export declare function composeGraphStyleCss(styleIds: readonly string[], getStyleCss: (styleId: string) => string): string;
+/**
+ * Extracts Vite's final CSS payload from the development module without evaluating its browser HMR code.
+ *
+ * Remove this parser when either Vite exposes a supported plugin-container API that returns final CSS directly, or
+ * `weapp-tailwindcss` exposes generated root CSS after candidate updates. Until then the sidecar receives Vite's JavaScript
+ * style module, so this function isolates the version-specific `__vite__css` serialization contract.
+ */
+export declare function extractViteCss(moduleCode: string, rootId: string): string;

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

@@ -0,0 +1,95 @@
+import { isCSSRequest } from 'vite';
+import { normalizeModuleId } from '../../../utils/modules.js';
+const nonRuntimeStyleQueries = ['direct', 'inline', 'inline-css', 'raw', 'style-attr', 'transform-only', 'url'];
+/**
+ * Creates an auxiliary style request without replacing the physical Rolldown graph module.
+ *
+ * `weapp-vite-sidecar` is an upstream protocol marker, not a cache-busting nonce. `weapp-tailwindcss` detects the query
+ * key, strips the complete query when resolving the physical CSS pipeline file, and excludes this synthetic request from
+ * transformed-source candidate collection. That lets the request use the latest candidate state without feeding generated
+ * CSS back into Tailwind's source memory. The descriptive `style` value is stable; upstream treats the presence of the key
+ * as the protocol contract.
+ */
+export function createTailwindSidecarId(rootId) {
+    return `${rootId}?weapp-vite-sidecar=style`;
+}
+/** Selects imported style modules whose Vite development output owns a runtime CSS payload. */
+export function isGlobalStyleRequest(id) {
+    if (!isCSSRequest(id)) {
+        return false;
+    }
+    const queryStart = id.indexOf('?');
+    if (queryStart < 0) {
+        return true;
+    }
+    const fragmentStart = id.indexOf('#', queryStart);
+    const query = id.slice(queryStart + 1, fragmentStart < 0 ? undefined : fragmentStart);
+    const parameters = new URLSearchParams(query);
+    return (!parameters.has('weapp-vite-sidecar') && nonRuntimeStyleQueries.every((parameter) => !parameters.has(parameter)));
+}
+/**
+ * Creates the ordered style plan for one completed HMR transaction.
+ *
+ * `entryIds` carries semantic cascade ownership from the WX resolver: the App capsule first, followed by Page capsules in
+ * configured route order. Each entry is traversed depth-first. Static imports retain source order and precede dynamic imports;
+ * dynamic branches are included because WX cannot inject lazy CSS at browser runtime. A style follows its dependencies,
+ * matching evaluation order.
+ *
+ * Graph IDs may contain queries while `hasStyle` reads physical IDs. Normalization lets aliases share one captured style.
+ * JavaScript and non-runtime CSS requests remain traversal nodes but do not enter the plan. All mutable traversal state is
+ * transaction-local, so import additions and removals need no invalidation bookkeeping. Complexity is O(modules + edges),
+ * with O(modules + styles) temporary memory.
+ */
+export function createGraphStylePlan(entryIds, getModuleInfo, hasStyle) {
+    // These local collections collapse cycles, shared modules, and aliases without retaining derived topology between batches.
+    const visitedModuleIds = new Set();
+    const visitedStyleIds = new Set();
+    const styleIds = [];
+    const visit = (moduleId) => {
+        if (visitedModuleIds.has(moduleId)) {
+            return;
+        }
+        visitedModuleIds.add(moduleId);
+        const moduleInfo = getModuleInfo(moduleId);
+        if (!moduleInfo) {
+            return;
+        }
+        moduleInfo.importedIds.forEach(visit);
+        moduleInfo.dynamicallyImportedIds.forEach(visit);
+        const styleId = normalizeModuleId(moduleId);
+        if (hasStyle(styleId) && !visitedStyleIds.has(styleId)) {
+            visitedStyleIds.add(styleId);
+            styleIds.push(styleId);
+        }
+    };
+    entryIds.forEach(visit);
+    return styleIds;
+}
+/** Renders one immutable graph plan after any Tailwind roots in that same plan have been refreshed. */
+export function composeGraphStyleCss(styleIds, getStyleCss) {
+    return styleIds.map(getStyleCss).join('\n');
+}
+/**
+ * Extracts Vite's final CSS payload from the development module without evaluating its browser HMR code.
+ *
+ * Remove this parser when either Vite exposes a supported plugin-container API that returns final CSS directly, or
+ * `weapp-tailwindcss` exposes generated root CSS after candidate updates. Until then the sidecar receives Vite's JavaScript
+ * style module, so this function isolates the version-specific `__vite__css` serialization contract.
+ */
+export function extractViteCss(moduleCode, rootId) {
+    const assignmentPrefix = 'const __vite__css = ';
+    const assignmentStart = moduleCode.indexOf(assignmentPrefix);
+    if (assignmentStart < 0) {
+        throw new Error(`Vite CSS transform for ${rootId} did not expose __vite__css`);
+    }
+    // Vite serializes the payload with JSON.stringify on one assignment line. Parse that literal so quotes, escapes, and
+    // embedded CSS newlines are decoded by JSON rather than by a second, subtly different unescaping implementation.
+    const valueStart = assignmentStart + assignmentPrefix.length;
+    const lineEnd = moduleCode.indexOf('\n', valueStart);
+    const serializedCss = moduleCode.slice(valueStart, lineEnd < 0 ? moduleCode.length : lineEnd);
+    const css = JSON.parse(serializedCss);
+    if (typeof css !== 'string') {
+        throw new Error(`Vite CSS transform for ${rootId} exposed a non-string __vite__css value`);
+    }
+    return css;
+}

package/dist/node/utils/modules.d.ts

@@ -14,7 +14,7 @@ export declare function resolveAppComponentPath({ appPath, projectRoot }: AppCom
 export declare function resolvePageComponentPath({ pagePath, projectRoot }: PageComponentPathOptions): string;
 /** Creates a portable import for one configured Page component. */
 export declare function createPageComponentImportPath(options: PageComponentPathOptions): string;
-/** Normalizes a file-backed Vite module ID for stable comparisons. */
+/** Converts a file-backed Vite request ID to its normalized physical path for stable comparisons. */
 export declare function normalizeModuleId(id: string): string;
 /** Converts a local file path into Vite's portable file-system import form. */
 export declare function toViteFileImportPath(filePath: string): string;

package/dist/node/utils/modules.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { normalizePath } from 'vite';
 /** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
 export function resolveChunkReference(importerChunkId, reference) {
     if (!reference.startsWith('./') && !reference.startsWith('../')) {
@@ -18,11 +19,11 @@ export function resolvePageComponentPath({ pagePath, projectRoot }) {
 export function createPageComponentImportPath(options) {
     return toViteFileImportPath(resolvePageComponentPath(options));
 }
-/** Normalizes a file-backed Vite module ID for stable comparisons. */
+/** Converts a file-backed Vite request ID to its normalized physical path for stable comparisons. */
 export function normalizeModuleId(id) {
-    return id.replaceAll('\\', '/').replace(/\?.*$/, '');
+    return normalizePath(id.replace(/\?.*$/, ''));
 }
 /** Converts a local file path into Vite's portable file-system import form. */
 export function toViteFileImportPath(filePath) {
-    return `/@fs/${normalizeModuleId(path.resolve(filePath))}`;
+    return `/@fs/${normalizePath(path.resolve(filePath))}`;
 }

package/dist/node/utils/packages.js

@@ -1,9 +1,9 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { normalizeModuleId } from './modules.js';
+import { normalizePath } from 'vite';
 export const packageRequire = createRequire(import.meta.url);
 const packageRoot = path.dirname(packageRequire.resolve('vite-plugin-taro/package.json'));
 /** Resolves a file shipped by this package as a portable Vite module ID. */
 export function resolvePackageFile(...segments) {
-    return normalizeModuleId(path.join(packageRoot, ...segments));
+    return normalizePath(path.join(packageRoot, ...segments));
 }

package/dist/node/utils/vite.d.ts

@@ -0,0 +1,17 @@
+import type { HookHandler, Plugin, PluginOption } from 'vite';
+type TransformHook = HookHandler<NonNullable<Plugin['transform']>>;
+export type TransformHookResult = Awaited<ReturnType<TransformHook>>;
+export type AsyncTransformHook = (this: ThisParameterType<TransformHook>, ...args: Parameters<TransformHook>) => Promise<TransformHookResult>;
+export type TransformHookWrapper = (transform: AsyncTransformHook) => AsyncTransformHook;
+export type PluginMapper = (plugin: Plugin) => Plugin;
+/** Transforms every concrete plugin while preserving nested arrays, falsy options, and promised options. */
+export declare function transformVitePlugin(pluginOptions: PluginOption[], mapPlugin: PluginMapper): PluginOption[];
+/**
+ * Clones a Vite transform hook with middleware that controls execution of the original handler.
+ *
+ * Function and object hook forms retain their original plugin context. Object metadata such as `order` and `filter` is copied
+ * unchanged, and the input descriptor is never mutated. The wrapper receives the normalized asynchronous transform with its
+ * complete plugin context, code, ID, and metadata signature, and returns the handler that continues Vite's plugin pipeline.
+ */
+export declare function wrapPluginTransform(plugin: Plugin, wrapper: TransformHookWrapper): Plugin;
+export {};

package/dist/node/utils/vite.js

@@ -0,0 +1,43 @@
+/** Transforms every concrete plugin while preserving nested arrays, falsy options, and promised options. */
+export function transformVitePlugin(pluginOptions, mapPlugin) {
+    return pluginOptions.map((option) => transformPluginOption(option, mapPlugin));
+}
+function transformPluginOption(option, mapPlugin) {
+    if (option instanceof Promise) {
+        return option.then((resolvedOption) => transformPluginOption(resolvedOption, mapPlugin));
+    }
+    if (Array.isArray(option)) {
+        return transformVitePlugin(option, mapPlugin);
+    }
+    return isPlugin(option) ? mapPlugin(option) : option;
+}
+function isPlugin(option) {
+    return (option !== null &&
+        option !== false &&
+        option !== undefined &&
+        typeof option === 'object' &&
+        !Array.isArray(option) &&
+        'name' in option);
+}
+/**
+ * Clones a Vite transform hook with middleware that controls execution of the original handler.
+ *
+ * Function and object hook forms retain their original plugin context. Object metadata such as `order` and `filter` is copied
+ * unchanged, and the input descriptor is never mutated. The wrapper receives the normalized asynchronous transform with its
+ * complete plugin context, code, ID, and metadata signature, and returns the handler that continues Vite's plugin pipeline.
+ */
+export function wrapPluginTransform(plugin, wrapper) {
+    const { transform } = plugin;
+    if (!transform) {
+        throw new Error(`${plugin.name} must expose a transform hook`);
+    }
+    const isTransformFunction = typeof transform === 'function';
+    const handler = isTransformFunction ? transform : transform.handler;
+    const wrappedHandler = wrapper(async function (code, id, meta) {
+        return handler.call(this, code, id, meta);
+    });
+    return {
+        ...plugin,
+        transform: isTransformFunction ? wrappedHandler : { ...transform, handler: wrappedHandler }
+    };
+}

package/dist/node/vite-plugin.js

@@ -1,7 +1,6 @@
 import react from '@vitejs/plugin-react';
 import { createClientTaroPlugin } from './plugins/client/client-taro.js';
 import { createConditionalDirectivePlugin } from './plugins/conditional/conditional-directives.js';
-import { createCssPlugins } from './plugins/css/plugins.js';
 import { createH5TargetPlugins } from './plugins/h5/plugins.js';
 import { createWxTargetPlugins } from './plugins/wx/plugins.js';
 /** Creates the Vite plugins for one Taro target. */
@@ -9,7 +8,6 @@ export default function vitePluginTaro(options) {
     return [
         createConditionalDirectivePlugin(options.target),
         createClientTaroPlugin(options.target),
-        ...createCssPlugins(options.target),
         ...react(),
         ...(options.target === 'wx' ? createWxTargetPlugins(options) : []),
         ...(options.target === 'h5' ? createH5TargetPlugins(options) : [])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.5.12",
+  "version": "0.5.14",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat Mini Program and H5 targets.",
   "type": "module",
@@ -73,10 +73,11 @@
     "react-reconciler": "0.33.0",
     "react-refresh": "^0.18.0",
     "rolldown": "1.2.3",
+    "rxjs": "^7.8.2",
     "tailwindcss": "^4.3.3",
     "weapp-tailwindcss": "^5.2.11",
-    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.5.12",
-    "@tarojs/react": "npm:vite-plugin-taro-react@0.5.12"
+    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.5.14",
+    "@tarojs/react": "npm:vite-plugin-taro-react@0.5.14"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/node/plugins/client/client-taro.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite'
+import { normalizePath, type Plugin } from 'vite'
 import type { VitePluginTaroTarget } from '../../../options.ts'
 import { normalizeModuleId } from '../../utils/modules.ts'
 import { resolvePackageFile } from '../../utils/packages.ts'
@@ -21,7 +21,7 @@ import { injectTaroFrameworkApis } from './inject-taro-framework-apis.ts'
 export const clientTaroApiId = 'virtual:taro/api'
 
 const clientTaroApiPath = resolvePackageFile('dist/runtime/client/taro/api.js')
-const normalizedClientTaroApiPath = normalizeModuleId(clientTaroApiPath)
+const normalizedClientTaroApiPath = normalizePath(clientTaroApiPath)
 
 const clientTaroComponentId = 'virtual:taro/components'
 

package/src/node/plugins/h5/create-stencil-client-adapter.ts

@@ -1,6 +1,6 @@
 import type { WalkerEnter } from 'oxc-walker'
 import type { RolldownMagicString } from 'rolldown'
-import type { Plugin } from 'vite'
+import { normalizePath, type Plugin } from 'vite'
 import { normalizeModuleId } from '../../utils/modules.ts'
 import { transformWithOxcWalker } from '../../utils/oxc-transform.ts'
 import { packageRequire } from '../../utils/packages.ts'
@@ -8,7 +8,7 @@ import { packageRequire } from '../../utils/packages.ts'
 const stencilClientPath = packageRequire.resolve('@stencil/core/internal/client', {
     paths: [packageRequire.resolve('@tarojs/components/package.json')]
 })
-const normalizedStencilClientPath = normalizeModuleId(stencilClientPath)
+const normalizedStencilClientPath = normalizePath(stencilClientPath)
 
 /**
  * Creates the compiler-owned adaptation of Stencil's client style insertion.

package/src/node/plugins/h5/plugins.ts

@@ -1,17 +1,38 @@
 import babel, { defineRolldownBabelPreset } from '@rolldown/plugin-babel'
 import type { HtmlTagDescriptor, Plugin, PluginOption } from 'vite'
+import { WeappTailwindcss } from 'weapp-tailwindcss/vite'
 import type { VitePluginTaroOptions } from '../../../options.ts'
 import { esTarget } from '../../utils/constant.ts'
 import { toViteFileImportPath } from '../../utils/modules.ts'
 import { packageRequire } from '../../utils/packages.ts'
 import { clientTaroApiId } from '../client/client-taro.ts'
+import { tailwindcssBasedir } from '../tailwind/tailwind-css.ts'
 import { h5AppPath } from './constant.ts'
 import { createStencilClientAdapter } from './create-stencil-client-adapter.ts'
 import { createModuleResolver } from './resolver/module-resolver.ts'
 
 /** Creates the plugins that own the H5 target. */
 export function createH5TargetPlugins(options: VitePluginTaroOptions): PluginOption[] {
-    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. */

package/src/node/plugins/h5/resolver/module-resolver.ts

@@ -1,3 +1,4 @@
+import { normalizePath } from 'vite'
 import type { VitePluginTaroOptions } from '../../../../options.ts'
 import { normalizeModuleId, resolveAppComponentPath } from '../../../utils/modules.ts'
 import { appComponentId } from '../../client/constant.ts'
@@ -24,7 +25,7 @@ export function createModuleResolver(options: VitePluginTaroOptions) {
             projectRoot: string
             sourcemap?: boolean
         }) {
-            if (normalizeModuleId(id) === normalizeModuleId(h5AppPath)) {
+            if (normalizeModuleId(id) === normalizePath(h5AppPath)) {
                 return transformH5App({ code, id, options, projectRoot, sourcemap })
             }
         }

package/src/node/plugins/tailwind/tailwind-css.ts

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

package/src/node/plugins/wx/dev/create-hmr-results-stream.ts

@@ -0,0 +1,71 @@
+import type { DevOptions } from 'rolldown/experimental'
+import { buffer, debounceTime, filter, type SchedulerLike, Subject } from 'rxjs'
+
+type HmrUpdatesResult = Parameters<NonNullable<DevOptions['onHmrUpdates']>>[0]
+type HmrUpdates = Exclude<HmrUpdatesResult, Error>
+
+/**
+ * Adapts Rolldown's non-awaited HMR callback into lossless quiet-window publications.
+ *
+ * Debouncing the result stream itself would retain only the final callback and lose incremental patch factories that later
+ * patches provably do not reproduce. Instead, the debounced view is only a closing notifier for `buffer`: every callback is
+ * retained in arrival order, and one configured quiet period emits the complete window to the host's existing serialized
+ * writer. This first stream migration deliberately does not own physical state; `publish` and `reportError` remain synchronous
+ * admission callbacks so the dev host can enqueue both through its single writer.
+ *
+ * DevEngine failures are values, not Observable errors. They represent transient editor generations and carry no executable
+ * patch, so the stream reports the final error but otherwise removes them. Successful callbacks on either side remain ordered
+ * and lossless; Rolldown generated each against its unpublished client frontier, and the host delivers every retained payload.
+ * Completing the returned Subject flushes its current buffer synchronously, allowing host shutdown to await the resulting
+ * serialized task rather than silently dropping an admitted patch.
+ *
+ * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until the quiet edge.
+ */
+export function createHmrResultsStream(
+    settleMilliseconds: number,
+    scheduler: SchedulerLike,
+    publish: (result: HmrUpdates) => void,
+    reportError: (error: Error) => void
+): Subject<HmrUpdatesResult> {
+    /*
+     * This hot Subject is the sole mutable boundary between Rolldown's non-awaited callback and RxJS. Each next preserves one
+     * compiler generation by reference and in arrival order. buffer owns the temporary lossless window; debounceTime observes the
+     * same Subject only to decide when that window closes. Replacing this with a debounced scalar would discard patch factories,
+     * while letting callback Promises mutate host state directly would overlap publications. Completion flushes the final window
+     * before shutdown, after which the Subject is never reused.
+     */
+    const results = new Subject<HmrUpdatesResult>()
+
+    results
+        .pipe(
+            buffer(results.pipe(debounceTime(settleMilliseconds, scheduler))),
+            filter((window) => window.length > 0)
+        )
+        .subscribe((window) => {
+            /*
+             * An Error is one source generation that produced no executable delta; it does not invalidate successful Rolldown
+             * callbacks already admitted on either side of it. Dropping the whole quiet window would therefore discard real
+             * patch factories, while starting a complete build would compile the same known-invalid editor contents. Keep the
+             * old runtime running, report only the latest diagnostic from a repeated parser burst, and continue below with the
+             * successful callback values exactly as if the temporary invalid save had never produced an HMR payload.
+             */
+            const lastFailure = window.findLast((result): result is Error => result instanceof Error)
+            if (lastFailure) {
+                reportError(lastFailure)
+            }
+            const successfulWindow = window.filter((result): result is HmrUpdates => !(result instanceof Error))
+            if (successfulWindow.length > 0) {
+                /*
+                 * flatMap preserves callback arrival order and each callback's internal Rolldown order. Updates must not be
+                 * deduplicated: later undelivered patches are deltas and do not reproduce factories from earlier sequences.
+                 * changedFiles is opaque DevEngine metadata and has no identity semantics in the host, so preserving its raw
+                 * concatenation is both cheaper and more faithful than maintaining a second Set-based interpretation here.
+                 */
+                publish({
+                    updates: successfulWindow.flatMap((result) => result.updates),
+                    changedFiles: successfulWindow.flatMap((result) => result.changedFiles)
+                })
+            }
+        })
+    return results
+}