vite-plugin-taro 0.6.20 → 0.7.0

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

@@ -0,0 +1,29 @@
+import type { ViteDevServer } from 'vite';
+import { type RuntimeControlMessage, type RuntimeReport } from '../../../../runtime/mini/dev/hmr-protocol.ts';
+import type { MiniContract } from '../mini-contract.ts';
+import type { MiniStylePlugin } from '../styles/plugins.ts';
+import type { MiniHmrMode } from './hmr-mode.ts';
+declare module 'vite' {
+    interface CustomEventMap {
+        'vpt:mini-hmr:control': RuntimeControlMessage;
+        'vpt:mini-hmr:report': RuntimeReport;
+    }
+}
+export type MiniDevHost = Readonly<{
+    close: () => Promise<void>;
+}>;
+/**
+ * Creates the Mini Program dev host: the adapter that owns the physical Rolldown DevEngine and selected update mode effects.
+ * It replaces Vite's browser-oriented `bundledDev.listen()` because a Mini Program cannot execute Vite's browser module graph;
+ * its engine must write a native project and either replace complete output or deliver environment-valid patches.
+ *
+ * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
+ * every live import edge. Keeping those responsibilities in the same serialized host transaction prevents JavaScript factories,
+ * physical native styles, and Rolldown's published frontier from describing different source generations.
+ */
+export declare function createMiniDevHost({ server, contract, styles, hmrMode }: {
+    server: ViteDevServer;
+    contract: Pick<MiniContract, 'options' | 'styles'>;
+    styles: MiniStylePlugin;
+    hmrMode: MiniHmrMode;
+}): Promise<MiniDevHost>;

package/dist/node/plugins/{wx → mini}/dev/hmr-files.d.ts

@@ -1,6 +1,4 @@
 import type { HmrInfo } from './hmr-protocol.ts';
-export declare const developmentAppWxssFileName = "app.wxss";
-export declare const globalWxssFileName = "assets/global.wxss";
 export declare const hmrInfoFileName = "hmr/info.js";
 /**
  * Renders immutable CommonJS metadata because App startup must initialize the runtime synchronously before any entry capsule.
@@ -14,7 +12,7 @@ export declare function renderHmrInfo(info: HmrInfo): string;
  * cache after it restarts. Tying this inert comment to the build identity invalidates that cache once per complete build,
  * while incremental style updates continue changing only the imported file and therefore preserve the App heap.
  */
-export declare function renderDevelopmentAppWxss(buildId: string): string;
+export declare function renderDevelopmentAppStyle(globalStyleFileName: string, buildId: string): string;
 /**
  * Atomically publishes one physical development file so DevTools can observe only complete generations.
  *

package/dist/node/plugins/mini/dev/hmr-mode.d.ts

@@ -0,0 +1,32 @@
+import type { Plugin } from 'vite';
+import type { MiniHmrOptions, RuntimeModulesContract } from '../mini-contract.ts';
+import type { PatchPublication } from './hmr-protocol.ts';
+/** One mode-selected effect executed by the development host. */
+export type MiniHmrAction = Readonly<{
+    kind: 'event';
+    event: string;
+    data: unknown;
+}> | Readonly<{
+    kind: 'write';
+    fileName: string;
+    source: string;
+}>;
+/**
+ * The behavior that differs between Mini Program development update implementations.
+ *
+ * Every mode selects one runtime, plugin set, entry banner, Rolldown rebuild policy, and declarative patch effects. Rebuild mode
+ * uses `always` and returns no patch effects.
+ */
+export type MiniHmrMode = Readonly<{
+    rebuildStrategy: 'always' | 'on-failure';
+    runtimeFile: string;
+    plugins: readonly Plugin[];
+    reset?: () => MiniHmrAction;
+    publish?: (publication: PatchPublication) => MiniHmrAction;
+    createEntryBanner: (pageFiles: ReadonlySet<string>) => (chunk: Readonly<{
+        name: string;
+        fileName: string;
+    }>) => string;
+}>;
+/** Resolves exactly one implementation before the Mini Program development host is created. */
+export declare function createMiniHmrMode(options: MiniHmrOptions, modules: RuntimeModulesContract): MiniHmrMode;

package/dist/node/plugins/{wx → mini}/dev/hmr-protocol.d.ts

@@ -1,7 +1,7 @@
 import type { BindingClientHmrUpdate } from 'rolldown/experimental';
 /** Shared Vite WebSocket path for runtime reports and mode-specific HMR events. */
 export declare const hmrEndpointPath = "/__vpt_hmr__";
-export type { HmrInfo, RuntimeReport } from '../../../../runtime/wx/dev/wx-hmr-protocol.ts';
+export type { HmrInfo, RuntimeReport } from '../../../../runtime/mini/dev/hmr-protocol.ts';
 /** The Patch variant of Rolldown's per-client HMR update admitted into the patch journal. */
 export type PatchUpdate = Extract<BindingClientHmrUpdate['update'], {
     type: 'Patch';

package/dist/node/plugins/{wx/dev/wx-dev-options.d.ts → mini/dev/mini-dev-options.d.ts}

@@ -1,8 +1,8 @@
 import type { InputOptions, OutputOptions } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
-import type { VptOptions } from '../../../../options.ts';
-import type { WxHmrMode } from './hmr-mode.ts';
+import type { MiniContract } from '../mini-contract.ts';
+import type { MiniHmrMode } from './hmr-mode.ts';
 type BundledDevRolldownOptions = InputOptions & {
     experimental?: {
         [key: string]: unknown;
@@ -17,15 +17,15 @@ export type BundledDev = {
     triggerBundleRegenerationIfStale(): Promise<boolean>;
 };
 /**
- * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
+ * Installs physical Mini Program 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, hmrMode }: {
+export declare function installMiniDevOptions({ bundledDev, server, contract, hmrMode }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
-    options: VptOptions;
-    hmrMode: WxHmrMode;
+    contract: Pick<MiniContract, 'options'>;
+    hmrMode: MiniHmrMode;
 }): void;
-/** Returns the configured output after rejecting states unsupported by the physical WX engine. */
+/** Returns the configured output after rejecting states unsupported by the physical Mini Program engine. */
 export declare function requireSingleOutput(rolldownOptions: BundledDevRolldownOptions): OutputOptions;
 export {};

package/dist/node/plugins/{wx → mini}/dev/modes/devtools/devtools-hmr-mode.d.ts

@@ -1,14 +1,15 @@
-import type { WxHmrMode } from '../../hmr-mode.ts';
+import type { RuntimeModulesContract } from '../../../mini-contract.ts';
+import type { MiniHmrMode } from '../../hmr-mode.ts';
 import type { PatchUpdate } from '../../hmr-protocol.ts';
 export declare const devtoolsPatchesFileName = "hmr/patches.js";
 /**
- * Collects the behavior that depends on WeChat DevTools project-file compilation.
+ * Collects behavior that depends on native development-tool project-file compilation.
  *
  * Runtime entry, Page transform, entry banners, and patch delivery stay in one descriptor because they implement one protocol:
  * DevTools observes a changed Page dependency, re-executes the Page shell, and that shell synchronously gives the cumulative
  * native factory payload to the persistent App runtime. Mixing any one of these pieces with another mode would break that chain.
  */
-export declare function createDevtoolsHmrMode(): WxHmrMode;
+export declare function createDevtoolsHmrMode(modules: RuntimeModulesContract): MiniHmrMode;
 /** Provides a valid, inert CommonJS dependency before the host has a patch range to publish. */
 export declare function renderInitialDevtoolsPatches(): string;
 /**

package/dist/node/plugins/mini/dev/modes/interpreter/interpreter-hmr-mode.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeModulesContract } from '../../../mini-contract.ts';
+import type { MiniHmrMode } from '../../hmr-mode.ts';
+/** Creates the pure interpreter adapter whose events are dispatched by the shared development host. */
+export declare function createInterpreterHmrMode(modules: RuntimeModulesContract): MiniHmrMode;

package/dist/node/plugins/mini/dev/modes/rebuild/rebuild-hmr-mode.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeModulesContract } from '../../../mini-contract.ts';
+import type { MiniHmrMode } from '../../hmr-mode.ts';
+/** Selects complete-output replacement without installing a patch transport or native Page handoff. */
+export declare function createRebuildHmrMode(modules: RuntimeModulesContract): MiniHmrMode;

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

@@ -0,0 +1,35 @@
+import { type PluginOption } from 'vite';
+import type { MiniContract } from '../mini-contract.ts';
+import type { MiniStylePlugin } from '../styles/plugins.ts';
+/** Selects the sole Vite environment that owns the physical Mini Program development project. */
+export declare function isMiniClientEnvironment(environment: Readonly<{
+    name: string;
+}>): boolean;
+/**
+ * Adds the serve-only bundled-development plugin set for a Mini Program target: the shared dev adapter, selected HMR mode, and React
+ * Refresh adaptation transforms.
+ *
+ * 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 createMiniDevelopmentPlugin(contract: Pick<MiniContract, 'options' | 'runtime' | 'styles'>, styles: MiniStylePlugin): PluginOption[];
+/**
+ * Transfers development ownership of the App stylesheet from complete output to the dev host.
+ *
+ * The ordinary output hook emits the static production wrapper during every complete build. In development, the existing
+ * physical wrapper instead contains the previous complete-build marker. 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 the native tool observe that root-style change and reload the App against the previous patch identity, or before a
+ *    rebuild-mode transaction has completed;
+ * 3. let the host replace the wrapper again with the new marker, 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 stylesheet remains available while complete output is written. The host replaces it exactly once afterward.
+ * Patch modes first reset delivery and publish matching `hmr/info.js`; rebuild mode has no patch state and writes a fresh marker
+ * directly. Incremental HMR never enters this complete-output hook and changes only the imported global stylesheet; rewriting
+ * the App root would reload the heap while a JavaScript patch is awaiting acknowledgement. The serve-only plugin leaves
+ * production output unchanged.
+ */
+export declare function removeDevelopmentAppStyle(bundle: Record<string, unknown>, appStyleFileName: string): void;

package/dist/node/plugins/{wx → mini}/dev/react-refresh.d.ts

@@ -1,24 +1,24 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 /**
- * Creates the serve-only React Refresh adaptation transforms for the wx target.
+ * Creates the serve-only React Refresh adaptation transforms for a Mini Program target.
  *
- * @vitejs/plugin-react's generated refresh code assumes an HTML preamble and a browser global scope; wx has neither. Each
+ * @vitejs/plugin-react assumes an HTML preamble and browser global scope; Mini Program hosts provide neither. Each
  * transform owns one distinct compatibility boundary:
  *
  * - The refresh runtime is selected by exact ID. It rewrites only the two browser protocol globals that React Refresh evaluates
  *   and injects its renderer hook at module evaluation, replacing the missing HTML preamble.
  * - React Reconciler is selected by exact physical ID. Its renderer injection receives a static dependency on the refresh
  *   runtime, so hook installation cannot race renderer initialization during cold startup.
- * - React-family modules are selected by the reserved free DevTools-hook identifier. Their expression references must resolve
- *   through WeChat's `global` object; an AST visitor edits only those identifier ranges after the filter admits the module.
+ * - React-family modules are selected by the reserved free DevTools-hook identifier. Their expression references are rewritten
+ *   as explicit `globalThis` members; an AST visitor edits only those identifier ranges after the filter admits the module.
  * - Refresh boundaries are selected by Vite's generated `$RefreshReg$` guard. The AST transform removes only that web-preamble
  *   assertion because each boundary already owns local wrappers over the imported refresh runtime.
  *
  * These adaptations deliberately remain serve-only plugin transforms rather than target-wide `define` entries. That scope
- * prevents development protocol behavior from leaking into production or unrelated WX modules. Plugin order also
+ * prevents development protocol behavior from leaking into production or unrelated Mini Program modules. Plugin order also
  * matters: Reconciler receives its static refresh dependency before the later DevTools-hook transform lowers its free references.
  */
-export declare function createWxReactRefreshTransforms(): Plugin[];
+export declare function createMiniReactRefreshTransforms(): Plugin[];
 /** Makes renderer hook injection statically depend on the refresh runtime. */
 export declare function injectReactRefreshRendererDependency(code: string): {
     code: string;

package/dist/node/plugins/mini/mini-contract.d.ts

@@ -0,0 +1,66 @@
+import type { Rolldown } from 'vite';
+import type { VptJsonObject, VptOptions } from '../../../options.ts';
+/** Taro compiler bindings selected by one Mini Program target. */
+export type TaroContract = {
+    env: string;
+    componentsReactPath: string;
+    platformRuntimePath: string;
+};
+/** Physical runtime modules selected by one Mini Program target. */
+export type RuntimeModulesContract = {
+    bootstrap: string;
+    transport: string;
+    appShell: string;
+    appCapsule: string;
+    componentShell: string;
+    componentCapsule: string;
+    customWrapperShell: string;
+    pageShell: string;
+    pageCapsule: string;
+    devtoolsHmrRuntime: string;
+    interpreterHmrRuntime: string;
+};
+/** Physical runtime selection for one Mini Program target. */
+export type RuntimeContract = {
+    modules: RuntimeModulesContract;
+};
+/** Style output names selected by one Mini Program target. */
+export type StyleContract = {
+    appFileName: string;
+    globalFileName: string;
+};
+/** Native component registration discovered from the final Mini Program graph. */
+export type MiniNativeComponentRegistration = Readonly<{
+    name: string;
+    componentPath: string;
+    fields: readonly string[];
+}>;
+/** Graph-retained generated code package awaiting target-specific declaration. */
+export type MiniGeneratedSubpackage = Readonly<{
+    root: string;
+}>;
+/** Complete final-graph input supplied to one target's project-skeleton generator. */
+export type MiniProjectSkeletonInput = Readonly<{
+    bundle: Rolldown.OutputBundle;
+    subpackages: readonly MiniGeneratedSubpackage[];
+    nativeComponents: readonly MiniNativeComponentRegistration[];
+    isProduction: boolean;
+}>;
+/** One target-owned native project-skeleton generator. */
+export type OutputContract = {
+    generateProjectSkeleton(input: MiniProjectSkeletonInput): Rolldown.EmittedAsset[];
+};
+/** Complete input consumed by the shared Mini Program pipeline. */
+export type MiniContract = {
+    options: VptOptions;
+    taro: TaroContract;
+    runtime: RuntimeContract;
+    styles: StyleContract;
+    output: OutputContract;
+};
+/** Application JSON represented by the current Mini Program contract. */
+export type MiniJsonObject = VptJsonObject;
+/** One Page represented by the current Mini Program contract. */
+export type MiniPage = MiniContract['options']['pages'][number];
+/** HMR configuration represented by the current Mini Program contract. */
+export type MiniHmrOptions = MiniContract['options']['hmr'];

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

@@ -0,0 +1,38 @@
+import type { Rolldown } from 'vite';
+import type { RuntimeModulesContract } from '../mini-contract.ts';
+/** Identifies Rolldown's generated helper module independently of its unstable output filename. */
+export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
+/** Resolves the shared Taro facade's platform initialization side effect. */
+export declare const taroPlatformRuntimeId = "\0vpt:taro-platform-runtime";
+/** Redirects Vite's injected browser preload helper to the bootstrap identity loader. */
+export declare const vitePreloadId = "\0vite/preload-helper.js";
+/** Forces the native App shell entry to emit at the required root path. */
+export declare const appShellFileName = "app.js";
+/** Forces Taro's recursive native Component entry to emit at its configured root path. */
+export declare const componentShellFileName = "comp.js";
+/** Forces Taro's CustomWrapper native shell to emit at its configured root path. */
+export declare const customWrapperShellFileName = "custom-wrapper.js";
+/** Resolves the configured Page component from its route-qualified capsule importer. */
+export declare const pageComponentId = "\0vpt:page-component";
+/** Gives every Page shell one private capsule target that can be resolved using its route. */
+export declare const pageCapsuleId = "\0vpt:page-capsule";
+export type MiniChunk = Rolldown.PreRenderedChunk | Rolldown.RenderedChunk;
+/** Build-graph role of an explicit native lifecycle entry. */
+export type MiniEntryRole = 'shell' | 'capsule';
+/** Runtime domain in which one final Mini Program JavaScript chunk executes. */
+export type MiniExecutionKind = 'native' | 'capsule' | 'amphibious';
+/** Complete execution classification derived from one pass over a chunk's module IDs. */
+export type MiniChunkClassification = Readonly<{
+    entryRole: MiniEntryRole | undefined;
+    executionKind: MiniExecutionKind;
+    isTransport: boolean;
+}>;
+/** Classifies final chunks against one immutable shared-runtime module table. */
+export type MiniModuleClassifier = (chunk: MiniChunk) => MiniChunkClassification;
+/**
+ * Creates a classifier whose fixed identity sets are shared by every chunk in one plugin instance.
+ *
+ * Construction is O(1). Each classification normalizes every module ID exactly once and runs in O(M), where M is the number
+ * of modules in the chunk. This replaces separate shell, capsule, amphibious, and transport scans.
+ */
+export declare function createMiniModuleClassifier(modules: RuntimeModulesContract): MiniModuleClassifier;

package/dist/node/plugins/{wx → mini}/output/files.d.ts

@@ -1,10 +1,10 @@
 import type { Rolldown } from 'vite';
-import type { VptOptions } from '../../../../options.ts';
+import type { MiniContract } from '../mini-contract.ts';
 import type { GeneratedSubpackage, PackageLocation } from '../placer/placement.ts';
-/** Creates every compiler-owned WX file derived from the final Rolldown bundle. */
-export declare function createOutputFiles({ bundle, options, subpackages, isProduction, getModuleInfo, getPackageLocation }: {
+/** Creates every compiler-owned Mini Program file derived from the final Rolldown bundle. */
+export declare function createOutputFiles({ bundle, contract, subpackages, isProduction, getModuleInfo, getPackageLocation }: {
     bundle: Rolldown.OutputBundle;
-    options: VptOptions;
+    contract: Pick<MiniContract, 'output' | 'styles'>;
     subpackages: readonly GeneratedSubpackage[];
     isProduction: boolean;
     getModuleInfo: (moduleId: string) => {

package/dist/node/plugins/{wx → mini}/placer/placement.d.ts

@@ -1,5 +1,5 @@
 import type { Rolldown } from 'vite';
-export declare const subpackagePlanningBudget = 1900000;
+import type { MiniGeneratedSubpackage } from '../mini-contract.ts';
 /** Identifies one generated code-only subpackage by its physical output root. */
 export type SubpackageLocation = {
     /** Discriminates generated subpackages from main. */
@@ -11,15 +11,8 @@ export type SubpackageLocation = {
 export type PackageLocation = {
     kind: 'main';
 } | SubpackageLocation;
-/** Native app.json declaration for one generated code-only subpackage. */
-export type GeneratedSubpackage = {
-    /** Stable native alias derived from the generated root hash. */
-    name: string;
-    /** Physical directory containing this subpackage's emitted capsules. */
-    root: string;
-    /** Marks this as a code-only subpackage with no native Page routes. */
-    pages: readonly [];
-};
+/** One generated code package retained by the final output graph. */
+export type GeneratedSubpackage = MiniGeneratedSubpackage;
 /** Immutable ownership and materialization operations for one complete final-chunk graph. */
 export type Placement = Readonly<{
     getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation;
@@ -43,8 +36,9 @@ export type Placement = Readonly<{
  * Analysis costs the sum of transition static-closure traversals. Packing scans fitting bins and intersects sparse
  * transition sets; its worst case is O(CBT), while practical graphs have few bins and sparse transition membership.
  */
-export declare function createPlacement({ chunks, getAdditionalModuleBytes }: {
+export declare function createPlacement({ chunks, planningBudgetBytes, getAdditionalModuleBytes }: {
     chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    planningBudgetBytes: number;
     getAdditionalModuleBytes(moduleId: string): number;
 }): Placement;
 /** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */

package/dist/node/plugins/{wx → mini}/placer/placer.d.ts

@@ -1,20 +1,23 @@
 import { type Plugin, type Rolldown } from 'vite';
+import type { RuntimeModulesContract } from '../mini-contract.ts';
+import { type MiniChunkClassification, type MiniModuleClassifier } from '../module/module.ts';
 import { type GeneratedSubpackage, type PackageLocation } from './placement.ts';
 export type { GeneratedSubpackage, Placement } from './placement.ts';
 /** Selects the explicit React/Taro roots whose complete dependency closure forms the framework vendor chunk. */
-export declare function isWxFrameworkVendorModule(moduleId: string): boolean;
-/** Placement services consumed by the later `vpt:wx` rendering and output hooks. */
-export type WxPlacementPlugin = Plugin & Readonly<{
+export declare function isMiniFrameworkVendorModule(moduleId: string): boolean;
+/** Placement services consumed by the later Mini Program rendering and output hooks. */
+export type MiniPlacementPlugin = Plugin & Readonly<{
+    classifyChunk(chunk: Rolldown.PreRenderedChunk | Rolldown.RenderedChunk): MiniChunkClassification;
     getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation;
     getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string;
     getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
     getSubpackages(): readonly GeneratedSubpackage[];
 }>;
 /**
- * Rolldown options owned by WX placement. Every field enforces a distinct output invariant. The plugin returns this object
+ * Rolldown options owned by Mini Program placement. Every field enforces a distinct output invariant. The plugin returns this object
  * from its config hook, while direct Rolldown integration tests reuse the same value to exercise the identical lifecycle.
  */
-export declare const placementRolldownOptions: {
+export declare function createPlacementRolldownOptions(classifyChunk: MiniModuleClassifier): {
     /**
      * Output-stage naming remains under Rolldown's ownership. These options establish physical candidates and hash
      * participation only; LTHP mutates the resulting OutputChunk filenames later without replacing the chunks.
@@ -24,18 +27,18 @@ export declare const placementRolldownOptions: {
          * React and Taro form one stable framework boundary shared by the App and every Page capsule. Keeping their complete
          * dependency closure together prevents application edits from invalidating framework chunk identity and makes later
          * development generations eligible to reuse the unchanged vendor. All remaining modules use Rolldown's automatic
-         * chunking; physical WX package placement operates on those final chunks without imposing another split strategy.
+         * chunking; physical Mini Program package placement operates on those final chunks without another split strategy.
          */
         codeSplitting: {
             groups: {
                 name: string;
-                test: typeof isWxFrameworkVendorModule;
+                test: typeof isMiniFrameworkVendorModule;
                 priority: number;
                 includeDependenciesRecursively: boolean;
             }[];
         };
         /**
-         * Native App/Page/Component shells are files addressed directly by WeChat and must retain the exact names configured
+         * Native App/Page/Component shells are files addressed directly by the host and must retain the exact names configured
          * in `input`, such as `app.js` and `pages/home/index.js`. Transport is excluded even though it is CommonJS:
          * application chunks import its content-hashed path, so it belongs with hashed runtime/capsule entries. `[hash]`
          * remains a Rolldown placeholder here and is resolved only after renderChunk transforms finish.
@@ -61,16 +64,16 @@ export declare const placementRolldownOptions: {
     preserveEntrySignatures: 'allow-extension';
 };
 /**
- * Creates the `vpt:wx-placer` lifecycle owner:
+ * Creates the Mini Program placement lifecycle owner:
  *
  * 1. Its config hook installs package-neutral Rolldown names and entry-signature semantics.
  * 2. `renderStart` atomically starts a generation in `awaiting-chunks`; no stale placement remains reachable.
  * 3. Its first pre-order `renderChunk` creates one immutable LTHP placement from the complete tree-shaken graph.
- * 4. `vpt:wx` asks this plugin only for package ownership, physical relocation, and native loading mode.
+ * 4. `vpt:mini` asks this plugin only for package ownership, physical relocation, and native loading mode.
  * 5. Its pre-order `generateBundle` assigns each OutputChunk its package-qualified filename and publishes app.json declarations.
  *
  * The discriminated state is the only generation-local mutation: `idle → awaiting-chunks → planned → finalized`. Each hook
  * performs one whole-state transition, so stale graph state, duplicate planning, and partially reset generations are
  * unrepresentable.
  */
-export declare function createWxPlacementPlugin(): WxPlacementPlugin;
+export declare function createMiniPlacementPlugin(modules: RuntimeModulesContract): MiniPlacementPlugin;

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

@@ -0,0 +1,4 @@
+import type { PluginOption } from 'vite';
+import type { MiniContract } from './mini-contract.ts';
+/** Creates the complete Mini Program plugin set. */
+export declare function createMiniTargetPlugins(contract: MiniContract): PluginOption[];

package/dist/node/plugins/{wx → mini}/render/capsule.d.ts

@@ -1,16 +1,16 @@
 import type { Rolldown } from 'vite';
 import type { AstTransformResult } from '../../../utils/transform.ts';
 /**
- * Converts one final Rolldown ESM chunk into the inert registration consumed by the WX module runtime.
+ * Converts one final Rolldown ESM chunk into the inert registration consumed by the Mini Program module runtime.
  *
  * Why this boundary exists:
  *
  * - Rolldown produces an ESM chunk graph, but a Mini Program loads emitted JavaScript through native `require` and
  *   `require.async`; it does not provide the browser ESM loader that normally links Vite chunks.
- * - Native App, Page, and Component shells must start through WeChat's synchronous lifecycle APIs, while their application
+ * - Native App, Page, and Component shells must start through the host's synchronous lifecycle APIs, while their application
  *   graph still needs ESM linking semantics such as cycles, live exports, dynamic imports, `import.meta`, and top-level await.
  * - The plugin therefore keeps native lifecycle shells as CommonJS and executes application "capsules" through the bundled
- *   SystemJS runtime. Native shells enter that graph with `global.System.importSync`, and genuine asynchronous boundaries use
+ *   SystemJS runtime. Native shells enter that graph through the language-global `System.importSync`, and asynchronous boundaries use
  *   the same runtime through `System.import`.
  *
  * What this renderer emits:
@@ -25,12 +25,12 @@ import type { AstTransformResult } from '../../../utils/transform.ts';
  *
  * Rolldown imports name physical output files whose relative paths include placement directories and content hashes. The
  * SystemJS registry instead uses package-neutral logical chunk IDs. Canonicalizing both static and literal dynamic references
- * here lets transport independently map a stable module identity to the physical `require` path selected by WX placement.
+ * here lets transport independently map a stable module identity to the physical `require` path selected by Mini Program placement.
  * Runtime-computed dynamic IDs cannot be canonicalized and are intentionally preserved.
  *
  * This function runs on final Rolldown output rather than arbitrary source modules. `transformSystemJs` accepts only the
  * normalized final-chunk grammar required by this pipeline and fails the build on unsupported forms instead of risking a
- * partial or semantically incorrect capsule. Source maps remain optional because WX development output deliberately disables
+ * partial or semantically incorrect capsule. Source maps remain optional because Mini Program development output deliberately disables
  * them on this startup-critical path.
  */
 export declare function renderCapsule(code: string, chunk: Rolldown.RenderedChunk, sourcemap: boolean): AstTransformResult;

package/dist/node/plugins/{wx → mini}/render/native.d.ts

@@ -1,14 +1,15 @@
 import type { Rolldown } from 'vite';
 import type { AstTransformResult } from '../../../utils/transform.ts';
+import type { MiniModuleClassifier } from '../module/module.ts';
 /**
- * Materializes one final native/amphibious Rolldown chunk as executable WX CommonJS.
+ * Materializes one final native/amphibious Rolldown chunk as executable Mini Program CommonJS.
  *
  * The transform performs four semantic operations:
  *
  * 1. Static ESM imports are hoisted into source-order `require` calls. Named imports remain property reads from the required
  *    namespace so they observe current values. Default and namespace imports receive Babel-compatible CommonJS interop.
  * 2. An import whose target owns a capsule entry is not passed to native `require`. It becomes
- *    `global.System.importSync(logicalChunkId)`, synchronously linking the capsule before the native lifecycle call.
+ *    the language-global `System.importSync(logicalChunkId)`, synchronously linking the capsule before the native lifecycle call.
  * 3. Local exports are published at declaration and mutation points. Imported re-exports use getters, while assignments and
  *    updates notify every alias without changing expression completion values or accidentally matching shadowed bindings.
  * 4. ESM top-level `this` becomes `undefined`. Direct imported calls and tags are explicitly unbound so converting an import
@@ -16,12 +17,13 @@ import type { AstTransformResult } from '../../../utils/transform.ts';
  *
  * Static dependency loading is emitted before the untouched module body because ESM evaluates dependencies before body
  * statements regardless of where import declarations appear textually. Generated helper names are allocated against every
- * source identifier. Source maps use the same range edits when requested; WX development disables them and keeps this path
+ * source identifier. Source maps use the same range edits when requested; Mini Program development disables them and keeps this path
  * focused on startup latency.
  */
-export declare function renderNative({ code, chunk, chunks, sourcemap }: {
+export declare function renderNative({ code, chunk, chunks, classifyModule, sourcemap }: {
     code: string;
     chunk: Rolldown.RenderedChunk;
     chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    classifyModule: MiniModuleClassifier;
     sourcemap: boolean;
 }): AstTransformResult;

package/dist/node/plugins/{wx → mini}/render/system-js/string-editor.d.ts

@@ -1,7 +1,7 @@
 /**
  * Records non-overlapping range edits and renders them in one source-order pass.
  *
- * Final WX development chunks do not request source maps. RolldownMagicString's repeated relocation of hundreds of hoisted
+ * Final Mini Program development chunks do not request source maps. RolldownMagicString's repeated relocation of hoisted
  * functions is considerably more expensive than the semantic analysis itself, so this editor keeps the same range operations
  * while avoiding a mutable chunk graph when no mappings can be observed.
  */

package/dist/node/plugins/{wx → mini}/render/system-js/system-js.d.ts

@@ -7,7 +7,7 @@ export type TransformSystemJsOptions = Readonly<{
     filename: string;
     format: SystemJsOutputFormat;
     sourcemap: boolean;
-    /** Converts physical Rolldown references into the logical IDs used by the WX capsule registry. */
+    /** Converts physical Rolldown references into the logical IDs used by the Mini capsule registry. */
     resolveReference(reference: string, kind: SystemJsReferenceKind): string;
 }>;
 export type TransformSystemJsResult = Readonly<{

package/dist/node/plugins/{wx → mini}/render/transport.d.ts

@@ -1,5 +1,6 @@
 import type { Rolldown } from 'vite';
 import { type AstTransformResult } from '../../../utils/transform.ts';
+import type { MiniModuleClassifier } from '../module/module.ts';
 /**
  * Materializes transport while Rolldown's preliminary hash placeholders are still active. Each switch case deliberately has
  * two IDs: the package-neutral preliminary filename without its `assets/` directory becomes the SystemJS registration
@@ -11,10 +12,11 @@ import { type AstTransformResult } from '../../../utils/transform.ts';
  * chunks that import bootstrap. A Mini Program ships one application package rather than independently cached HTTP
  * chunks, so honest content hashes and automatic graph linking are more valuable than minimizing that hash fan-out.
  */
-export declare function materializeTransport({ code, transportChunk, chunks, getLoadMode, getPhysicalChunkId, sourcemap }: {
+export declare function materializeTransport({ code, transportChunk, chunks, classifyModule, getLoadMode, getPhysicalChunkId, sourcemap }: {
     code: string;
     transportChunk: Rolldown.RenderedChunk;
     chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    classifyModule: MiniModuleClassifier;
     getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
     getPhysicalChunkId?: (chunk: Rolldown.RenderedChunk) => string;
     sourcemap?: boolean;

package/dist/node/plugins/{wx → mini}/resolve/resolver.d.ts

@@ -1,6 +1,6 @@
-import type { VptOptions } from '../../../../options.ts';
-/** Creates the resolver and source specializer for the wx module graph. */
-export declare function createResolver(options: VptOptions): {
+import type { MiniContract } from '../mini-contract.ts';
+/** Creates the resolver and source specializer for one Mini Program module graph. */
+export declare function createResolver(contract: Pick<MiniContract, 'options' | 'runtime' | 'taro'>): {
     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 → mini}/resolve/specialize-app-capsule.d.ts

@@ -1,9 +1,9 @@
-import type { VptJsonObject } from '../../../../options.ts';
 import { type AstTransformResult } from '../../../utils/transform.ts';
+import type { MiniJsonObject } from '../mini-contract.ts';
 /** Specializes the App capsule with its normalized native configuration. */
 export declare function specializeAppCapsule({ code, id, appConfig, sourcemap }: {
     code: string;
     id: string;
-    appConfig: VptJsonObject;
+    appConfig: MiniJsonObject;
     sourcemap?: boolean;
 }): Promise<AstTransformResult>;

package/dist/node/plugins/{wx → mini}/resolve/specialize-page-capsule.d.ts

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