vite-plugin-taro 0.5.14 → 0.6.0

package/dist/node/plugins/client/client-taro.d.ts

@@ -1,6 +1,6 @@
 import { type Plugin } from 'vite';
-import type { VitePluginTaroTarget } from '../../../options.ts';
+import type { VptTarget } from '../../../options.ts';
 /** Public facade used by transformed application API imports. */
 export declare const clientTaroApiId = "virtual:taro/api";
 /** Creates the shared Taro facade backed by the selected target's API implementation. */
-export declare function createClientTaroPlugin(target: VitePluginTaroTarget): Plugin;
+export declare function createClientTaroPlugin(target: VptTarget): Plugin;

package/dist/node/plugins/conditional/conditional-directives.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from 'vite';
-import type { VitePluginTaroTarget } from '../../../options.ts';
+import type { VptTarget } from '../../../options.ts';
 /** Creates source-level target conditional handling shared by H5 and WX. */
-export declare function createConditionalDirectivePlugin(target: VitePluginTaroTarget): Plugin;
+export declare function createConditionalDirectivePlugin(target: VptTarget): Plugin;

package/dist/node/plugins/h5/plugins.d.ts

@@ -1,7 +1,7 @@
 import type { PluginOption } from 'vite';
-import type { VitePluginTaroOptions } from '../../../options.ts';
+import type { VptOptions } from '../../../options.ts';
 /** Creates the plugins that own the H5 target. */
-export declare function createH5TargetPlugins(options: VitePluginTaroOptions): PluginOption[];
+export declare function createH5TargetPlugins(options: VptOptions): PluginOption[];
 /**
  * Coarse source prefilter for the upstream Taro API transform.
  *

package/dist/node/plugins/h5/resolver/module-resolver.d.ts

@@ -1,6 +1,6 @@
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 /** Creates H5 application module resolution and specialization. */
-export declare function createModuleResolver(options: VitePluginTaroOptions): {
+export declare function createModuleResolver(options: VptOptions): {
     resolveId({ id, projectRoot }: {
         id: string;
         projectRoot: string;

package/dist/node/plugins/h5/transform-app.d.ts

@@ -1,10 +1,10 @@
-import type { VitePluginTaroOptions } from '../../../options.ts';
+import type { VptOptions } from '../../../options.ts';
 import { type AstTransformResult } from '../../utils/transform.ts';
 /** Specializes the physical H5 App for one configured project. */
 export declare function transformH5App({ code, id, options, projectRoot, sourcemap }: {
     code: string;
     id: string;
-    options: VitePluginTaroOptions;
+    options: VptOptions;
     projectRoot: string;
     sourcemap?: boolean;
 }): Promise<AstTransformResult>;

package/dist/node/plugins/h5/transform-app.js

@@ -2,8 +2,8 @@ import { types } from '@babel/core';
 import { createPageComponentImportPath } from '../../utils/modules.js';
 import { createAppConfig } from '../../utils/project-config.js';
 import { replaceWithAst } from '../../utils/transform.js';
-const appConfigPlaceholder = '__VITE_PLUGIN_TARO_H5_APP_CONFIG__';
-const routesPlaceholder = '__VITE_PLUGIN_TARO_H5_ROUTES__';
+const appConfigPlaceholder = '__VPT_H5_APP_CONFIG__';
+const routesPlaceholder = '__VPT_H5_ROUTES__';
 /** Specializes the physical H5 App for one configured project. */
 export async function transformH5App({ code, id, options, projectRoot, sourcemap = true }) {
     const transformed = await replaceWithAst(code, id, {

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

@@ -1,8 +1,11 @@
 import type { GetModuleInfo, Plugin } from 'rolldown';
+/** Final CSS extracted from Vite's transformed style module, before the shared WX compatibility pass. */
 type ProcessedStyle = Readonly<{
     css: string;
+    /** Marks roots whose generated utilities must be refreshed when JavaScript changes Tailwind candidates. */
     isTailwindRoot: boolean;
 }>;
+/** Minimal structural view of DevEngine output; style reconciliation does not own chunks or other asset metadata. */
 type CompleteOutputFile = Readonly<{
     type: 'asset';
     fileName: string;
@@ -20,10 +23,19 @@ export type StyleCaptureAction = Readonly<{
     style: ProcessedStyle;
 }>;
 /**
- * Owns capture hooks, the host's style projection, and its physical WXSS publication frontier.
+ * Captures final Vite CSS and composes the graph projection with its durable WXSS publisher.
  *
- * Rolldown remains authoritative for topology through its live graph reader. Plugin hooks emit typed actions so the host can
- * serialize captures with every other effect; only the matching capture methods mutate this projection.
+ * Rolldown remains authoritative for topology. Plugin hooks emit typed actions so the host serializes capture mutations with
+ * output and HMR publication; the projection and publisher below each own only one mutable concern.
+ *
+ * Complete-build path:
+ *   final transform captures → DevEngine output write → graph reconciliation → App build rotation
+ *
+ * Incremental path:
+ *   final transform captures → optional Tailwind root refresh → graph rendering → WXSS write → JavaScript patch publication
+ *
+ * Both paths render the same ordered App/Page graph projection. This prevents complete builds and HMR from implementing two
+ * subtly different CSS ownership policies, while keeping physical byte equality and atomic writes out of graph state.
  */
 export declare function createStyleCapture({ applicationEntryIds, outDir, emit, transformTailwindRoot }: {
     applicationEntryIds: readonly string[];
@@ -33,10 +45,10 @@ export declare function createStyleCapture({ applicationEntryIds, outDir, emit,
         code: string;
     }> | null>;
 }): Readonly<{
-    bindOutput: (output: readonly CompleteOutputFile[]) => void;
     captureGraph: (reader: GetModuleInfo) => void;
     captureStyle: (id: string, style: ProcessedStyle) => void;
     plugin: Plugin;
     publishChanged: (changedIds: readonly string[]) => Promise<void>;
+    reconcileComplete: (output: readonly CompleteOutputFile[]) => Promise<void>;
 }>;
 export {};

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

@@ -4,50 +4,39 @@ import { transformWxStyle } from '../styles/transform-wx-style.js';
 import { composeGraphStyleCss, createGraphStylePlan, createTailwindSidecarId, extractViteCss, isGlobalStyleRequest } from '../styles/utils.js';
 import { globalWxssFileName, writeHmrFile } from './hmr-files.js';
 /**
- * Owns capture hooks, the host's style projection, and its physical WXSS publication frontier.
+ * Captures final Vite CSS and composes the graph projection with its durable WXSS publisher.
  *
- * Rolldown remains authoritative for topology through its live graph reader. Plugin hooks emit typed actions so the host can
- * serialize captures with every other effect; only the matching capture methods mutate this projection.
+ * Rolldown remains authoritative for topology. Plugin hooks emit typed actions so the host serializes capture mutations with
+ * output and HMR publication; the projection and publisher below each own only one mutable concern.
+ *
+ * Complete-build path:
+ *   final transform captures → DevEngine output write → graph reconciliation → App build rotation
+ *
+ * Incremental path:
+ *   final transform captures → optional Tailwind root refresh → graph rendering → WXSS write → JavaScript patch publication
+ *
+ * Both paths render the same ordered App/Page graph projection. This prevents complete builds and HMR from implementing two
+ * subtly different CSS ownership policies, while keeping physical byte equality and atomic writes out of graph state.
  */
 export function createStyleCapture({ applicationEntryIds, outDir, emit, transformTailwindRoot }) {
-    /*
-     * This mutable capability is rebound by buildStart for each complete generation. Rolldown keeps the captured function live
-     * across incremental graph edits, so HMR traverses authoritative current topology without maintaining a shadow graph. It is
-     * undefined only before the first buildStart; retaining an older reader across a later complete build would bind transactions
-     * to the wrong engine generation, while snapshotting module data would require O(V + E) mutation on every edit.
-     */
-    let getModuleInfo;
-    /*
-     * This mutable Map is the CSS projection Rolldown does not retain: successful final transform hooks replace one module's
-     * processed bytes, failed transforms intentionally leave its last valid generation, and a successful multi-root Tailwind
-     * refresh commits all replacements only after every sibling resolves. Entries are not deleted when topology changes because
-     * reachability comes from the live graph plan; eager deletion would need a duplicate reverse graph and could remove CSS still
-     * shared by another App/Page root. Its size is bounded by style module identities seen during this server lifecycle.
-     */
-    const processedStyles = new Map();
-    /*
-     * This mutable value mirrors the WXSS bytes currently durable on disk. It has one owner but two real transition sources:
-     *
-     * 1. DevEngine physically writes complete output before onOutput, so bindOutput only observes and adopts that external
-     *    commit. An omitted asset means DevEngine preserved the existing file and this value must remain unchanged.
-     * 2. Incremental HMR is physically written by this host, so publishChanged advances the value only after its atomic write
-     *    succeeds (or after byte equality proves no write was needed).
-     *
-     * Combining these operations behind one generic update event would still require branching between “observe an existing
-     * write” and “perform a new write”, while hiding their different durability boundaries. A genuine single path would require
-     * preventing DevEngine from writing complete WXSS and transferring that entire output responsibility to the host, adding
-     * asset interception and ordering machinery. The two explicit methods are therefore the smallest accurate state model.
-     */
-    let publishedWxss;
+    const projection = createStyleProjection({
+        applicationEntryIds: applicationEntryIds,
+        transformTailwindRoot: transformTailwindRoot
+    });
+    const publication = createStylePublication(outDir);
     const plugin = {
         name: 'vpt:wx-dev-style-capture',
         buildStart() {
+            // Capture a live reader rather than a graph snapshot. Rolldown updates the capability as imports change, and a later
+            // complete generation replaces it through the host action queue before that generation can publish output.
             emit({ kind: 'capture-graph', getModuleInfo: (moduleId) => this.getModuleInfo(moduleId) });
         },
         transform(code, id) {
             if (!isGlobalStyleRequest(id)) {
                 return;
             }
+            // This host plugin runs after Vite's CSS transform, so `code` is the JavaScript wrapper containing final PostCSS and
+            // CSS-Module output. Capturing source CSS instead would lose generated class names and framework transformations.
             const css = extractViteCss(code, id);
             emit({
                 kind: 'capture-style',
@@ -60,48 +49,107 @@ export function createStyleCapture({ applicationEntryIds, outDir, emit, transfor
         }
     };
     return {
-        bindOutput(output) {
-            /*
-             * Complete output is one of the two real physical writers. Its emitted asset is therefore the authoritative frontier
-             * when present; omission means DevEngine preserved the existing file and this state must remain unchanged.
-             */
-            const style = output.find((file) => file.type === 'asset' && file.fileName === globalWxssFileName);
-            if (style) {
-                publishedWxss = typeof style.source === 'string' ? style.source : new TextDecoder().decode(style.source);
+        captureGraph: projection.captureGraph,
+        captureStyle: projection.captureStyle,
+        plugin: plugin,
+        async publishChanged(changedIds) {
+            // A CSS edit already carries updated processed bytes. Any non-CSS edit can alter both imports and Tailwind class
+            // candidates, so it requires a fresh graph plan and Tailwind-root generation even when no .css ID changed directly.
+            const styleChanged = changedIds.some(isGlobalStyleRequest);
+            const candidatesChanged = changedIds.some((id) => !isCSSRequest(id));
+            if (!styleChanged && !candidatesChanged) {
+                return;
             }
+            await publication.publish(await projection.render(candidatesChanged));
         },
+        async reconcileComplete(output) {
+            // Bundled development can omit CSS Modules from the compiler asset even with cssCodeSplit disabled. Observe the
+            // physical output first, then reconcile the same graph projection used by incremental HMR before App rotation.
+            publication.observeOutput(output);
+            await publication.publish(await projection.render(false));
+        }
+    };
+}
+/**
+ * Owns the live graph capability and final transformed bytes for every observed style module.
+ *
+ * Rendering is O(V + E + C): graph planning visits each reachable module and edge once, then composition and WX conversion
+ * process C CSS bytes once. The only persistent memory is one processed byte string per style identity observed by the server.
+ */
+function createStyleProjection({ applicationEntryIds, transformTailwindRoot }) {
+    /*
+     * This mutable capability is rebound by buildStart for each complete generation. Rolldown keeps the function live across
+     * incremental graph edits, so rendering uses authoritative topology without maintaining a shadow graph.
+     */
+    let getModuleInfo;
+    /*
+     * This mutable projection stores final CSS bytes that Rolldown does not retain. Successful transforms replace one entry;
+     * unreachable entries can remain because every render filters them through the current graph plan. Its size is bounded by
+     * style module identities observed during this server lifecycle.
+     */
+    const processedStyles = new Map();
+    return {
         captureGraph(reader) {
             getModuleInfo = reader;
         },
         captureStyle(id, style) {
             processedStyles.set(id, style);
         },
-        plugin: plugin,
-        async publishChanged(changedIds) {
-            const styleChanged = changedIds.some(isGlobalStyleRequest);
-            const candidatesChanged = changedIds.some((id) => !isCSSRequest(id));
-            if (!styleChanged && !candidatesChanged) {
-                return;
-            }
+        async render(refreshTailwind) {
             if (!getModuleInfo) {
-                throw new Error('WX style graph is unavailable before HMR publication');
+                throw new Error('WX style graph is unavailable before publication');
             }
-            // Traverse topology exactly once; root refresh and final rendering consume this immutable transaction plan.
+            // App first and configured Pages afterward define one deterministic global cascade. The plan also removes stale map
+            // entries implicitly: styles no longer reachable from these roots never enter composition.
             const styleIds = createGraphStylePlan(applicationEntryIds, getModuleInfo, (styleId) => processedStyles.has(styleId));
-            if (candidatesChanged) {
+            if (refreshTailwind) {
                 await refreshTailwindStyles(styleIds, processedStyles, transformTailwindRoot);
             }
+            // Compose browser-facing transformed CSS first, then run one whole-file WX pass. Transforming modules independently
+            // would change cross-module cascade behavior and duplicate compatibility work.
             const css = composeGraphStyleCss(styleIds, (styleId) => requireProcessedStyle(processedStyles, styleId).css);
-            const wxss = (await transformWxStyle(css)).css;
+            return (await transformWxStyle(css)).css;
+        }
+    };
+}
+/**
+ * Owns the physical WXSS frontier independently from graph capture and rendering.
+ *
+ * DevEngine writes complete output itself; incremental HMR does not. Observing complete output before publishing the projection
+ * gives both writers one byte frontier, so equality avoids redundant filesystem notifications without pretending the host owns
+ * the compiler's write transaction.
+ */
+function createStylePublication(outDir) {
+    /*
+     * This mutable value mirrors bytes durable on disk. Complete output adopts the compiler's external write before graph
+     * reconciliation; host publication advances it only after an atomic write succeeds or byte equality proves none is needed.
+     */
+    let publishedWxss;
+    return {
+        observeOutput(output) {
+            // Missing WXSS means DevEngine intentionally reused the existing physical asset. Do not reset the frontier: doing so
+            // would force an identical rewrite and a spurious DevTools style event on every omitted complete generation.
+            const style = output.find((file) => file.type === 'asset' && file.fileName === globalWxssFileName);
+            if (style) {
+                publishedWxss = typeof style.source === 'string' ? style.source : new TextDecoder().decode(style.source);
+            }
+        },
+        async publish(wxss) {
             if (wxss !== publishedWxss) {
+                // writeHmrFile uses atomic replacement; advance the frontier only after durability so a failed write leaves the
+                // last known physical generation available for the next reconciliation attempt.
                 await writeHmrFile(outDir, globalWxssFileName, wxss);
             }
-            // HMR is the second physical writer; advance the frontier only after its atomic write succeeds or was unnecessary.
             publishedWxss = wxss;
         }
     };
 }
-/** Regenerates all reachable Tailwind roots and commits the cache only when every transform succeeds. */
+/**
+ * Regenerates all reachable Tailwind roots and commits the cache only when every transform succeeds.
+ *
+ * Roots run concurrently because they are independent derivations of the same candidate generation. Results remain local until
+ * Promise.all fulfills; one failed root therefore preserves every prior root together instead of publishing a mixed generation.
+ */
 async function refreshTailwindStyles(styleIds, processedStyles, transformRoot) {
     const roots = styleIds.filter((styleId) => requireProcessedStyle(processedStyles, styleId).isTailwindRoot);
     const refreshedStyles = await Promise.all(roots.map(async (rootId) => {

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

@@ -1,5 +1,5 @@
 import type { ViteDevServer } from 'vite';
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 export type WxDevHost = Readonly<{
     close: () => Promise<void>;
 }>;
@@ -14,6 +14,6 @@ export type WxDevHost = Readonly<{
  */
 export declare function createWxDevHost({ server, options, applicationEntryIds }: {
     server: ViteDevServer;
-    options: VitePluginTaroOptions;
+    options: VptOptions;
     applicationEntryIds: readonly string[];
 }): Promise<WxDevHost>;

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

@@ -11,7 +11,7 @@ import { PatchPublisher } from './patch-publisher.js';
 import { createRuntimeReportsStream } from './runtime-reports.js';
 import { installWxDevOptions, requireSingleOutput } from './wx-dev-options.js';
 /** One short trailing-edge window absorbs editor bursts before style preparation and physical Page notification. */
-const hmrSettleMilliseconds = 32;
+const hmrSettleMilliseconds = 16;
 /**
  * Creates the wx dev host: the adapter that owns the physical Rolldown DevEngine (created
  * with dev(...)) and the patch publisher, and replaces Vite's bundledDev.listen so the
@@ -163,12 +163,22 @@ export async function createWxDevHost({ server, options, applicationEntryIds })
                     logWxError(server.config.logger, 'wx dev build failed', action.result);
                     return;
                 }
-                styleCapture.bindOutput(action.result.output);
-                return rotateBuildSession();
+                return reconcileCompleteOutput(action.result.output);
             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);
+        await rotateBuildSession();
+    }
     /** Applies one runtime receipt to the active physical patch history. */
     function processReport(report) {
         // Delayed reports from older builds must never prune the live build's cumulative patch history.

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

@@ -1,5 +1,5 @@
 import { type PluginOption } from 'vite';
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 /** Selects the sole Vite environment that owns the physical Mini Program development project. */
 export declare function isWxClientEnvironment(environment: Readonly<{
     name: string;
@@ -11,7 +11,7 @@ export declare function isWxClientEnvironment(environment: Readonly<{
  * The ordered application entries cross this configuration boundary unchanged so the host can compose global CSS without
  * reconstructing the resolver's App/Page ownership policy from unrelated Rolldown shell and transport entries.
  */
-export declare function createWxDevelopmentPlugin(options: VitePluginTaroOptions, applicationEntryIds: readonly string[]): PluginOption[];
+export declare function createWxDevelopmentPlugin(options: VptOptions, applicationEntryIds: readonly string[]): PluginOption[];
 /**
  * Transfers development ownership of `app.wxss` from complete output to the dev host.
  *

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

@@ -1,7 +1,7 @@
 import type { InputOptions, OutputOptions, Plugin } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 type BundledDevRolldownOptions = InputOptions & {
     experimental?: {
         [key: string]: unknown;
@@ -22,7 +22,7 @@ export type BundledDev = {
 export declare function installWxDevOptions({ bundledDev, server, options, hostPlugins }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
-    options: VitePluginTaroOptions;
+    options: VptOptions;
     hostPlugins: Plugin[];
 }): void;
 /** Returns the configured output after rejecting states unsupported by the physical WX engine. */

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

@@ -1,10 +1,10 @@
 import type { Rolldown } from 'vite';
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 import type { GeneratedSubpackage } from '../placement/placer.ts';
 /** 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;
+    options: VptOptions;
     subpackages: readonly GeneratedSubpackage[];
     getModuleInfo: (moduleId: string) => {
         meta: Rolldown.CustomPluginOptions;

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

@@ -1,9 +1,9 @@
 import type { Rolldown } from 'vite';
-import type { JsonObject, VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptJsonObject, VptOptions } from '../../../../options.ts';
 import type { GeneratedSubpackage } from '../placement/placer.ts';
 /** Creates every configured native JSON asset. */
 export declare function createJsonAssets({ options, subpackages, nativeComponents }: {
-    options: VitePluginTaroOptions;
+    options: VptOptions;
     subpackages: readonly GeneratedSubpackage[];
     nativeComponents: readonly {
         name: string;
@@ -11,4 +11,4 @@ export declare function createJsonAssets({ options, subpackages, nativeComponent
     }[];
 }): Rolldown.EmittedAsset[];
 /** Serializes one native JSON object with stable formatting. */
-export declare function renderJson(value: JsonObject): string;
+export declare function renderJson(value: VptJsonObject): string;

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

@@ -13,7 +13,7 @@ export function createJsonAssets({ options, subpackages, nativeComponents }) {
         ...(options.projectPrivateConfigJson
             ? [createJsonAsset('project.private.config.json', options.projectPrivateConfigJson)]
             : []),
-        createJsonAsset('sitemap.json', options.sitemapJson)
+        ...(options.sitemapJson ? [createJsonAsset('sitemap.json', options.sitemapJson)] : [])
     ];
 }
 /** Creates Page JSON with generated Taro and native component registrations. */

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

@@ -1,7 +1,7 @@
 import type { Rolldown } from 'vite';
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 /** Creates Taro's shared WeChat templates and native WXML/WXSS companions for every Page. */
-export declare function createTemplateAssets(bundle: Rolldown.OutputBundle, options: VitePluginTaroOptions, nativeComponents: readonly {
+export declare function createTemplateAssets(bundle: Rolldown.OutputBundle, options: VptOptions, nativeComponents: readonly {
     name: string;
     fields: readonly string[];
 }[]): Rolldown.EmittedAsset[];

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

@@ -1,4 +1,4 @@
 import type { PluginOption } from 'vite';
-import type { VitePluginTaroOptions } from '../../../options.ts';
+import type { VptOptions } from '../../../options.ts';
 /** Creates the complete plugin set for the wx target. */
-export declare function createWxTargetPlugins(options: VitePluginTaroOptions): PluginOption[];
+export declare function createWxTargetPlugins(options: VptOptions): PluginOption[];

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

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { types } from '@babel/core';
 import { replaceWithAst } from '../../../utils/transform.js';
 import { getWxExecutionKind } from '../module.js';
-const transportPlaceholder = '__VITE_PLUGIN_TARO_TRANSPORT__';
+const transportPlaceholder = '__VPT_TRANSPORT__';
 const moduleIdParameter = 'moduleId';
 const exportBindingParameter = 'exportBinding';
 /**

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

@@ -1,6 +1,6 @@
-import type { VitePluginTaroOptions } from '../../../../options.ts';
+import type { VptOptions } from '../../../../options.ts';
 /** Creates the resolver and source specializer for the wx module graph. */
-export declare function createResolver(options: VitePluginTaroOptions): {
+export declare function createResolver(options: VptOptions): {
     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[];

package/dist/node/plugins/wx/resolve/specialize-bootstrap.d.ts

@@ -1,9 +1,9 @@
-import type { JsonObject } from '../../../../options.ts';
+import type { VptJsonObject } from '../../../../options.ts';
 import { type AstTransformResult } from '../../../utils/transform.ts';
 /** Specializes the amphibious bootstrap with the shared App configuration. */
 export declare function specializeBootstrap({ code, id, appConfig, sourcemap }: {
     code: string;
     id: string;
-    appConfig: JsonObject;
+    appConfig: VptJsonObject;
     sourcemap?: boolean;
 }): Promise<AstTransformResult>;

package/dist/node/plugins/wx/resolve/specialize-bootstrap.js

@@ -1,6 +1,6 @@
 import { types } from '@babel/core';
 import { replaceWithAst } from '../../../utils/transform.js';
-const appConfigPlaceholder = '__VITE_PLUGIN_TARO_APP_CONFIG__';
+const appConfigPlaceholder = '__VPT_APP_CONFIG__';
 /** Specializes the amphibious bootstrap with the shared App configuration. */
 export function specializeBootstrap({ code, id, appConfig, sourcemap = true }) {
     return replaceWithAst(code, id, {

package/dist/node/plugins/wx/resolve/specialize-page-capsule.d.ts

@@ -1,9 +1,9 @@
-import type { VitePluginTaroPageOption } from '../../../../options.ts';
+import type { VptPageOption } from '../../../../options.ts';
 import { type AstTransformResult } from '../../../utils/transform.ts';
 /** Specializes the Page capsule for one configured route. */
 export declare function specializePageCapsule({ code, id, page, sourcemap }: {
     code: string;
     id: string;
-    page: VitePluginTaroPageOption;
+    page: VptPageOption;
     sourcemap?: boolean;
 }): Promise<AstTransformResult>;

package/dist/node/plugins/wx/resolve/specialize-page-capsule.js

@@ -1,7 +1,7 @@
 import { types } from '@babel/core';
 import { replaceWithAst } from '../../../utils/transform.js';
-const pagePathPlaceholder = '__VITE_PLUGIN_TARO_PAGE_PATH__';
-const pageConfigPlaceholder = '__VITE_PLUGIN_TARO_PAGE_CONFIG__';
+const pagePathPlaceholder = '__VPT_PAGE_PATH__';
+const pageConfigPlaceholder = '__VPT_PAGE_CONFIG__';
 /** Specializes the Page capsule for one configured route. */
 export function specializePageCapsule({ code, id, page, sourcemap = true }) {
     return replaceWithAst(code, id, {

package/dist/node/utils/project-config.d.ts

@@ -1,3 +1,3 @@
-import type { JsonObject, VitePluginTaroOptions } from '../../options.ts';
+import type { VptJsonObject, VptOptions } from '../../options.ts';
 /** Creates shared App configuration with configured Page order as the authoritative value. */
-export declare function createAppConfig(options: VitePluginTaroOptions): JsonObject;
+export declare function createAppConfig(options: VptOptions): VptJsonObject;

package/dist/node/vpt.d.ts

@@ -0,0 +1,4 @@
+import type { PluginOption } from 'vite';
+import type { VptOptions } from '../options.ts';
+/** Creates the Vite plugins for one Taro target. */
+export default function vpt(options: VptOptions): PluginOption[];

package/dist/node/{vite-plugin.js → vpt.js}

@@ -4,7 +4,7 @@ import { createConditionalDirectivePlugin } from './plugins/conditional/conditio
 import { createH5TargetPlugins } from './plugins/h5/plugins.js';
 import { createWxTargetPlugins } from './plugins/wx/plugins.js';
 /** Creates the Vite plugins for one Taro target. */
-export default function vitePluginTaro(options) {
+export default function vpt(options) {
     return [
         createConditionalDirectivePlugin(options.target),
         createClientTaroPlugin(options.target),