vite-plugin-taro 0.6.3 → 0.6.6

package/README.en.md

@@ -1,4 +1,4 @@
-# vite-plugin-taro
+# VPT
 
 [![npm version](https://img.shields.io/npm/v/vite-plugin-taro.svg)](https://www.npmjs.com/package/vite-plugin-taro)
 ![Vite](https://img.shields.io/npm/dependency-version/vite-plugin-taro/peer/vite?label=Vite)
@@ -20,7 +20,7 @@ Continue with the [Quick Start guide](https://vpt.js.org/guides/quick-start/).
 
 ### React Hot Reload in WeChat DevTools
 
-<video src="https://github.com/user-attachments/assets/cb93daf5-1827-496a-bb74-8397975accf6" controls autoplay muted loop playsinline width="100%"></video>
+<video src="https://github.com/user-attachments/assets/c8289e1e-d8ad-429f-a0d9-a40656b4962a" controls autoplay muted loop playsinline width="100%"></video>
 
 - **Vite 8 + React 19** Build one codebase for WeChat Mini Program and Web with the Vite ecosystem.
 - **Hot reload** Preserve App data, the active page, React component state, and input state while editing.
@@ -39,7 +39,7 @@ Continue with the [Quick Start guide](https://vpt.js.org/guides/quick-start/).
 - [Configuration options](https://vpt.js.org/guides/configuration/)
 - [Conditional compilation](https://vpt.js.org/guides/conditional-directives/)
 - [Skyline mode](https://vpt.js.org/guides/skyline-mode/)
-- [Migrate from Taro CLI](https://vpt.js.org/guides/migrate-from-taro/)
+- [Migrate from Taro](https://vpt.js.org/guides/migrate-from-taro/)
 - [Module system](https://vpt.js.org/references/module-system/)
 - [Hot module replacement internals](https://vpt.js.org/references/hmr-implementation/)
 - [Repository management](https://vpt.js.org/references/repository-management/)

package/README.md

@@ -1,4 +1,4 @@
-# vite-plugin-taro
+# VPT
 
 [![npm version](https://img.shields.io/npm/v/vite-plugin-taro.svg)](https://www.npmjs.com/package/vite-plugin-taro)
 ![Vite](https://img.shields.io/npm/dependency-version/vite-plugin-taro/peer/vite?label=Vite)
@@ -21,7 +21,7 @@ npm create vite-taro@latest my-app
 
 ### 已支持微信开发者工具的 React 热更新
 
-<video src="https://github.com/user-attachments/assets/cb93daf5-1827-496a-bb74-8397975accf6" controls autoplay muted loop playsinline width="100%"></video>
+<video src="https://github.com/user-attachments/assets/c8289e1e-d8ad-429f-a0d9-a40656b4962a" controls autoplay muted loop playsinline width="100%"></video>
 
 - **Vite 8 + React 19** 基于 Vite 生态，一份代码覆盖微信小程序与 Web。
 - **热更新** 编辑代码时保留 App 数据、当前页面、React 组件状态与输入状态。
@@ -40,7 +40,7 @@ npm create vite-taro@latest my-app
 - [配置选项](https://vpt.js.org/guides/configuration/)
 - [条件编译](https://vpt.js.org/guides/conditional-directives/)
 - [Skyline 模式](https://vpt.js.org/guides/skyline-mode/)
-- [从 Taro CLI 迁移](https://vpt.js.org/guides/migrate-from-taro/)
+- [从 Taro 迁移](https://vpt.js.org/guides/migrate-from-taro/)
 - [模块系统](https://vpt.js.org/references/module-system/)
 - [热更新原理](https://vpt.js.org/references/hmr-implementation/)
 - [仓库维护](https://vpt.js.org/references/repository-management/)

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

@@ -1,5 +1,6 @@
 import type { ViteDevServer } from 'vite';
 import type { VptOptions } from '../../../../options.ts';
+import type { WxStylePlugin } from '../styles/plugins.ts';
 export type WxDevHost = Readonly<{
     close: () => Promise<void>;
 }>;
@@ -9,11 +10,11 @@ export type WxDevHost = Readonly<{
  * 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.
+ * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
+ * every live import edge.
  */
-export declare function createWxDevHost({ server, options, applicationEntryIds }: {
+export declare function createWxDevHost({ server, options, styles }: {
     server: ViteDevServer;
     options: VptOptions;
-    applicationEntryIds: readonly string[];
+    styles: WxStylePlugin;
 }): Promise<WxDevHost>;

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

@@ -1,11 +1,9 @@
-import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import colors from 'picocolors';
 import { dev } from 'rolldown/experimental';
 import { asyncScheduler } from 'rxjs';
 import { createHmrResultsStream } from './create-hmr-results-stream.js';
-import { createStyleCapture } from './create-style-capture.js';
-import { developmentAppWxssFileName, hmrControlPath, hmrInfoFileName, hmrPatchesFileName, renderDevelopmentAppWxss, renderHmrInfo, renderInitialHmrPatches, writeHmrFile } from './hmr-files.js';
+import { developmentAppWxssFileName, globalWxssFileName, hmrControlPath, hmrInfoFileName, hmrPatchesFileName, renderDevelopmentAppWxss, renderHmrInfo, renderInitialHmrPatches, writeHmrFile } from './hmr-files.js';
 import { createHostActions } from './host-actions.js';
 import { PatchPublisher } from './patch-publisher.js';
 import { createRuntimeReportsStream } from './runtime-reports.js';
@@ -18,27 +16,16 @@ const hmrSettleMilliseconds = 16;
  * 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.
+ * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
+ * every live import edge.
  */
-export async function createWxDevHost({ server, options, applicationEntryIds }) {
+export async function createWxDevHost({ server, options, styles }) {
     const bundledDev = getBundledDev(server);
     // All callbacks admit typed actions through this edge; concatMap is the sole owner of effect ordering and mutable host state.
     const hostActions = createHostActions(applyHostAction, (action, error) => logWxError(server.config.logger, `wx HMR ${action.kind} failed`, error));
-    const styleCapture = createStyleCapture({
-        applicationEntryIds: applicationEntryIds,
-        outDir: server.config.build.outDir,
-        // Capture hooks run only after engine.run, when the host action subscription and all reducer dependencies are ready.
-        emit: (action) => hostActions.next(action),
-        transformTailwindRoot: async (rootId, requestId) => {
-            // The capture contains generated CSS, while the sidecar must re-run from raw Tailwind directives. Vite exposes no
-            // raw source in its live module graph, so this read is the authoritative source generation rather than a read-back.
-            return server.environments.client.pluginContainer.transform(await readFile(rootId, 'utf8'), requestId);
-        }
-    });
     const publisher = new PatchPublisher((content) => writeHmrFile(server.config.build.outDir, hmrPatchesFileName, content));
     // Option installation now configures only Rolldown. Build lifecycle results enter through the engine's output action below.
-    installWxDevOptions({ bundledDev, server, options, hostPlugins: [styleCapture.plugin] });
+    installWxDevOptions({ bundledDev, server, options });
     const engine = await createEngine();
     const hmrResults = createHmrResultsStream(hmrSettleMilliseconds, asyncScheduler, (result) => {
         // One reduced window becomes one existing host transaction: style preparation, one cumulative patch write, then
@@ -98,11 +85,15 @@ export async function createWxDevHost({ server, options, applicationEntryIds })
             hmrResults.complete();
             runtimeReports.complete();
             await hostActions.waitForIdle();
-            // Keep the action edge open until the final generation has admitted all capture and output callbacks.
+            // Keep the action edge open until the final generation has admitted every output callback.
             await engine.ensureCurrentBuildFinish();
             await hostActions.complete();
         }
     };
+    /** Atomically materializes the style plugin's prepared global artifact. */
+    async function writeGlobalStyle(wxss) {
+        await writeHmrFile(server.config.build.outDir, globalWxssFileName, wxss);
+    }
     /** Rotates the build identity and materializes the App metadata for it. */
     async function rotateBuildSession() {
         const port = boundPort(server);
@@ -142,14 +133,6 @@ export async function createWxDevHost({ server, options, applicationEntryIds })
     /** Reduces one merged source action through the existing authoritative host state. */
     function applyHostAction(action) {
         switch (action.kind) {
-            case 'capture-graph':
-                // The buildStart reader is a live capability; replacing it only here makes the reducer own build rebinding.
-                styleCapture.captureGraph(action.getModuleInfo);
-                return;
-            case 'capture-style':
-                // A failed upstream transform emits no action, intentionally retaining the last valid processed CSS generation.
-                styleCapture.captureStyle(action.id, action.style);
-                return;
             case 'publish':
                 return publishUpdates(action.result);
             case 'error':
@@ -163,20 +146,14 @@ export async function createWxDevHost({ server, options, applicationEntryIds })
                     logWxError(server.config.logger, 'wx dev build failed', action.result);
                     return;
                 }
-                return reconcileCompleteOutput(action.result.output);
+                return publishCompleteStyles();
             case 'listening':
                 return rotateBuildSession();
         }
     }
-    /**
-     * Reconciles graph-complete styles before rotating the App-visible build identity.
-     *
-     * DevEngine has already written its compiler asset when onOutput fires, but bundled development may have omitted CSS Modules
-     * from that asset. Awaiting reconciliation inside the serialized reducer guarantees the subsequent app.wxss rotation—the
-     * event that refreshes DevTools—can only expose a generation whose global WXSS already represents the complete App/Page graph.
-     */
-    async function reconcileCompleteOutput(output) {
-        await styleCapture.reconcileComplete(output);
+    /** Publishes graph-complete styles before rotating the App-visible build identity. */
+    async function publishCompleteStyles() {
+        await styles.finalizeUpdate([], writeGlobalStyle);
         await rotateBuildSession();
     }
     /** Applies one runtime receipt to the active physical patch history. */
@@ -252,16 +229,15 @@ export async function createWxDevHost({ server, options, applicationEntryIds })
         if (patches.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 styleCapture.publishChanged(patches.flatMap((patch) => patch.changedIds));
+        // `onHmrUpdates` runs after every affected transform has updated captured CSS and the live import graph. The style
+        // boundary finalizes every factory before atomically publishing their matching WXSS.
+        const finalizedPatches = await styles.finalizeUpdate(patches, writeGlobalStyle);
         // 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(patches);
-        await commitPublishedBatch(patches);
+        await publisher.produce(finalizedPatches);
+        await commitPublishedBatch(finalizedPatches);
     }
     /**
      * Advances Rolldown's published frontier in the same sequence order materialized in the cumulative physical file.

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

@@ -1,5 +1,6 @@
 import { type PluginOption } from 'vite';
 import type { VptOptions } from '../../../../options.ts';
+import type { WxStylePlugin } from '../styles/plugins.ts';
 /** Selects the sole Vite environment that owns the physical Mini Program development project. */
 export declare function isWxClientEnvironment(environment: Readonly<{
     name: string;
@@ -8,10 +9,10 @@ export declare function isWxClientEnvironment(environment: Readonly<{
  * 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.
+ * The shared style pipeline already owns the resolver's ordered App/Page cascade policy, so the host does not reconstruct it
+ * from unrelated Rolldown shell and transport entries.
  */
-export declare function createWxDevelopmentPlugin(options: VptOptions, applicationEntryIds: readonly string[]): PluginOption[];
+export declare function createWxDevelopmentPlugin(options: VptOptions, styles: WxStylePlugin): PluginOption[];
 /**
  * Transfers development ownership of `app.wxss` from complete output to the dev host.
  *

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

@@ -14,10 +14,10 @@ export function isWxClientEnvironment(environment) {
  * 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.
+ * The shared style pipeline already owns the resolver's ordered App/Page cascade policy, so the host does not reconstruct it
+ * from unrelated Rolldown shell and transport entries.
  */
-export function createWxDevelopmentPlugin(options, applicationEntryIds) {
+export function createWxDevelopmentPlugin(options, styles) {
     /*
      * Vite creates this plugin descriptor before a server or DevEngine exists, then invokes configureServer and closeBundle on
      * different lifecycle stacks. This mutable handle transfers the one client-owned host between those hooks: configureServer
@@ -65,7 +65,7 @@ export function createWxDevelopmentPlugin(options, applicationEntryIds) {
                     host = await createWxDevHost({
                         server: server,
                         options: options,
-                        applicationEntryIds: applicationEntryIds
+                        styles: styles
                     });
                 }
             },

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

@@ -1,4 +1,4 @@
-import type { InputOptions, OutputOptions, Plugin } from 'rolldown';
+import type { InputOptions, OutputOptions } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
 import type { VptOptions } from '../../../../options.ts';
@@ -19,11 +19,10 @@ export type BundledDev = {
  * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
  * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.
  */
-export declare function installWxDevOptions({ bundledDev, server, options, hostPlugins }: {
+export declare function installWxDevOptions({ bundledDev, server, options }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
     options: VptOptions;
-    hostPlugins: Plugin[];
 }): 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

@@ -8,7 +8,7 @@ import { appShellFileName } from '../module/module.js';
  * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
  * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.
  */
-export function installWxDevOptions({ bundledDev, server, options, hostPlugins }) {
+export function installWxDevOptions({ bundledDev, server, options }) {
     /*
      * Vite owns this mutable adapter method and calls it later when constructing DevEngine. Replacing that one seam preserves
      * Vite's resolved graph while applying WX physical-output conventions to every options generation. Capturing and mutating one
@@ -78,10 +78,10 @@ export function installWxDevOptions({ bundledDev, server, options, hostPlugins }
         };
         /*
          * The plugin list is mutable configuration consumed once by this engine generation. Replace the top-level reference with
-         * an ordered composite rather than pushing into Vite's potentially shared nested array: existing transforms run first,
-         * host capture observes their final values, and the reporter observes final output without mutating either input list.
+         * an ordered composite rather than pushing into Vite's potentially shared nested array; the reporter observes final output
+         * without mutating Vite's retained input list.
          */
-        rolldownOptions.plugins = [rolldownOptions.plugins, hostPlugins, createViteReporter(server)];
+        rolldownOptions.plugins = [rolldownOptions.plugins, createViteReporter(server)];
         disableViteOxcSourcemap(rolldownOptions.plugins);
         return rolldownOptions;
     };

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

@@ -10,19 +10,15 @@ 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';
+import { createWxStylePlugin } from './styles/plugins.js';
 /** Creates the complete plugin set for the wx target. */
 export function createWxTargetPlugins(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.
     const placement = createWxPlacementPlugin();
-    return [
-        placement,
-        createWxStylePlugins(),
-        createWxPlugin(options, resolver, placement),
-        createWxDevelopmentPlugin(options, resolver.applicationEntryIds)
-    ];
+    const styles = createWxStylePlugin(resolver.applicationEntryIds);
+    return [placement, styles, createWxPlugin(options, resolver, placement), createWxDevelopmentPlugin(options, styles)];
 }
 /** Configures the complete wx target build pipeline. */
 function createWxPlugin(options, resolver, placement) {
@@ -106,10 +102,8 @@ function createWxPlugin(options, resolver, placement) {
         },
         generateBundle: {
             /*
-             * 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.
+             * Registration after the style pipeline makes the compiler stylesheet final before native Page and component
+             * companions are emitted. The style finalizer therefore cannot mistake native WXSS for application CSS.
              */
             order: 'post',
             async handler(_, bundle) {

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

@@ -1,3 +1,141 @@
-import type { PluginOption } from 'vite';
-/** Creates the complete WX Tailwind and global-style pipeline. */
-export declare function createWxStylePlugins(): PluginOption[];
+import { type Plugin } from 'vite';
+import { createContext } from 'weapp-tailwindcss/core';
+/** JavaScript code plus the physical filename required by the Weapp JavaScript transformer. */
+type JavaScriptArtifact = Readonly<{
+    code: string;
+    filename: string;
+}>;
+/** Vite plugin with the development-host operation that finalizes one coherent WX style/JavaScript transaction. */
+export type WxStylePlugin = Plugin & Readonly<{
+    /** Converts patch factories and publishes their matching global WXSS through the host's atomic writer. */
+    finalizeUpdate: <Artifact extends JavaScriptArtifact>(artifacts: readonly Artifact[], writeWxss: (wxss: string) => Promise<void>) => Promise<readonly Artifact[]>;
+}>;
+/**
+ * Creates the single owner of global WX style compilation, graph projection, JavaScript class rewriting, and publication.
+ *
+ * ## Architectural invariant
+ *
+ * A WX transaction must expose JavaScript and WXSS produced from one class-identity snapshot. Tailwind utility names can be
+ * rewritten for WeChat—for example, `py-5.5` becomes `py-5_d5`—so publishing either side independently can leave running code
+ * referring to selectors that do not yet exist. This plugin therefore treats reachable CSS, Tailwind candidates, converted
+ * WXSS, and converted JavaScript as one output. Complete builds and HMR updates both call `finalizeOutput()`; they differ only
+ * in how the returned bytes are materialized.
+ *
+ * ## Ownership boundaries
+ *
+ * The pipeline deliberately gives each subsystem one responsibility:
+ *
+ * 1. Rolldown owns module reachability and invalidation. VPT reads `getModuleInfo()` and registers watch files, but does not
+ *    maintain a second import graph or decide independently which root should rerun.
+ * 2. The persistent Tailwind generator owns candidate discovery and incremental candidate removal. VPT invokes it only from
+ *    the owning CSS root's Rolldown transform and never rescans the project during output publication.
+ * 3. Vite owns preprocessors, PostCSS, CSS Modules, and final module CSS semantics. VPT observes the input to the resolved
+ *    `vite:css-post` hook only after the original hook succeeds; it never rereads source files or repeats CSS preprocessing.
+ * 4. The Weapp transformation context owns WX selector conversion and JavaScript class-string conversion. One retained context
+ *    and one projected candidate set drive both operations.
+ * 5. VPT owns physical global WXSS and patch publication. Vite's browser CSS asset is only an intermediate carrier and is
+ *    removed before VPT emits `assets/global.wxss`.
+ *
+ * Native Page and component WXSS are outside this global pipeline. The WX output plugin is registered after this style plugin
+ * and emits those opaque companions later. The WX configuration also enforces `cssCodeSplit: false`, so Vite contributes at
+ * most one browser compiler stylesheet for this plugin to replace.
+ *
+ * ## Compilation phases
+ *
+ * ### 1. Tailwind pre-transform
+ *
+ * The pre-transform checks physical application CSS for Tailwind imports or directives. Ordinary styles pass through. A
+ * Tailwind root compiles to browser CSS before Vite's normal CSS pipeline runs. Successful generation records the generator,
+ * scanner, current class set, compiler dependencies, and exact root source under the normalized physical module ID.
+ *
+ * Candidate files and compiler dependencies intentionally have different invalidation behavior:
+ *
+ * - Candidate-file changes rerun the root with the existing generator and scanner. `incrementalCache: true` updates additions
+ *   and removals without discarding the generator's authoritative cache.
+ * - Compiler-dependency changes mark the root invalid. Its next Rolldown transform resolves a new Tailwind source and creates a
+ *   new generator and scanner. Replacement is delayed until that transform has current source and plugin context.
+ * - If a stylesheet stops being a Tailwind root, its generator is disposed and its Tailwind state is removed. The later Vite
+ *   CSS hook replaces the retained CSS after normal processing succeeds.
+ *
+ * ### 2. Vite-final CSS capture
+ *
+ * `configResolved` wraps the concrete `vite:css-post` transform while preserving its hook metadata, filter, ordering, and
+ * plugin context. The original Vite hook executes first, which preserves CSS Module exports and Vite's internal extraction
+ * state. Only a successful transform updates `styleByModuleId`; syntax errors therefore leave the last successful CSS available
+ * to the currently running application. Query modes such as `?raw`, `?url`, and `?inline` are excluded because they represent
+ * values rather than graph-owned stylesheets.
+ *
+ * ### 3. Live-graph projection
+ *
+ * Output finalization starts from resolved App/Page entry IDs and traverses Rolldown's current static and dynamic import edges
+ * in dependency-first post-order. Transaction-local visited sets terminate cycles and deduplicate shared modules and physical
+ * stylesheets. A retained stylesheet contributes only when its module is still reachable, so removing an import prunes its CSS
+ * and Tailwind candidates without a separate prune protocol or persistent topology cache. Candidate sets are unioned only from
+ * the Tailwind roots whose captured CSS survives that exact traversal, preserving the CSS/class identity invariant.
+ *
+ * ### 4. Shared WX finalization
+ *
+ * `finalizeOutput()` first converts the concatenated reachable CSS to WXSS, then transforms every supplied JavaScript artifact
+ * with the same projected class set. It returns data and performs no bundle mutation or filesystem publication. If either
+ * transformation fails, the promise rejects before callers expose partial output. JavaScript conversion is skipped when the
+ * projection contains no Tailwind candidates, preserving ordinary bundle bytes.
+ *
+ * ### 5a. Complete-build commit
+ *
+ * The post-order `generateBundle` hook gathers all JavaScript chunks, finalizes them as one operation, and only then mutates the
+ * bundle. It assigns converted code, clears invalid source maps, removes Vite's intermediate browser stylesheet, and always
+ * emits `assets/global.wxss`. Emitting an empty global file is required because `app.wxss` imports it even when the application
+ * currently has no styles. Native output hooks run afterward and emit Page/component companion files independently.
+ *
+ * ### 5b. Development commit
+ *
+ * The development host calls `finalizeUpdate()` after Rolldown produces patch factories or a complete-output notification.
+ * Finalization uses the `PluginContext` captured by `buildStart`, so it observes the same current graph as the compiler. After
+ * all conversion succeeds, the host's atomic writer publishes changed WXSS before `finalizeUpdate()` returns converted patch
+ * factories. The patch publisher therefore cannot expose newer JavaScript class identities before matching selectors exist.
+ * `publishedWxss` advances only after a successful write and suppresses byte-identical writes that would otherwise trigger
+ * unnecessary WeChat DevTools reload events.
+ *
+ * ## Retained state and lifecycle
+ *
+ * The factory retains four explicit mutable state owners plus one library-owned transformation context:
+ *
+ * - `entryIds`: graph-exact App/Page entry identities resolved at the start of each build;
+ * - `graphContext`: the active Rolldown graph reader needed by host calls made outside plugin hooks;
+ * - `styleByModuleId`: the latest successful Vite CSS plus optional Tailwind state at one normalized module identity;
+ * - `publishedWxss`: the last durably published development stylesheet used for unchanged-write suppression;
+ * - `weappContext`: Weapp's internal conversion state, retained so selector and JavaScript rewriting share one context.
+ *
+ * The state owners remain scoped to one plugin instance; `entryIds` is atomically replaced after each complete resolution.
+ * Build-command bundles dispose Tailwind generators after bundle generation. A development watcher otherwise keeps them alive
+ * across updates and disposes them when it closes. Captured CSS survives compiler cleanup because output notifications can
+ * arrive after that cleanup, and is cleared only when the watcher terminates.
+ *
+ * ## Cost model
+ *
+ * Projection is `O(V + E + B + C)` for reachable modules, import edges, concatenated CSS bytes, and candidate insertions.
+ * JavaScript conversion is linear in the total supplied chunk or patch-factory bytes, subject to the Weapp parser's own cost.
+ * Retained memory is `O(B + C + D + F)` for latest CSS, candidate sets, compiler dependencies, and scanner file identities; no
+ * second application graph is retained. Tailwind's generator and Oxide scanner caches are intentionally persistent because
+ * recreating them on every candidate edit would repeat source normalization and scanning work.
+ */
+export declare function createWxStylePlugin(applicationEntryIds: readonly string[]): WxStylePlugin;
+/**
+ * Produces WXSS and JavaScript from one live-graph projection.
+ *
+ * The function receives every stateful dependency explicitly so tests and both output modes execute the same algorithm. It
+ * completes WXSS conversion before JavaScript conversion and returns bytes without publishing or mutating caller artifacts.
+ */
+export declare function finalizeOutput(entryIds: readonly string[], styleByModuleId: ReadonlyMap<string, Readonly<{
+    css: string | undefined;
+    tailwind: Readonly<{
+        classSet: ReadonlySet<string>;
+    }> | undefined;
+}>>, getModuleInfo: (moduleId: string) => Readonly<{
+    importedIds: readonly string[];
+    dynamicallyImportedIds: readonly string[];
+}> | null | undefined, weappContext: Pick<ReturnType<typeof createContext>, 'transformJs' | 'transformWxss'>, javaScript: readonly JavaScriptArtifact[]): Promise<{
+    javaScript: string[];
+    wxss: string;
+}>;
+export {};