vite-plugin-taro 0.5.12 → 0.5.14

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

@@ -1,25 +1,43 @@
-import { transformWithOxc } from 'vite';
+import { normalizePath, transformWithOxc } from 'vite';
 import { esTarget } from '../../../utils/constant.js';
 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';
+/** Selects the sole Vite environment that owns the physical Mini Program development project. */
+export function isWxClientEnvironment(environment) {
+    return environment.name === 'client';
+}
 /**
  * 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) {
+    /*
+     * 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
+     * assigns it after asynchronous construction, and closeBundle reads it to drain the same engine. Environment scoping ensures
+     * only the client hook pair participates. Capturing a construction Promise would start too early, while recreating the host
+     * in closeBundle would lose every live action, patch, style, and client frontier owned by the running instance.
+     */
     let host = null;
     // Portable hook filters stay broad; these exact identities exclude similarly named user modules.
-    const normalizedAppCapsulePath = normalizeModuleId(appCapsulePath);
-    const normalizedPageCapsulePath = normalizeModuleId(pageCapsulePath);
-    const normalizedTaroRuntimePath = normalizeModuleId(taroRuntimePath);
+    const normalizedAppCapsulePath = normalizePath(appCapsulePath);
+    const normalizedPageCapsulePath = normalizePath(pageCapsulePath);
+    const normalizedTaroRuntimePath = normalizePath(taroRuntimePath);
     return [
         {
             name: 'vpt:wx-dev',
             apply: 'serve',
+            // The physical WX DevEngine is a client build. Native environment scoping gives its shared host exactly one
+            // generate/close lifecycle instead of admitting hooks from Vite's unrelated SSR environment.
+            applyToEnvironment: isWxClientEnvironment,
             config() {
                 return {
                     build: {
@@ -47,7 +65,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 +148,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 {
@@ -153,9 +202,12 @@ function getPageRoute(id) {
         throw new Error(`WX Page capsule is missing its route: ${id}`);
     return route;
 }
-// The assembled runtime chunk is byte-identical on every build (the base runtime and the
-// bundled implement are immutable for the server's lifetime), so the lowering runs once
-// and every build reuses it.
+/*
+ * memoize owns a mutable one-entry-by-input cache. The assembled runtime source is byte-identical across complete generations
+ * because both the Rolldown base and injected implementation are immutable for the server lifetime. Reusing its lowered result
+ * avoids repeating the only large Oxc transform on every rebuild; keying by source still invalidates correctly if a future Vite
+ * generation changes the runtime, unlike a module-global cached string detached from its actual input.
+ */
 const fixRolldownRuntime = memoize((code) => {
     return transformWithOxc(code, rolldownRuntimeId, {
         lang: 'js',

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

@@ -193,7 +193,11 @@ export function removeRefreshPreambleGuard({ code, id }) {
         createVisitor: createRefreshPreambleGuardVisitor
     });
 }
-// The refresh runtime module and the react-family modules are immutable for the server's
-// lifetime, so their Oxc parses run once per module and every build reuses the output.
+/*
+ * Each memoized transform owns a mutable cache keyed only by source bytes. The matching runtime/react-family modules are
+ * immutable between complete generations, so reparsing them would repeat O(source bytes) Oxc work without observing new state.
+ * Source keys still create a fresh result after a dependency upgrade or real module edit, unlike a once-only cache keyed by ID;
+ * keeping separate caches prevents identical text in different transform domains from sharing the wrong adaptation.
+ */
 const fixRefreshRuntime = memoize(transformRefreshRuntime, { getCacheKey: ({ code }) => code });
 const fixReactDevtoolsHook = memoize(transformReactDevtoolsHook, { getCacheKey: ({ code }) => code });

package/dist/node/plugins/wx/dev/runtime-reports.d.ts

@@ -0,0 +1,27 @@
+import { type SchedulerLike, Subject } from 'rxjs';
+type AppliedReport = Readonly<{
+    kind: 'applied';
+    buildId: string;
+    seq: number;
+}>;
+/** The runtime hit an unrecoverable state and needs a complete build. */
+type RebuildReport = Readonly<{
+    kind: 'rebuild';
+    buildId: string;
+    reason: string;
+}>;
+export type RuntimeReport = AppliedReport | RebuildReport;
+/**
+ * Conflates runtime receipts without weakening their build identity or recovery semantics.
+ *
+ * Reports are metadata frontiers rather than executable deltas: for one build, the highest applied sequence subsumes lower and
+ * duplicate acknowledgements. A rebuild does not subsume reports from a different build, because delayed Pages may still POST
+ * after session rotation, but it dominates every acknowledgement for its own build. The host validates each retained build ID
+ * against the physical publisher only when its serialized task executes, preserving rotation order.
+ *
+ * Completing the Subject flushes the active window synchronously so shutdown can include its host task before closing Rolldown.
+ * Reduction is O(reports) time and O(distinct builds) retained space per quiet window.
+ */
+export declare function createRuntimeReportsStream(settleMilliseconds: number, scheduler: SchedulerLike, publish: (reports: readonly RuntimeReport[]) => void): Subject<RuntimeReport>;
+export declare function reduceRuntimeReportWindow(window: readonly RuntimeReport[]): readonly RuntimeReport[];
+export {};

package/dist/node/plugins/wx/dev/runtime-reports.js

@@ -0,0 +1,45 @@
+import { buffer, debounceTime, filter, Subject } from 'rxjs';
+/**
+ * Conflates runtime receipts without weakening their build identity or recovery semantics.
+ *
+ * Reports are metadata frontiers rather than executable deltas: for one build, the highest applied sequence subsumes lower and
+ * duplicate acknowledgements. A rebuild does not subsume reports from a different build, because delayed Pages may still POST
+ * after session rotation, but it dominates every acknowledgement for its own build. The host validates each retained build ID
+ * against the physical publisher only when its serialized task executes, preserving rotation order.
+ *
+ * Completing the Subject flushes the active window synchronously so shutdown can include its host task before closing Rolldown.
+ * Reduction is O(reports) time and O(distinct builds) retained space per quiet window.
+ */
+export function createRuntimeReportsStream(settleMilliseconds, scheduler, publish) {
+    /*
+     * This Subject is the sole mutable HTTP admission edge. Requests append reports synchronously and finish their responses;
+     * buffer then owns the short-lived window while debounceTime supplies only its quiet-edge signal. Reports are metadata rather
+     * than executable deltas, so the window may be reduced before entering hostActions. Directly mutating PatchPublisher from the
+     * request stack would race patch writes and build rotation; retaining every raw receipt beyond the window would grow with Page
+     * count and duplicate acknowledgements. Completion flushes the final window during phased shutdown.
+     */
+    const reports = new Subject();
+    reports
+        .pipe(buffer(reports.pipe(debounceTime(settleMilliseconds, scheduler))), filter((window) => window.length > 0))
+        .subscribe((window) => publish(reduceRuntimeReportWindow(window)));
+    return reports;
+}
+export function reduceRuntimeReportWindow(window) {
+    /*
+     * This transaction-local mutable Map is bounded by distinct build IDs in one quiet window. Insertion order preserves causal
+     * build order, while replacing a value conflates only that build's monotonic acknowledgement frontier; rebuild becomes its
+     * terminal value. A single global latest report would let delayed Pages erase another build, and retaining the raw window
+     * would make downstream work proportional to duplicate report volume. The Map is discarded immediately after reduction.
+     */
+    const reportsByBuild = new Map();
+    for (const report of window) {
+        const previous = reportsByBuild.get(report.buildId);
+        if (previous?.kind === 'rebuild') {
+            continue;
+        }
+        if (report.kind === 'rebuild' || previous === undefined || report.seq > previous.seq) {
+            reportsByBuild.set(report.buildId, report);
+        }
+    }
+    return [...reportsByBuild.values()];
+}

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

@@ -1,8 +1,8 @@
-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';
-export type BundledDevRolldownOptions = InputOptions & {
+type BundledDevRolldownOptions = InputOptions & {
     experimental?: {
         [key: string]: unknown;
         devMode?: boolean | Record<string, unknown>;
@@ -15,11 +15,16 @@ export type BundledDev = {
     listen(): Promise<void>;
     triggerBundleRegenerationIfStale(): Promise<boolean>;
 };
-/** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
-export declare function installWxDevOptions({ bundledDev, server, options }: {
+/**
+ * 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 }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
     options: VitePluginTaroOptions;
-}): Promise<void>;
+    hostPlugins: Plugin[];
+}): void;
 /** Returns the configured output after rejecting states unsupported by the physical WX engine. */
 export declare function requireSingleOutput(rolldownOptions: BundledDevRolldownOptions): OutputOptions;
+export {};

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

@@ -4,20 +4,17 @@ import { viteReporterPlugin } from 'rolldown/experimental';
 import { once } from '../../../utils/once.js';
 import { resolvePackageFile } from '../../../utils/packages.js';
 import { appShellFileName } from '../module.js';
-import { createWxDevMode } from './create-wx-dev-mode.js';
-/** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
-export function installWxDevOptions({ bundledDev, server, options }) {
-    // The buildEnd hook and its one-shot result belong to the same abstraction. Consumers can await startup without receiving
-    // a resolver capable of settling it externally.
-    const initialBuild = Promise.withResolvers();
-    const settleInitialBuild = once((error) => {
-        if (error) {
-            initialBuild.reject(error);
-        }
-        else {
-            initialBuild.resolve();
-        }
-    });
+/**
+ * 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 }) {
+    /*
+     * 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
+     * options object here would be stale on later complete builds; creating a second engine would duplicate watchers and graphs.
+     * The bound original remains immutable and is invoked exactly once per delegated options request.
+     */
     const original = bundledDev.getRolldownOptions.bind(bundledDev);
     bundledDev.getRolldownOptions = async () => {
         const rolldownOptions = await original();
@@ -28,8 +25,15 @@ export function installWxDevOptions({ bundledDev, server, options }) {
         }
         const configured = configuredOutput ?? {};
         // Every page entry must depend on hmr/patches.js: DevTools classifies a changed Page dependency as Page JavaScript
-        // hot reload and re-executes live Pages, which is the only physical patch trigger that preserves the App heap.
+        // hot reload and re-executes live Pages, which is the only physical patch trigger that preserves the App heap. Although
+        // Set provides O(1) membership, exposing it as ReadonlySet prevents mutation after this options generation is resolved.
         const pageFiles = new Set(options.pages.map((page) => `${page.path}.js`));
+        /*
+         * Rolldown passes this mutable output object onward by identity, and nested Vite plugins may already retain it. Mutating
+         * that single object preserves their references while atomically replacing browser-oriented naming and format fields with
+         * stable physical WX conventions. Cloning only our fields would leave retained references on stale hashed filenames;
+         * mutating configuredOutput itself would leak development normalization back into the user's resolved Vite config.
+         */
         Object.assign(output, configured, {
             assetFileNames: createStableFileNames(configured.assetFileNames, 'assets/[name][extname]'),
             banner: createEntryBanner(pageFiles),
@@ -39,19 +43,27 @@ export function installWxDevOptions({ bundledDev, server, options }) {
             minify: true,
             sourcemap: false
         });
+        /*
+         * experimental belongs to this transaction-local Rolldown options generation. Materialize it only when absent, then
+         * replace devMode with a new object so user fields survive without mutating a possibly shared configured sub-object.
+         */
         rolldownOptions.experimental ??= {};
-        rolldownOptions.experimental.devMode = createWxDevMode(rolldownOptions.experimental.devMode, await bundleRuntimeSource());
-        const reportInitialBuildPlugin = {
-            name: 'vpt:wx-report-initial-build',
-            buildEnd: settleInitialBuild
+        const existingDevMode = rolldownOptions.experimental.devMode;
+        rolldownOptions.experimental.devMode = {
+            ...(typeof existingDevMode === 'object' ? existingDevMode : {}),
+            implement: await bundleRuntimeSource(),
+            lazy: false,
+            skipCommonRuntimeInjection: false
         };
-        // 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)];
+        /*
+         * 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.
+         */
+        rolldownOptions.plugins = [rolldownOptions.plugins, hostPlugins, createViteReporter(server)];
         disableViteOxcSourcemap(rolldownOptions.plugins);
         return rolldownOptions;
     };
-    return initialBuild.promise;
 }
 /** Returns the configured output after rejecting states unsupported by the physical WX engine. */
 export function requireSingleOutput(rolldownOptions) {
@@ -65,6 +77,7 @@ function ensureSingleOutput(rolldownOptions) {
     if (Array.isArray(rolldownOptions.output)) {
         throw new Error('wx development requires one configured Rolldown output.');
     }
+    // Rolldown needs the created object attached to input options by identity; returning a detached fallback would be ignored.
     rolldownOptions.output ??= {};
     return rolldownOptions.output;
 }
@@ -107,6 +120,11 @@ function disableViteOxcSourcemap(pluginOption) {
         return;
     const plugin = pluginOption;
     if (plugin.name === 'builtin:vite-transform' && plugin._options?.transformOptions) {
+        /*
+         * Vite's private builtin retains this mutable transform options object and does not expose a public replacement hook.
+         * Updating its one sourcemap flag prevents Oxc from allocating maps that final WX output always discards; cloning the
+         * descriptor would not update the builtin closure that reads the original object during transforms.
+         */
         plugin._options.transformOptions.sourcemap = false;
     }
 }
@@ -123,7 +141,12 @@ function createViteReporter(server) {
         warnLargeChunks: false
     });
 }
-// The runtime source is immutable for the host's lifetime, so the nested bundle is shared by every complete build.
+/*
+ * once owns a mutable cached Promise, justified because getRolldownOptions may run for multiple complete generations while the
+ * runtime input and build options remain immutable for the process lifetime. Sharing the in-flight/result Promise prevents
+ * concurrent options requests from launching duplicate nested builds; caching source instead of a Rolldown output object avoids
+ * leaking mutable bundle metadata between engines.
+ */
 const bundleRuntimeSource = once(async function bundleRuntimeSource() {
     // write: false keeps this nested helper build from creating a second dist directory in the application project.
     const result = await build({

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

@@ -1,4 +1,4 @@
-import type { Rolldown } from 'vite';
+import { type Rolldown } from 'vite';
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
 /** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */

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

@@ -1,10 +1,11 @@
 import path from 'node:path';
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../utils/modules.js';
 import { packageRequire, resolvePackageFile } from '../../utils/packages.js';
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export const rolldownRuntimeId = '\0rolldown/runtime.js';
 /** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */
-export const reactReconcilerRoot = normalizeModuleId(path.dirname(packageRequire.resolve('react-reconciler/package.json')));
+export const reactReconcilerRoot = normalizePath(path.dirname(packageRequire.resolve('react-reconciler/package.json')));
 /** Identifies the amphibious bootstrap that initializes SystemJS and serves every native shell. */
 export const bootstrapPath = resolvePackageFile('dist/runtime/wx/amphibious/bootstrap.js');
 /** Identifies the native transport source materialized before Rolldown finalizes content hashes. */

package/dist/node/plugins/wx/native/compile-native-component-interface.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../../utils/modules.js';
 import { collectNativeComponentAssets, nativeComponentMetaKey } from './native-component-assets.js';
 import { transformNativeComponentInterfaces } from './native-component-interface.js';
@@ -10,7 +11,7 @@ export async function compileNativeComponentInterface({ code, id, sourcemap, add
     nativeComponents.forEach((source) => {
         addWatchFile(source.folder);
         source.assets.forEach((asset) => {
-            addWatchFile(normalizeModuleId(path.join(source.folder, asset.relativePath)));
+            addWatchFile(normalizePath(path.join(source.folder, asset.relativePath)));
         });
     });
     const assetBytes = nativeComponents.reduce((sourceTotal, source) => {

package/dist/node/plugins/wx/native/create-native-component-output.js

@@ -26,6 +26,8 @@ export async function createNativeComponentOutput({ bundle, getModuleInfo }) {
                     fields: source.fields
                 });
                 for (const asset of source.assets) {
+                    // Native folders are intentionally opaque to Rolldown, so no bundle asset contains these bytes to reuse.
+                    // Read each planned source once here to transfer it into the compiler-owned output bundle.
                     files.push({
                         type: 'asset',
                         fileName: path.posix.join(outputFolder, asset.relativePath),

package/dist/node/plugins/wx/native/native-component-assets.d.ts

@@ -1,4 +1,4 @@
-import type { Rolldown } from 'vite';
+import { type Rolldown } from 'vite';
 import type { NativeComponentDefinition } from './native-component-interface.ts';
 type NativeComponentAsset = {
     relativePath: string;

package/dist/node/plugins/wx/native/native-component-assets.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { normalizeModuleId } from '../../../utils/modules.js';
+import { normalizePath } from 'vite';
 export const nativeComponentMetaKey = 'vpt:native-components';
 /** Reads the native contribution to a transformed module's package weight. */
 export function getNativeComponentAssetBytes(meta) {
@@ -16,7 +16,7 @@ export async function collectNativeComponentAssets(definition, interfacePath) {
     await requireNativeComponentEntry(definition);
     // This mutable accumulator is local to one traversal and avoids repeatedly copying growing asset arrays.
     const assets = [];
-    await collectDirectory(definition.folder, [], assets, normalizeModuleId(interfacePath));
+    await collectDirectory(definition.folder, [], assets, normalizePath(interfacePath));
     return { ...definition, assets };
 }
 /** Rejects a missing or non-directory source before Rolldown starts its recursive traversal. */
@@ -65,7 +65,7 @@ async function collectDirectory(folder, segments, assets, interfacePath) {
             continue;
         }
         const sourcePath = path.join(folder, ...entrySegments);
-        if (normalizeModuleId(sourcePath) === interfacePath) {
+        if (normalizePath(sourcePath) === interfacePath) {
             continue;
         }
         assets.push({

package/dist/node/plugins/wx/native/native-component-interface.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { RolldownMagicString } from 'rolldown';
 import { parseAst } from 'rolldown/parseAst';
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../../utils/modules.js';
 import { clientTaroNativeId } from '../../client/constant.js';
 /** Replaces native component interface calls with source-folder names and returns their static metadata. */
@@ -96,7 +97,7 @@ function parseDefinition(call, moduleId, declaredInterfaces, buildError) {
     if (!entryReference) {
         throw buildError('Native component entry must use () => import(...) with a static relative .js path');
     }
-    const entryPath = normalizeModuleId(path.resolve(path.dirname(moduleId), entryReference));
+    const entryPath = normalizePath(path.resolve(path.dirname(moduleId), entryReference));
     return {
         folder: path.posix.dirname(entryPath),
         entry: path.posix.basename(entryPath, '.js'),

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;
 };

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

@@ -1,3 +1,4 @@
+import { normalizePath } from 'vite';
 import { normalizeModuleId, resolveAppComponentPath, resolvePageComponentPath } from '../../../utils/modules.js';
 import { createAppConfig } from '../../../utils/project-config.js';
 import { appComponentId } from '../../client/constant.js';
@@ -6,8 +7,10 @@ import { specializeBootstrap } from './specialize-bootstrap.js';
 import { specializePageCapsule } from './specialize-page-capsule.js';
 /** Creates the resolver and source specializer for the wx module graph. */
 export function createResolver(options) {
-    const normalizedBootstrapPath = normalizeModuleId(bootstrapPath);
-    const normalizedPageCapsulePath = normalizeModuleId(pageCapsulePath);
+    const normalizedBootstrapPath = normalizePath(bootstrapPath);
+    const normalizedPageCapsulePath = normalizePath(pageCapsulePath);
+    // Construct output input and application traversal roots together once so style order cannot drift from route order.
+    const entryGraph = createEntryGraph(options.pages);
     // Provide constant-time route validation and access to each configured Page JSON object.
     const pageByPath = new Map(options.pages.map((page) => [page.path, page]));
     const privateIdResolvers = new Map([
@@ -32,7 +35,7 @@ export function createResolver(options) {
         ]
     ]);
     return {
-        input: createInput(options.pages),
+        ...entryGraph,
         resolveId(id, importer, projectRoot) {
             // Unknown IDs fall through so Vite and other plugins retain normal resolution.
             return privateIdResolvers.get(id)?.(importer, projectRoot);
@@ -53,22 +56,34 @@ export function createResolver(options) {
         }
     };
 }
-/** Declares native shells, infrastructure, and capsules as independent output entries. */
-function createInput(pages) {
-    return Object.fromEntries([
-        ['bootstrap', bootstrapPath],
-        ['transport', transportPath],
-        [appShellFileName, appShellPath],
-        ['app-capsule', appCapsulePath],
-        [componentShellFileName, componentShellPath],
-        ['component-capsule', componentCapsulePath],
-        ...pages.flatMap((page) => {
-            return [
-                [`${page.path}.js`, createRouteModuleId({ moduleId: pageShellPath, pagePath: page.path })],
-                [`${page.path}-capsule`, createRouteModuleId({ moduleId: pageCapsulePath, pagePath: page.path })]
-            ];
-        })
-    ]);
+/** Declares output entries and the ordered application subset that can own user styles. */
+function createEntryGraph(pages) {
+    const pageEntries = pages.map((page) => {
+        return {
+            capsuleId: createRouteModuleId({ moduleId: pageCapsulePath, pagePath: page.path }),
+            capsuleName: `${page.path}-capsule`,
+            shellId: createRouteModuleId({ moduleId: pageShellPath, pagePath: page.path }),
+            shellName: `${page.path}.js`
+        };
+    });
+    return {
+        // The App owns the first global cascade layer; configured Pages follow in their declared route order.
+        applicationEntryIds: [appCapsulePath, ...pageEntries.map((entry) => entry.capsuleId)],
+        input: Object.fromEntries([
+            ['bootstrap', bootstrapPath],
+            ['transport', transportPath],
+            [appShellFileName, appShellPath],
+            ['app-capsule', appCapsulePath],
+            [componentShellFileName, componentShellPath],
+            ['component-capsule', componentCapsulePath],
+            ...pageEntries.flatMap((entry) => {
+                return [
+                    [entry.shellName, entry.shellId],
+                    [entry.capsuleName, entry.capsuleId]
+                ];
+            })
+        ])
+    };
 }
 /** Creates one route-qualified module ID. */
 function createRouteModuleId({ moduleId, pagePath }) {

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

@@ -0,0 +1,3 @@
+import type { PluginOption } from 'vite';
+/** Creates the complete WX Tailwind and global-style pipeline. */
+export declare function createWxStylePlugins(): PluginOption[];