vite-plugin-taro 0.6.20 → 0.7.0

package/dist/node/plugins/mini/skeleton/skeleton-utils.d.ts

@@ -0,0 +1,33 @@
+import type { Rolldown } from 'vite';
+import type { VptOptions } from '../../../../options.ts';
+import type { MiniJsonObject, MiniNativeComponentRegistration, MiniPage } from '../mini-contract.ts';
+/** Component-selection input accepted by each pinned native template implementation. */
+export type SkeletonTemplateComponentConfig = {
+    includes: Set<string>;
+    exclude: Set<string>;
+    thirdPartyComponents: Map<string, Set<string>>;
+    includeAll: boolean;
+};
+/** Native registrations shared by Page, recursive-component, and CustomWrapper configuration. */
+export type SkeletonNativeComponentConfig = {
+    usingComponents: Record<string, string>;
+    componentPlaceholder: Record<string, string>;
+};
+/** Creates application configuration with generated package declarations appended by the target skeleton. */
+export declare function createSkeletonAppJson(options: VptOptions, subpackages: readonly MiniJsonObject[]): MiniJsonObject;
+/** Creates a Page config while preserving caller fields and registering every generated rendering boundary. */
+export declare function createSkeletonPageJson(page: MiniPage, nativeComponents: SkeletonNativeComponentConfig): MiniJsonObject;
+/** Creates the recursive component config shared by comp and CustomWrapper. */
+export declare function createRecursiveComponentJson(nativeComponents: SkeletonNativeComponentConfig): MiniJsonObject;
+/** Creates native registrations and asynchronous-package placeholders from discovered component interfaces. */
+export declare function createNativeComponentConfig(nativeComponents: readonly MiniNativeComponentRegistration[]): SkeletonNativeComponentConfig;
+/** Collects reachable host exports and native JSX fields for one native template implementation. */
+export declare function collectTemplateComponentConfig(bundle: Rolldown.OutputBundle, componentsModulePath: string, nativeComponents: readonly MiniNativeComponentRegistration[]): SkeletonTemplateComponentConfig;
+/** Creates compact production JSON and readable development JSON. */
+export declare function createJsonAsset(fileName: string, value: MiniJsonObject, isProduction: boolean): Rolldown.EmittedAsset;
+/** Creates one emitted text asset. */
+export declare function createTextAsset(fileName: string, source: string): Rolldown.EmittedAsset;
+/** Replaces one pinned upstream fragment and rejects absent or duplicated source contracts. */
+export declare function replaceExactlyOnce(source: string, current: string, replacement: string, description: string): string;
+/** Creates a Page-relative path to a file emitted at the Mini Program output root. */
+export declare function toRootRelativePath(pagePath: string, rootFileName: string): string;

package/dist/node/plugins/{wx/styles/create-wx-transformer.d.ts → mini/styles/create-mini-transformer.d.ts}

@@ -3,10 +3,10 @@ type JavaScriptTransformInput = Readonly<{
     code: string;
     filename: string;
 }>;
-type WxTransformer = Readonly<{
+type MiniTransformer = Readonly<{
     transformJavaScript: (input: JavaScriptTransformInput) => string;
     transformStylesheet: (css: string) => Promise<string>;
 }>;
-/** Creates VPT's fixed Tailwind-v4/WX transformer without loading Weapp's generic framework context. */
-export declare function createWxTransformer(): WxTransformer;
+/** Creates VPT's fixed Tailwind-v4 Mini Program transformer without loading a framework project context. */
+export declare function createMiniTransformer(): MiniTransformer;
 export {};

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

@@ -1,25 +1,26 @@
 import { type Plugin } from 'vite';
-import { createWxTransformer } from './create-wx-transformer.ts';
-/** JavaScript code plus the physical filename required by the WX JavaScript transformer. */
+import type { MiniContract } from '../mini-contract.ts';
+import { createMiniTransformer } from './create-mini-transformer.ts';
+/** JavaScript code plus the physical filename required by the Mini Program class-name transformer. */
 type JavaScriptArtifact = Readonly<{
     code: string;
     filename: string;
 }>;
-type WxTransformer = ReturnType<typeof createWxTransformer>;
-/** Vite plugin with the development-host operation that finalizes one coherent WX style/JavaScript transaction. */
-export type WxStylePlugin = Plugin & Readonly<{
-    /** Neutralizes browser CSS payloads and publishes their matching global WXSS through the host's atomic writer. */
-    finalizeUpdate: <Artifact extends JavaScriptArtifact>(artifacts: readonly Artifact[], writeWxss: (wxss: string) => Promise<void>) => Promise<readonly Artifact[]>;
+type MiniTransformer = ReturnType<typeof createMiniTransformer>;
+/** Vite plugin with the host operation that finalizes one coherent native-style/JavaScript transaction. */
+export type MiniStylePlugin = Plugin & Readonly<{
+    /** Neutralizes browser CSS payloads and atomically publishes the matching global native stylesheet. */
+    finalizeUpdate: <Artifact extends JavaScriptArtifact>(artifacts: readonly Artifact[], writeStylesheet: (stylesheet: string) => Promise<void>) => Promise<readonly Artifact[]>;
 }>;
 /**
- * Creates the single owner of global WX style compilation, graph projection, JavaScript class rewriting, and publication.
+ * Creates the single owner of global native-style compilation, graph projection, class rewriting, and publication.
  *
  * ## Architectural invariant
  *
- * A WX transaction must expose JavaScript and WXSS produced from one class-identity snapshot. Tailwind utility names can be
- * rewritten for WeChat—for example, `py-5.5` becomes `py-5_d5`—so publishing either side independently can leave running code
+ * One Mini Program transaction must expose JavaScript and native CSS produced from one class-identity snapshot. Tailwind utility
+ * names can be escaped—for example, `py-5.5` becomes `py-5_d5`—so publishing either side independently can leave running code
  * referring to selectors that do not yet exist. This plugin therefore treats reachable CSS, Tailwind candidates, converted
- * WXSS, and converted JavaScript as one output. Complete builds and HMR updates both call `finalizeOutput()`; they differ only
+ * native CSS, and converted JavaScript as one output. Complete builds and HMR updates both call `finalizeOutput()`; they differ only
  * in how the returned bytes are materialized.
  *
  * ## Ownership boundaries
@@ -32,13 +33,13 @@ export type WxStylePlugin = Plugin & Readonly<{
  *    the owning CSS root's Rolldown transform and never rescans the project during output publication.
  * 3. Vite owns preprocessors, PostCSS, CSS Modules, and final module CSS semantics. VPT observes the input to the resolved
  *    `vite:css-post` hook only after the original hook succeeds; it never rereads source files or repeats CSS preprocessing.
- * 4. The fixed WX transformer owns selector conversion and Oxc-based JavaScript class-string conversion. One retained
- *    transformer and one projected candidate set drive both operations without loading Weapp's generic framework context.
- * 5. VPT owns physical global WXSS and patch publication. Vite's browser CSS asset is only an intermediate carrier and is
- *    removed before VPT emits `assets/global.wxss`.
+ * 4. The fixed Mini transformer owns selector conversion and Oxc-based JavaScript class-string conversion. One retained
+ *    transformer and one projected candidate set drive both operations without loading a framework project context.
+ * 5. VPT owns physical global native CSS and patch publication. Vite's browser CSS asset is only an intermediate carrier and is
+ *    removed before VPT emits the contract-selected global stylesheet.
  *
- * Native Page and component WXSS are outside this global pipeline. The WX output plugin is registered after this style plugin
- * and emits those opaque companions later. The WX configuration also enforces `cssCodeSplit: false`, so Vite contributes at
+ * Native Page and component styles are outside this global pipeline. The target skeleton is generated after this style plugin
+ * and emits those opaque companions later. Mini output also enforces `cssCodeSplit: false`, so Vite contributes at
  * most one browser compiler stylesheet for this plugin to replace.
  *
  * ## Compilation phases
@@ -74,9 +75,9 @@ export type WxStylePlugin = Plugin & Readonly<{
  * and Tailwind candidates without a separate prune protocol or persistent topology cache. Candidate sets are unioned only from
  * the Tailwind roots whose captured CSS survives that exact traversal, preserving the CSS/class identity invariant.
  *
- * ### 4. Shared WX finalization
+ * ### 4. Shared native-style finalization
  *
- * `finalizeOutput()` first converts the concatenated reachable CSS to WXSS, then transforms every supplied JavaScript artifact
+ * `finalizeOutput()` first converts the concatenated reachable CSS to native CSS, then transforms each JavaScript artifact
  * with the same projected class set. It returns data and performs no bundle mutation or filesystem publication. If either
  * transformation fails, the promise rejects before callers expose partial output. JavaScript conversion is skipped when the
  * projection contains no Tailwind candidates, preserving ordinary bundle bytes.
@@ -85,18 +86,17 @@ export type WxStylePlugin = Plugin & Readonly<{
  *
  * The post-order `generateBundle` hook gathers all JavaScript chunks, finalizes them as one operation, and only then mutates the
  * bundle. It assigns converted code, clears invalid source maps, removes Vite's intermediate browser stylesheet, and always
- * emits `assets/global.wxss`. Emitting an empty global file is required because `app.wxss` imports it even when the application
+ * emits the contract-selected global file. An empty file is required because the App stylesheet imports it even when the application
  * currently has no styles. Native output hooks run afterward and emit Page/component companion files independently.
  *
  * ### 5b. Development commit
  *
  * The development host calls `finalizeUpdate()` after Rolldown produces patch factories or a complete-output notification.
  * Finalization uses the `PluginContext` captured by `buildStart`, so it observes the same current graph as the compiler. After
- * all conversion succeeds, the host's atomic writer publishes changed WXSS before `finalizeUpdate()` returns converted patch
- * factories. Their captured Vite CSS literals are emptied first; factories, exports, changed IDs, and sequences remain intact.
- * The patch publisher therefore cannot expose newer JavaScript class identities before matching selectors exist.
- * `publishedWxss` advances only after a successful write and suppresses byte-identical writes that would otherwise trigger
- * unnecessary WeChat DevTools reload events.
+ * all conversion succeeds, the host's atomic writer publishes changed native CSS before `finalizeUpdate()` returns converted
+ * patch factories. Their captured Vite CSS literals are emptied first; factories, exports, changed IDs, and sequences remain
+ * intact. The patch publisher therefore cannot expose newer JavaScript class identities before matching selectors exist.
+ * `publishedStylesheet` advances only after a successful write and suppresses byte-identical native-tool reload events.
  *
  * ## Retained state and lifecycle
  *
@@ -105,8 +105,8 @@ export type WxStylePlugin = Plugin & Readonly<{
  * - `entryIds`: graph-exact App/Page entry identities resolved at the start of each build;
  * - `graphContext`: the active Rolldown graph reader needed by host calls made outside plugin hooks;
  * - `styleByModuleId`: the latest successful Vite CSS plus optional Tailwind state at one normalized module identity;
- * - `publishedWxss`: the last durably published development stylesheet used for unchanged-write suppression;
- * - `wxTransformer`: fixed stylesheet options and escaped-class cache shared by CSS and JavaScript conversion.
+ * - `publishedStylesheet`: the last durably published development stylesheet used for unchanged-write suppression;
+ * - `miniTransformer`: fixed stylesheet options and escaped-class cache shared by CSS and JavaScript conversion.
  *
  * The state owners remain scoped to one plugin instance; `entryIds` is atomically replaced after each complete resolution.
  * A development watcher retains them across updates; build and watcher shutdown clear the complete style store.
@@ -120,12 +120,12 @@ export type WxStylePlugin = Plugin & Readonly<{
  * compiler dependencies, and watched file identities; no second application graph is retained. The Tailwind generator stays
  * alive across candidate edits to avoid repeating source normalization and compiler initialization.
  */
-export declare function createWxStylePlugin(applicationEntryIds: readonly string[]): WxStylePlugin;
+export declare function createMiniStylePlugin(contract: Pick<MiniContract, 'styles'>, applicationEntryIds: readonly string[]): MiniStylePlugin;
 /**
- * Produces WXSS and JavaScript from one live-graph projection.
+ * Produces native CSS and JavaScript from one live-graph projection.
  *
  * The function receives every stateful dependency explicitly so tests and both output modes execute the same algorithm. It
- * completes WXSS conversion before JavaScript conversion and returns bytes without publishing or mutating caller artifacts.
+ * completes stylesheet conversion before JavaScript conversion and returns bytes without publishing or mutating caller artifacts.
  */
 export declare function finalizeOutput(entryIds: readonly string[], styleByModuleId: ReadonlyMap<string, Readonly<{
     css: string | undefined;
@@ -135,8 +135,8 @@ export declare function finalizeOutput(entryIds: readonly string[], styleByModul
 }>>, getModuleInfo: (moduleId: string) => Readonly<{
     importedIds: readonly string[];
     dynamicallyImportedIds: readonly string[];
-}> | null | undefined, wxTransformer: WxTransformer, javaScript: readonly JavaScriptArtifact[]): Promise<{
+}> | null | undefined, miniTransformer: MiniTransformer, javaScript: readonly JavaScriptArtifact[]): Promise<{
     javaScript: string[];
-    wxss: string;
+    stylesheet: string;
 }>;
 export {};

package/dist/node/plugins/wx/create-wx-skeleton.d.ts

@@ -0,0 +1,57 @@
+import type { Rolldown } from 'vite';
+import type { VptOptions } from '../../../options.ts';
+import type { MiniProjectSkeletonInput } from '../mini/mini-contract.ts';
+type WxSkeletonInput = MiniProjectSkeletonInput & Readonly<{
+    options: VptOptions;
+    componentsModulePath: string;
+}>;
+/**
+ * Generates the WX templates that project one React ownership tree through two native Page data roots.
+ *
+ * ## Data ownership
+ *
+ * Each native Page starts with `app = { nn: 'vpt_fragment', cn: [] }` and `page = { cn: [] }`. The patched App document broadcasts
+ * compact App mutations under `app.*`; the Page root writes only `page.*`. React still owns one tree from the App component,
+ * through its `children`, to the independently scheduled Page root. Native templates join those projections only where React
+ * placed `vpt_page_outlet`, so context, lifecycle, refs, events, effects, removal, and HMR ownership remain in memory rather than
+ * being serialized from one root into the other.
+ *
+ * ## Template execution
+ *
+ * ```text
+ * Page WXML (owns app, page, Page event handler, and Page light DOM)
+ *   -> <comp i="{{app}}">                    crosses into the recursive component scope
+ *      -> comp.wxml imports base.wxml         owns App event dispatch and named-template lookup
+ *         -> tmpl_0_vpt_fragment              iterates the real compact roots in app.cn
+ *            -> stock host templates          recursively render each App branch
+ *               -> depth-reset <comp>         forwards light DOM only on the marked outlet spine
+ *                  -> tmpl_0_vpt_page_outlet  consumes the forwarded default slot
+ *                     -> taro_tmpl(page)       renders this Page's page.cn in caller scope
+ * ```
+ *
+ * `vpt_fragment` adapts zero, one, or many App roots to `comp`'s one-node `i` contract. It is template-only: it has no Fiber, sid,
+ * event source, ref, lifecycle, or native layout. Its `cn` entries remain real Taro compact nodes, and `wx:key="sid"` preserves
+ * native component instances, sibling identity, and event routing during insertion and reorder. The outer `comp` exists once, so
+ * exactly one Page slot is owned regardless of App root cardinality.
+ *
+ * ## Scope and slot forwarding
+ *
+ * WXML slots transfer caller-owned light DOM but not the caller's named-template table or WXS module scope. App dispatch occurs
+ * after entering `comp.wxml`; therefore `vpt_fragment` and `vpt_page_outlet` must be defined in shared `base.wxml`, which every
+ * recursive component imports. Defining them only in Page WXML can compile but fails when component-local dispatch cannot resolve
+ * the names. `utils.wxs`, `comp.wxml`, and CustomWrapper otherwise remain Taro's stock products.
+ *
+ * Taro resets recursion depth through nested `comp` components. The renderer marks only the outlet-to-App-root compact ancestor
+ * spine with `vo`; each generated depth-reset call checks that local marker before forwarding `<slot>`. This is O(1) per boundary,
+ * requires no descendant search or App/Page mode property, and prevents unrelated App branches from instantiating Page content.
+ * App events continue through `comp.eh`; slotted Page events retain the native Page's handler and original sid source.
+ *
+ * ## Updates and navigation
+ *
+ * A `page.*` update changes only caller-owned Page rendering because `app` is never passed into `taro_tmpl(page)`. App updates and
+ * outlet-spine marker changes remain granular `app.*` payloads broadcast before mounted Pages render them. Adding or removing a
+ * Page root mutates the in-memory outlet but does not serialize that root into App data. A newly pushed native Page receives the
+ * current complete App snapshot with its initial Page batch; retained and hidden Pages need no navigation synchronization.
+ */
+export declare function createWxSkeleton({ bundle, subpackages, nativeComponents, isProduction, options, componentsModulePath }: WxSkeletonInput): Rolldown.EmittedAsset[];
+export {};

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

@@ -1,4 +1,7 @@
 import type { PluginOption } from 'vite';
 import type { VptOptions } from '../../../options.ts';
-/** Creates the complete plugin set for the wx target. */
-export declare function createWxTargetPlugins(options: VptOptions): PluginOption[];
+import type { MiniContract } from '../mini/mini-contract.ts';
+/** Adapts the shared Mini Program pipeline to the WX public target. */
+export declare function createWxMiniPlugins(vptOptions: VptOptions): PluginOption[];
+/** Binds the shared Mini Program core to WeChat runtime and output conventions. */
+export declare function createWxMiniContract(vptOptions: VptOptions): MiniContract;

package/dist/node/plugins/zfb/create-zfb-skeleton.d.ts

@@ -0,0 +1,59 @@
+import type { Rolldown } from 'vite';
+import type { VptOptions } from '../../../options.ts';
+import type { MiniProjectSkeletonInput } from '../mini/mini-contract.ts';
+type ZfbSkeletonInput = MiniProjectSkeletonInput & Readonly<{
+    options: VptOptions;
+    componentsModulePath: string;
+}>;
+/**
+ * Generates the Alipay templates that project one React ownership tree through two independent native Page data roots.
+ *
+ * ## Native data ownership
+ *
+ * Every native Page owns `app`, the latest singleton App projection, and `page`, that Page instance's compact React root. The App
+ * document broadcasts granular `app.*` payloads to mounted Pages while each Page writes only `page.*`. The two projections meet
+ * at `vpt_page_outlet`; the Page Fiber remains beneath App `children` in React memory for context, lifecycle, refs, effects,
+ * removal, and HMR, but Page compact nodes never enter the App payload.
+ *
+ * ## AXML execution
+ *
+ * ```text
+ * Page AXML (owns app, page, and optional page-meta)
+ *   -> <comp i="{{app}}" p="{{page}}">       crosses both roots into one recursive component scope
+ *      -> comp.axml imports base.axml         owns named-template lookup and event dispatch
+ *         -> tmpl_0_vpt_fragment(i, p)        iterates the real compact App roots
+ *            -> stock templates(i, p)         recursively render App descendants while forwarding p
+ *               -> tmpl_0_vpt_page_outlet(p)
+ *                  -> taro_tmpl(root: p)       renders this Page's compact children at the exact outlet
+ * ```
+ *
+ * Alipay supports recursive named-template calls, so both trees stay inside one `comp` instance and need neither WX's depth-reset
+ * components nor a second Page-renderer component. `vpt_fragment` adapts zero, one, or many App roots to `comp`'s one-node `i`
+ * contract. It has no Fiber, sid, event source, ref, lifecycle, or native layout; only its real `cn` entries are keyed by sid.
+ * The outlet is equally transparent and adds no native layout node.
+ *
+ * Every named `<template>` receives a fresh explicit `data` object. Consequently `p` must be copied through each App recursion
+ * edge even though no stock host template reads it; otherwise the outlet can see `i` but not the Page root. The ordinary `p`
+ * component attribute also avoids Alipay's slot-wrapper trap: a named template reached through an imported recursive table is
+ * represented as another template component, which creates a fresh slot collection and loses the outer component's default slot.
+ * Passing Page data directly preserves the required location without duplicating the Page tree or rendering it beside the App.
+ *
+ * ## Why the Page has no base import
+ *
+ * Taro 4.2.1 removes `base.axml` imports from Alipay Pages that register custom components. Every VPT Page registers `comp`, so its
+ * AXML contains only optional PageMeta output and the `comp` bridge. The Page does not need an inlined copy either: `comp.axml` may
+ * import the shared table legally, and that table renders both `i` and `p`. This keeps each Page small, gives every named template
+ * one `utils.sjs` binding, and follows Taro's platform restriction without inventing a Page renderer.
+ *
+ * Both App and Page host events execute through `comp.eh` and resolve the original sid in Taro's shared event source. A `page.*`
+ * update changes only the `p` property; an `app.*` update changes only `i`. Newly pushed Pages receive the current complete App
+ * snapshot with their initial Page batch, while retained Pages require no navigation synchronization.
+ *
+ * Generated subpackages contain asynchronously loaded code rather than native routes. Alipay requires the `pages` field in each
+ * declaration, but accepts an empty array and still packages the files beneath that root. Keeping `pages: []` preserves the real
+ * model: no synthetic Page, native lifecycle, route, or template exists merely to make code eligible for asynchronous loading.
+ */
+export declare function createZfbSkeleton({ bundle, subpackages, nativeComponents, isProduction, options, componentsModulePath }: ZfbSkeletonInput): Rolldown.EmittedAsset[];
+/** Adds Alipay's transparent App collection and threads the independent Page root through every recursive data scope. */
+export declare function buildZfbBaseTemplate(source: string): string;
+export {};

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

@@ -0,0 +1,7 @@
+import type { PluginOption } from 'vite';
+import type { VptOptions } from '../../../options.ts';
+import type { MiniContract } from '../mini/mini-contract.ts';
+/** Adapts the shared Mini Program pipeline to the zfb public target. */
+export declare function createZfbMiniPlugins(vptOptions: VptOptions): PluginOption[];
+/** Binds the shared Mini Program core to Alipay runtime and output conventions. */
+export declare function createZfbMiniContract(vptOptions: VptOptions): MiniContract;

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

@@ -12,6 +12,8 @@ export declare function resolveAppComponentPath({ appPath, projectRoot }: AppCom
 export declare function resolvePageComponentPath({ pagePath, projectRoot }: PageComponentPathOptions): string;
 /** Creates a portable import for one configured Page component. */
 export declare function createPageComponentImportPath(options: PageComponentPathOptions): string;
+/** Creates an exact normalized module-ID filter while admitting Vite query parameters. */
+export declare function createExactModuleIdFilter(moduleId: string): RegExp;
 /** Converts a file-backed Vite request ID to its normalized physical path for stable comparisons. */
 export declare function normalizeModuleId(id: string): string;
 /** Converts a local file path into Vite's portable file-system import form. */

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

@@ -1,3 +1,5 @@
-import type { VptJsonObject, VptOptions } from '../../options.ts';
+import type { VptJsonObject, VptOptions, VptPageConfig, VptPageOption } from '../../options.ts';
+/** Resolves an omitted Page configuration to its empty native representation. */
+export declare function getPageConfig(page: VptPageOption): VptPageConfig;
 /** Creates shared App configuration with configured Page order as the authoritative value. */
 export declare function createAppConfig(options: VptOptions): VptJsonObject;

package/dist/options.d.ts

@@ -1,11 +1,22 @@
-/** A JSON object used by generated target configs. */
-export type VptJsonObject = Record<string, unknown>;
+/** One immutable JSON value accepted by generated target configuration files. */
+export type VptJsonValue = string | number | boolean | null | VptJsonObject | readonly VptJsonValue[];
+/** An immutable JSON object accepted by vpt configuration. */
+export interface VptJsonObject {
+    readonly [key: string]: VptJsonValue | undefined;
+}
+/** Application configuration written in the selected target's native schema. */
+export type VptAppConfig = VptJsonObject;
+/** Page configuration written in the selected target's native schema. */
+export type VptPageConfig = VptJsonObject;
 /** Build target handled by this plugin. */
-export type VptTarget = 'wx' | 'h5';
-/** Selects one implemented WX development HMR delivery and execution mechanism. */
+export type VptTarget = 'wx' | 'zfb' | 'h5';
+/** Selects one implemented Mini Program development update mechanism. */
 export type VptHmrOptions = Readonly<{
-    /** `devtools` executes native patch files; `interpreter` fetches source and evaluates it without native Page reload. */
-    mode: 'devtools' | 'interpreter';
+    /**
+     * `devtools` executes native patch files; `interpreter` evaluates pushed source without native Page reload; `rebuild`
+     * replaces the complete native output after every valid source change.
+     */
+    mode: 'devtools' | 'interpreter' | 'rebuild';
 }>;
 /** Configures one Taro page. */
 export type VptPageOption = {
@@ -13,24 +24,26 @@ export type VptPageOption = {
      * Taro route and output path without a file extension.
      *
      * The plugin resolves the page component from `src/${path}.tsx`, relative to the Vite project root. For example,
-     * `pages/home/index` resolves to `src/pages/home/index.tsx` and is emitted under `pages/home/index` for `wx`.
+     * `pages/home/index` resolves to `src/pages/home/index.tsx` and keeps that output route for every target.
      */
     path: string;
     /**
-     * Target-independent Taro page configuration.
+     * Optional native Page configuration for the selected target.
      *
-     * For `wx`, these values form the generated `<path>.json`; the plugin augments `usingComponents` with its generated
-     * component registrations. For `h5`, the values are added to the corresponding Taro router entry.
+     * Use Taro/WeChat keys for WX and H5, and Alipay keys for ZFB. The plugin preserves these fields in the Page runtime capsule
+     * and `<path>.json`, adding generated native-component registrations separately. It does not translate configuration names
+     * between platforms.
      */
-    config: VptJsonObject;
+    config?: VptPageConfig;
 };
 /** Configures vpt for one build target. */
 export interface VptOptions {
     /**
      * Platform produced by the current Vite invocation.
      *
-     * Use `wx` to emit a WeChat Mini Program or `h5` to emit a browser application. The selected target controls Taro
-     * module resolution, conditional compilation, runtime bootstrapping, style processing, and output generation.
+     * Use `wx` to emit a WeChat Mini Program, `zfb` to emit an Alipay Mini Program, or `h5` to emit a browser application.
+     * The selected target controls Taro module resolution, conditional compilation, runtime bootstrapping, style processing,
+     * and output generation.
      */
     target: VptTarget;
     /**
@@ -48,36 +61,41 @@ export interface VptOptions {
      */
     pages: VptPageOption[];
     /**
-     * Target-independent Taro application configuration.
+     * Native application configuration for the selected target.
      *
-     * For `wx`, these values form the generated `app.json`. For `h5`, they configure the Taro application and router.
-     * The plugin always derives `pages` from {@link pages}; caller-provided `pages`, `subPackages`, and `subpackages`
-     * values are discarded because the build pipeline owns page order and generated package placement.
+     * Use Taro/WeChat keys for WX and H5, and Alipay keys for ZFB. The plugin otherwise preserves the supplied configuration for
+     * runtime specialization and `app.json`; it does not translate configuration names between platforms. The plugin always
+     * derives `pages` from {@link pages}; caller-provided `pages`, `subPackages`, and `subpackages` values are discarded because
+     * the build pipeline owns page order and generated package placement.
      */
-    appJson: VptJsonObject;
+    appJson: VptAppConfig;
     /**
-     * WeChat DevTools project configuration written to `project.config.json` without merging.
+     * Native development-tool project configuration written without merging.
      *
-     * This option is required so one configuration shape can be shared between targets, but it is only emitted for a
-     * `wx` build and is ignored for `h5`.
+     * WX emits this object as `project.config.json`; ZFB emits it as `mini.project.json`; H5 ignores it. Supply the schema
+     * expected by the selected target rather than sharing one project's platform-specific values across invocations. ZFB must
+     * use format 2 with `compileOptions.globalObjectMode: 'enable'` because the upstream Taro runtime reads the platform `global`;
+     * its Taro-style ES6 output also relies on `compileOptions.transpile` for the developer tool's final syntax conversion.
      */
     projectConfigJson: VptJsonObject;
     /**
-     * Local WeChat DevTools overrides written to `project.private.config.json` without merging.
+     * Local development-tool preferences written without merging.
      *
-     * The file is emitted only when this value is provided for a `wx` build. It is ignored for `h5`.
+     * WX emits this object as `project.private.config.json`; ZFB emits it as `.mini-ide/project-ide.json`; H5 ignores it.
+     * These files control local IDE behavior rather than portable application metadata. In particular, the ZFB file does not
+     * associate the project with an Alipay App ID; Alipay Mini Program Studio keeps that selection in its workspace storage.
      */
     projectPrivateConfigJson?: VptJsonObject;
     /**
      * WeChat Mini Program indexing rules written to `sitemap.json` without merging.
      *
-     * The file is emitted only when this value is provided for a `wx` build. It is ignored for `h5`.
+     * The file is emitted only when this value is provided for a `wx` build. It is ignored for ZFB and H5.
      */
     sitemapJson?: VptJsonObject;
     /**
-     * Selects the WX development HMR mode. Omission uses `devtools`.
+     * Selects the Mini Program development update mode. Omission uses `devtools`.
      *
-     * This option affects only `vite serve` for the `wx` target and never changes H5 or production output.
+     * This option affects only `vite serve` for `wx` and `zfb` targets and never changes H5 or production output.
      */
     hmr?: VptHmrOptions;
 }

package/dist/runtime/{wx → mini}/amphibious/bootstrap.js

@@ -1,13 +1,13 @@
 // Install the minimal SystemJS loader and its synchronous-import extension before any native entry requests a capsule.
 import '../systemjs/system-core.js';
 import { transport } from './transport.js';
-// WX has no modulepreload transport. Genuine application import() boundaries retain System.import() and may load
+// Mini Program hosts have no modulepreload transport. Application import() boundaries retain System.import() and may load
 // asynchronous subpackage or top-level-await graphs through this identity wrapper.
 export const __vitePreload = (load) => load();
-// SystemJS installs on WeChat's `global` object; its properties are not lexical bindings.
-const installedSystem = global.System;
+// SystemJS installs on the language global before this dependent module evaluates.
+const installedSystem = globalThis.System;
 if (!installedSystem) {
-    throw new Error('SystemJS failed to initialize in the WeChat runtime');
+    throw new Error('SystemJS failed to initialize in the Mini Program runtime');
 }
 // Transport returns synchronous registrations for main-package capsules and amphibious modules, and promise-like
 // registrations only for capsules that physically live in generated subpackages.

package/dist/runtime/{wx → mini}/capsule/app.js

@@ -1,7 +1,7 @@
 // biome-ignore assist/source/organizeImports: Taro must initialize before the App component.
 import { createReactApp, ReactDOM } from './taro-runtime.js';
 import React from 'react';
-// @ts-expect-error: The wx build resolves this private App component.
+// @ts-expect-error: The active Mini contract resolves this private App component.
 import AppComponent from '\0vpt:app-component';
 const config = createReactApp(AppComponent, React, ReactDOM, __VPT_APP_CONFIG__);
 export default config;

package/dist/runtime/mini/capsule/page.js

@@ -0,0 +1,18 @@
+// App and Page shells activate independently; make Current.app initialization an explicit prerequisite for Page mount.
+import './app.js';
+// @ts-expect-error: The Mini Program build replaces this private import with the configured Page component.
+import PageComponent from '\0vpt:page-component';
+import { createPageConfig } from './taro-runtime.js';
+/*
+ * Generated Page templates invoke Taro's unchanged recursive component, whose input is one compact node selected by i.nn.
+ * App JSX does not have that cardinality: it may return one or many top-level hosts, and the private Page outlet may occur at
+ * any depth within them. vpt_fragment is therefore a native-template-only collection adapter. Its fixed nn selects a transparent
+ * template that iterates cn while one surrounding component owns the Page-content boundary. Runtime projection markers relay
+ * that content only through the App branch containing the outlet. Without the fragment, each App root would need a separate
+ * recursive component and potential Page-content copy, or the component would need an App-specific collection mode.
+ *
+ * This record is not a Taro host: it has no Fiber, event source, ref, lifecycle, native element, or keyed parent collection.
+ * It consequently needs no sid. Only cn is seeded and updated; nn remains the stable generic-template discriminator.
+ */
+const config = createPageConfig(PageComponent, __VPT_PAGE_PATH__, { app: { nn: 'vpt_fragment', cn: [] }, page: { cn: [] } }, __VPT_PAGE_CONFIG__);
+export default config;

package/dist/runtime/{wx → mini}/capsule/taro-runtime.d.ts

@@ -1,6 +1,6 @@
-/** biome-ignore-all assist/source/organizeImports: keep side effect orders */
+/** biome-ignore-all assist/source/organizeImports: keep side effect order */
 /** Taro runtime exports shared by the App, Page, and generated recursive component capsules. */
-import '@tarojs/plugin-platform-weapp/dist/runtime.js';
+import '\0vpt:taro-platform-runtime';
 export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
 export { default as ReactDOM } from '@tarojs/react';
 export { createPageConfig, createRecursiveComponentConfig } from '@tarojs/runtime';

package/dist/runtime/{wx → mini}/capsule/taro-runtime.js

@@ -1,11 +1,12 @@
-/** biome-ignore-all assist/source/organizeImports: keep side effect orders */
+/** biome-ignore-all assist/source/organizeImports: keep side effect order */
 /** Taro runtime exports shared by the App, Page, and generated recursive component capsules. */
-import '@tarojs/plugin-platform-weapp/dist/runtime.js';
+// @ts-expect-error: The active Mini contract resolves its Taro platform initialization module.
+import '\0vpt:taro-platform-runtime';
 export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
 export { default as ReactDOM } from '@tarojs/react';
 export { createPageConfig, createRecursiveComponentConfig } from '@tarojs/runtime';
 import { customWrapperCache } from '@tarojs/runtime';
-// DevTools HMR runs in the bootstrap chunk, so publish the application graph's cache once on their shared App global.
+// DevTools HMR runs in the bootstrap chunk, so publish the application graph's cache once on the language global.
 if (process.env.NODE_ENV === 'development') {
-    Reflect.set(global, Symbol.for('customWrapperCache'), customWrapperCache);
+    Reflect.set(globalThis, Symbol.for('customWrapperCache'), customWrapperCache);
 }

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

@@ -1,7 +1,7 @@
 /** Host-to-App terminal control over the App heap's authenticated Vite socket. */
-export declare const runtimeControlEvent = "vpt:wx-hmr:control";
+export declare const runtimeControlEvent = "vpt:mini-hmr:control";
 /** App-to-host application frontier and rebuild reports over the same socket. */
-export declare const runtimeReportEvent = "vpt:wx-hmr:report";
+export declare const runtimeReportEvent = "vpt:mini-hmr:report";
 /** Build identity and authenticated socket endpoint fixed for one App heap. */
 export type HmrInfo = Readonly<{
     buildId: string;

package/dist/runtime/{wx/dev/wx-hmr-protocol.js → mini/dev/hmr-protocol.js}

@@ -1,4 +1,4 @@
 /** Host-to-App terminal control over the App heap's authenticated Vite socket. */
-export const runtimeControlEvent = 'vpt:wx-hmr:control';
+export const runtimeControlEvent = 'vpt:mini-hmr:control';
 /** App-to-host application frontier and rebuild reports over the same socket. */
-export const runtimeReportEvent = 'vpt:wx-hmr:report';
+export const runtimeReportEvent = 'vpt:mini-hmr:report';