vite-plugin-taro 0.7.4 → 0.7.5-beta.0

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

@@ -10,5 +10,5 @@ export declare function createModuleResolver(options: VptOptions): {
         id: string;
         projectRoot: string;
         sourcemap?: boolean;
-    }): Promise<import("../../../utils/transform.ts").AstTransformResult> | undefined;
+    }): import("../../../utils/transform.ts").AstTransformResult | undefined;
 };

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

@@ -1,10 +1,10 @@
 import type { VptOptions } from '../../../options.ts';
 import { type AstTransformResult } from '../../utils/transform.ts';
-/** Specializes the physical H5 App for one configured project. */
+/** Specializes only the reserved expressions in VPT's physical H5 App; Vite lowers its TypeScript once afterward. */
 export declare function transformH5App({ code, id, options, projectRoot, sourcemap }: {
     code: string;
     id: string;
     options: VptOptions;
     projectRoot: string;
     sourcemap?: boolean;
-}): Promise<AstTransformResult>;
+}): AstTransformResult;

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

@@ -18,6 +18,7 @@ export declare function renderInitialDevtoolsPatches(): string;
  * DevTools re-executes a live Page because this physical dependency changed. The Page banner passes the exported payload to the
  * persistent App runtime before importing its capsule. Keeping the module inert—rather than applying factories at top level—
  * makes that ordering explicit, lets the runtime reject stale build IDs, and makes replay by several live Pages safe.
+ * The caller-supplied parameter binds every generated runtime reference, including closures retained for lazy modules.
  */
 export declare function renderDevtoolsPatches(buildId: string, patches: readonly PatchUpdate[]): string;
 /**

package/dist/node/plugins/mini/dev/react-refresh.d.ts

@@ -2,13 +2,13 @@ import { type Plugin } from 'vite';
 /**
  * Installs the missing HTML preamble inside the Refresh runtime. Boundary modules import that runtime before evaluating
  * their preamble guards, including during incremental updates. Reconciler also imports it before registering its renderer.
- * The shared Rolldown injection binds free `window` references to the same Taro window in the preamble and boundaries.
+ * Development defines route Refresh's globals to globalThis; ordinary window lookups stay native.
  */
 export declare function createMiniReactRefreshTransforms(): Plugin[];
 /**
  * Reproduces the browser preamble at runtime evaluation, after its declarations initialize.
- * The renderer hook belongs to the real global used by Reconciler. The no-op registration and identity signature belong
- * to the injected Taro window, satisfying upstream guards without replacing module-local Refresh registration.
+ * The renderer hook, no-op registration and identity signature share Reconciler's real global. Development defines point
+ * upstream guards at these same properties without replacing module-local Refresh registration.
  * These shared protocol properties are initialized once per runtime module evaluation, not for each updated boundary.
  */
 export declare function transformRefreshRuntime(code: string): {

package/dist/node/plugins/mini/global/create-mini-global-plugin.d.ts

@@ -0,0 +1,4 @@
+import { type Plugin } from 'vite';
+import type { MiniPlacementPlugin } from '../placer/placer.ts';
+/** Shares one standalone native provider between the application's virtual binding and the wrapped HMR runtime. */
+export declare function createMiniGlobalPlugin(placement: Pick<MiniPlacementPlugin, 'getPhysicalChunkId'>): Plugin[];

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

@@ -3,6 +3,8 @@ import type { RuntimeModulesContract } from '../mini-contract.ts';
 export declare const miniRuntimeId: string;
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
+/** Identifies the virtual binding shared by native files, SystemJS capsules and HMR factories. */
+export declare const vptGlobalBindingId = "\0vpt:global-binding";
 /** Generates the selected core-js imports as one independently executable output entry. */
 export declare const miniPolyfillsId = "\0vpt:mini-polyfills";
 /** Resolves the shared Taro facade's target initialization side effect. */
@@ -30,14 +32,16 @@ export type MiniChunkClassification = Readonly<{
     executionKind: MiniExecutionKind;
     isTransport: boolean;
 }>;
-/** Classifies chunks by runtime roles and framework vendor membership. */
+/** Classifies chunks by explicit runtime roles. */
 export type MiniModuleClassifier = (chunk: MiniChunk) => MiniChunkClassification;
-/** Groups the generated entry and core-js into common/polyfills.js. */
+/** Native hook filter for the physical core-js graph; the generated import-only entry needs no host rewriting. */
+export declare const miniPolyfillSourceFilter: RegExp;
+/** Keeps the global binding and core-js in the pre-bootstrap native chunk, outside the recursive framework group. */
 export declare function isMiniPolyfillModule(moduleId: string): boolean;
-/** Uses the same resolved roots for vendor grouping and amphibious execution; Rolldown includes their dependencies. */
+/** Groups framework modules by resolved package roots; Rolldown includes their dependencies. */
 export declare function isMiniFrameworkVendorModule(moduleId: string): boolean;
 /**
- * Classifies runtime entries and framework vendor chunks in one module-ID scan.
+ * Classifies explicit runtime entries in one module-ID scan; framework vendor remains a capsule.
  * Amphibious chunks share bootstrap's bridge so native and SystemJS callers reuse the same exports.
  * Construction is O(1); each lookup is O(M), where M is the number of modules in the chunk.
  */

package/dist/node/plugins/mini/native/create-mini-native-component-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+/** Expands native interfaces before Vite erases their TypeScript field declarations. */
+export declare function createMiniNativeComponentPlugin(): Plugin;

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

@@ -16,7 +16,8 @@ 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;
-    getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string;
+    /** Resolves a rendered chunk or its exact entry module ID to its planned physical path. */
+    getPhysicalChunkId(chunk: Rolldown.RenderedChunk | string): string;
     getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
     finalize(bundle: Rolldown.OutputBundle): readonly GeneratedSubpackage[];
 }>;

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

@@ -7,7 +7,7 @@ export type { GeneratedSubpackage, Placement } from './placement.ts';
 export type MiniPlacementPlugin = Plugin & Readonly<{
     classifyChunk(chunk: Rolldown.PreRenderedChunk | Rolldown.RenderedChunk): MiniChunkClassification;
     getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation;
-    getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string;
+    getPhysicalChunkId(chunk: Rolldown.RenderedChunk | string): string;
     getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
     getSubpackages(): readonly GeneratedSubpackage[];
 }>;

package/dist/node/plugins/mini/polyfill/create-mini-polyfill-plugin.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 import type { MiniContract } from '../mini-contract.ts';
-/** Loads a standalone polyfills entry before bootstrap and retains Taro's renderer bindings. */
+/** Loads selected polyfills before bootstrap and retains Taro's renderer bindings. */
 export declare function createMiniPolyfillPlugin(contract: Pick<MiniContract, 'options'>): Plugin;

package/dist/node/plugins/mini/polyfill/mini-browser-bindings.d.ts

@@ -1,6 +1,5 @@
-/** Taro's renderer-owned browser bindings; portable APIs use native globals or explicit polyfills. */
+/** Taro's renderer-owned bindings. window stays native; portable APIs use native globals or explicit polyfills. */
 export declare const miniBrowserBindings: {
-    window: [string, string];
     document: [string, string];
     navigator: [string, string];
     requestAnimationFrame: [string, string];

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

@@ -10,8 +10,8 @@ import type { AstTransformResult } from '../../../utils/transform.ts';
  * - 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 through the language-global `System.importSync`, and asynchronous boundaries use
- *   the same runtime through `System.import`.
+ *   SystemJS runtime. Native shells enter that graph through bootstrap's exported `System.importSync`, and asynchronous
+ *   boundaries use the same runtime through `System.import`.
  *
  * What this renderer emits:
  *

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

@@ -9,7 +9,7 @@ import type { MiniModuleClassifier } from '../module/module.ts';
  * 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
- *    the language-global `System.importSync(logicalChunkId)`, synchronously linking the capsule before the native lifecycle call.
+ *    bootstrap's `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
@@ -22,10 +22,12 @@ import type { MiniModuleClassifier } from '../module/module.ts';
  * 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, classifyModule, sourcemap }: {
+export declare function renderNative({ code, chunk, chunks, bootstrapModuleId, getPhysicalChunkId, classifyModule, sourcemap }: {
     code: string;
     chunk: Rolldown.RenderedChunk;
     chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    bootstrapModuleId: string;
+    getPhysicalChunkId: (chunk: Rolldown.RenderedChunk | string) => string;
     classifyModule: MiniModuleClassifier;
     sourcemap: boolean;
 }): AstTransformResult;

package/dist/node/plugins/mini/render/system-js/string-editor.d.ts

@@ -1,24 +1,36 @@
+/** One half-open source range; omitted ranges also own insertions at both boundaries. */
+type SourceRange = Readonly<{
+    start: number;
+    end: number;
+}>;
 /**
- * Records non-overlapping range edits and renders them in one source-order pass.
+ * Collects range edits, then compiles one immutable, source-ordered plan for every rendered view.
  *
- * 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.
+ * Final Mini Program development chunks do not request source maps. Hoisted functions and the remaining module body
+ * are disjoint views of the same plan, rather than repeated scans/sorts followed by destructive function removals.
+ *
+ * For E edits and F hoisted functions, compilation costs O(E log E) plus insertion text assembly. Each view uses binary
+ * searches followed by forward-only cursors over its edits. Rendering all functions and the remaining body costs
+ * O(E + F log E + output characters); views never scan the complete insertion journal per replacement or function.
+ * Storage is O(E + inserted text) plus rendered output, owned by this compilation only.
  */
 export declare class StringEditor {
     #private;
     readonly original: string;
     constructor(original: string);
-    /** Records a half-open replacement; semantic passes guarantee ranges are nested or disjoint. */
+    /** Records a replacement, including empty replacements for removed import declarations. */
     overwrite(start: number, end: number, content: string): void;
-    /** Removes a range and discards insertions that were owned only by that removed source. */
-    remove(start: number, end: number): void;
-    /** Inserts before prior insertions at a boundary, matching MagicString's prependLeft ordering. */
+    /** Records prepend order in O(1), avoiding unshift's repeated movement of earlier insertions. */
     prependLeft(position: number, content: string): void;
-    /** Inserts after prior insertions at the left side of a boundary. */
     appendLeft(position: number, content: string): void;
     /** Matches the subset of appendRight ordering used by the capsule compiler. */
     appendRight(position: number, content: string): void;
-    /** Materializes one source slice without mutating its edit journal, allowing functions to be rendered before relocation. */
-    render(start: number, end: number): string;
+    /** Sorts once after semantic edits finish; all function/body views share this immutable snapshot. */
+    compile(): {
+        /** Includes boundary insertions so relocated functions keep every edit they own. */
+        render: (start: number, end: number) => string;
+        /** Ranges must be disjoint and in source order, as direct Program function declarations are. */
+        renderOutside: (ranges: readonly SourceRange[]) => string;
+    };
 }
+export {};

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

@@ -1,12 +1,13 @@
 import type { Rolldown } from 'vite';
 import { type AstTransformResult } from '../../../utils/transform.ts';
 import type { MiniModuleClassifier } from '../module/module.ts';
+export declare const transportPlaceholder = "__VPT_TRANSPORT__";
 /**
  * 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
- * identity, while the LTHP-selected assets/package-qualified filename becomes the literal native require path. Rolldown
- * substitutes both hashes after this transform, so the
- * generated transport code and its own content hash describe the exact files that `generateBundle` later materializes.
+ * two IDs: the normalized preliminary filename becomes the SystemJS registration identity, while the LTHP-selected
+ * assets/package-qualified filename becomes the literal native require path. Rolldown
+ * substitutes both hashes after this transform, so the generated transport code and its own content hash describe the exact
+ * files that `generateBundle` later materializes.
  *
  * This intentionally creates broad hash invalidation: changing one capsule can rename transport, then bootstrap, then
  * chunks that import bootstrap. A Mini Program ships one application package rather than independently cached HTTP
@@ -21,3 +22,14 @@ export declare function materializeTransport({ code, transportChunk, chunks, cla
     getPhysicalChunkId?: (chunk: Rolldown.RenderedChunk) => string;
     sourcemap?: boolean;
 }): Promise<AstTransformResult>;
+/**
+ * Generates the closed transport expression from fixed ES2018-compatible syntax and JSON-encoded IDs and paths.
+ * All require arguments stay literal; inserting this expression needs neither Babel AST construction nor another Oxc pass.
+ */
+export declare function createTransportExpression({ transportChunk, chunks, classifyModule, getLoadMode, getPhysicalChunkId }: {
+    transportChunk: Rolldown.RenderedChunk;
+    chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    classifyModule: MiniModuleClassifier;
+    getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
+    getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string;
+}): string;

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

@@ -2,7 +2,7 @@ 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;
+    specialize(code: string, id: string, sourcemap?: boolean): import("../../../utils/transform.ts").AstTransformResult | undefined;
     applicationEntryIds: string[];
     input: any;
 };

package/dist/node/plugins/mini/resolve/specialize-app-capsule.d.ts

@@ -6,4 +6,4 @@ export declare function specializeAppCapsule({ code, id, appConfig, sourcemap }:
     id: string;
     appConfig: MiniJsonObject;
     sourcemap?: boolean;
-}): Promise<AstTransformResult>;
+}): AstTransformResult;

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

@@ -6,4 +6,4 @@ export declare function specializePageCapsule({ code, id, page, sourcemap }: {
     id: string;
     page: MiniPage;
     sourcemap?: boolean;
-}): Promise<AstTransformResult>;
+}): AstTransformResult;

package/dist/node/plugins/mini/skeleton/recursive-page-templates.d.ts

@@ -0,0 +1,6 @@
+/** Threads a Page root through recursive template scopes without serializing it into the App's compact tree. */
+export declare function buildRecursiveBaseTemplate(source: string, directive: 'a' | 'tt'): string;
+/** Starts the recursive App host with both independent native data roots. */
+export declare function buildRecursiveComponentTemplate(source: string): string;
+/** Keeps the independent Page root when App rendering crosses CustomWrapper. */
+export declare function buildRecursiveCustomWrapperTemplate(source: string): string;

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

@@ -1,13 +1,10 @@
 import { type Plugin } from 'vite';
 import type { MiniContract } from '../mini-contract.ts';
-import { createMiniTransformer } from './create-mini-transformer.ts';
-import { minifyMiniStylesheet } from './minify-mini-stylesheet.ts';
 /** JavaScript code plus the physical filename required by the Mini Program class-name transformer. */
 type JavaScriptArtifact = Readonly<{
     code: string;
     filename: string;
 }>;
-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. */
@@ -85,6 +82,11 @@ export type MiniStylePlugin = Plugin & Readonly<{
  * publication. Any conversion or minification failure rejects before callers expose partial output. JavaScript conversion is
  * skipped when the projection contains no Tailwind candidates, preserving ordinary bundle bytes.
  *
+ * `createFinalizeOutput()` captures the resolved output policy once and retains only the latest successful CSS conversion and
+ * candidate identity. Every transaction supplies a fresh live-graph projection, but byte-identical CSS skips both PostCSS and
+ * Lightning CSS. Equal candidate contents reuse the same set and replacement table even when the projection allocated a new
+ * set. Changed candidates never reuse stale replacements; conversion failures do not advance the snapshot.
+ *
  * ### 5a. Complete-build commit
  *
  * The post-order `generateBundle` hook gathers all JavaScript chunks, finalizes them as one operation, and only then mutates the
@@ -103,14 +105,14 @@ export type MiniStylePlugin = Plugin & Readonly<{
  *
  * ## Retained state and lifecycle
  *
- * The factory retains five explicit mutable state owners plus one fixed transformation service:
+ * Each plugin instance owns the following bounded state and transformation services:
  *
  * - `cssMinify`: requested global-style minification captured before disabling Vite's intermediate pass, then resolved once;
  * - `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;
  * - `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.
+ * - `finalizeOutput`: resolved output options, the fixed Mini transformer, and the latest successful CSS/candidate snapshot.
  *
  * 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,28 +122,11 @@ export type MiniStylePlugin = Plugin & Readonly<{
  * Projection is `O(V + E + B + C)` for reachable modules, import edges, concatenated CSS bytes, and candidate insertions.
  * Building one exact candidate precheck costs `O(C)` candidate bytes and testing a chunk costs `O(J)` source bytes. Matching
  * chunks then parse and walk in `O(J)`; replacing `Kᵢ` candidate tokens in literal `i` costs `O(LᵢKᵢ)` while preserving
- * untouched bytes through Rolldown's native editor. Retained memory is `O(B + C + D + F)` for latest CSS, candidate sets,
- * 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. Enabled minification parses
- * the one final global stylesheet in builds and HMR; no extra source reads or graph traversals are needed.
+ * untouched bytes through Rolldown's native editor. Comparing candidate sets costs `O(C)` without sorting. Retained memory
+ * is `O(B + C + D + F)` for latest CSS, candidate sets, 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. Native CSS conversion/minification runs only when projected CSS changes;
+ * no extra source reads or graph traversals are needed.
  */
 export declare function createMiniStylePlugin(contract: Pick<MiniContract, 'styles'>, applicationEntryIds: readonly string[]): MiniStylePlugin;
-/**
- * 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 stylesheet conversion and optional minification before JavaScript conversion and returns bytes without publication.
- */
-export declare function finalizeOutput(entryIds: readonly string[], styleByModuleId: ReadonlyMap<string, Readonly<{
-    css: string | undefined;
-    tailwind: Readonly<{
-        classSet: ReadonlySet<string>;
-    }> | undefined;
-}>>, getModuleInfo: (moduleId: string) => Readonly<{
-    importedIds: readonly string[];
-    dynamicallyImportedIds: readonly string[];
-}> | null | undefined, miniTransformer: MiniTransformer, javaScript: readonly JavaScriptArtifact[], stylesheetOptions: Parameters<typeof minifyMiniStylesheet>[1]): Promise<{
-    javaScript: string[];
-    stylesheet: string;
-}>;
 export {};

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

@@ -0,0 +1,14 @@
+import type { Rolldown } from 'vite';
+import type { VptOptions } from '../../../options.ts';
+import type { MiniProjectSkeletonInput } from '../mini/mini-contract.ts';
+type TtSkeletonInput = MiniProjectSkeletonInput & Readonly<{
+    options: VptOptions;
+    componentsModulePath: string;
+}>;
+/**
+ * TT supports recursive named templates. Like Alipay, its App host carries the independent Page root as p through each
+ * template scope and CustomWrapper boundary. The TT runtime declares p as a native property on both generated components.
+ * This preserves the App → Page React tree without copying Page nodes into the shared App projection or adding layout nodes.
+ */
+export declare function createTtSkeleton({ bundle, subpackages, nativeComponents, isProduction, options, componentsModulePath }: TtSkeletonInput): Rolldown.EmittedAsset[];
+export {};

package/dist/node/plugins/tt/create-tt-template.d.ts

@@ -0,0 +1,3 @@
+import { RecursiveTemplate } from '@tarojs/shared/dist/template.js';
+/** Creates an isolated mutable component registry for one TT skeleton generation. */
+export declare function createTtTemplate(): RecursiveTemplate;

package/dist/node/plugins/tt/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 TikTok. */
+export declare function createTtMiniPlugins(options: VptOptions): PluginOption[];
+/** Binds TT's runtime, native templates, styles, and socket transport to the shared compiler. */
+export declare function createTtMiniContract(options: VptOptions): MiniContract;

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

@@ -1,8 +1,11 @@
-import { generate } from '@babel/generator';
-import { type Rolldown } from 'vite';
+import type { Rolldown } from 'vite';
 export type AstTransformResult = {
     code: string;
     map: Rolldown.ExistingRawSourceMap | null;
 };
-/** Replaces each placeholder with a Babel AST expression while transforming the module through Oxc. */
-export declare function replaceWithAst(code: string, filename: string, replacement: Readonly<Record<string, Parameters<typeof generate>[0]>>, sourcemap?: boolean): Promise<AstTransformResult>;
+/**
+ * Specializes compiler-owned templates by their unique reserved slots. This is not a JavaScript substitution API:
+ * the shipped templates own the expression positions, and their tests verify those positions. Values must already be
+ * serialized JavaScript expressions. Vite remains the sole owner of TypeScript/JSX lowering and syntax validation.
+ */
+export declare function replaceTemplate(code: string, filename: string, replacement: Readonly<Record<string, string>>, sourcemap: boolean): AstTransformResult;

package/dist/options.d.ts

@@ -9,7 +9,7 @@ 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' | 'zfb' | 'h5';
+export type VptTarget = 'wx' | 'zfb' | 'tt' | 'h5';
 /** Selects one implemented Mini Program development update mechanism. */
 export type VptHmrOptions = Readonly<{
     /**
@@ -30,9 +30,9 @@ export type VptPageOption = {
     /**
      * Optional native Page configuration for the selected target.
      *
-     * 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.
+     * Use WeChat keys for WX, Alipay keys for ZFB, TikTok keys for TT, and Taro/WeChat keys for H5. 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?: VptPageConfig;
 };
@@ -41,7 +41,7 @@ export interface VptOptions {
     /**
      * Platform produced by the current Vite invocation.
      *
-     * Use `wx` to emit a WeChat Mini Program, `zfb` to emit an Alipay Mini Program, or `h5` to emit a browser application.
+     * Use `wx` for WeChat, `zfb` for Alipay, `tt` for TikTok Mini Programs, or `h5` for a browser application.
      * The selected target controls Taro module resolution, conditional compilation, runtime bootstrapping, style processing,
      * and output generation.
      */
@@ -63,8 +63,8 @@ export interface VptOptions {
     /**
      * Native application configuration for the selected target.
      *
-     * 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
+     * Use WeChat keys for WX, Alipay keys for ZFB, TikTok keys for TT, and Taro/WeChat keys for H5. The plugin 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.
      */
@@ -72,7 +72,7 @@ export interface VptOptions {
     /**
      * Native development-tool project configuration written without merging.
      *
-     * WX emits this object as `project.config.json`; ZFB emits it as `mini.project.json`; H5 ignores it. Supply the schema
+     * WX emits `project.config.json`; ZFB emits `mini.project.json`; TT emits `project.config.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.
@@ -81,7 +81,8 @@ export interface VptOptions {
     /**
      * Local development-tool preferences written without merging.
      *
-     * WX emits this object as `project.private.config.json`; ZFB emits it as `.mini-ide/project-ide.json`; H5 ignores it.
+     * WX emits `project.private.config.json`; ZFB emits `.mini-ide/project-ide.json`; TT emits `project.private.config.json`;
+     * H5 ignores it. TT private configuration requires TikTok DevTools 4.0.7+ and supports only its documented fields.
      * 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.
      */
@@ -89,7 +90,7 @@ export interface VptOptions {
     /**
      * 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 ZFB and H5.
+     * The file is emitted only when this value is provided for a `wx` build. It is ignored for ZFB, TT, and H5.
      */
     sitemapJson?: VptJsonObject;
     /**
@@ -109,7 +110,8 @@ export interface VptOptions {
     /**
      * Selects the Mini Program development update mode. Omission uses `devtools`.
      *
-     * This option affects only `vite serve` for `wx` and `zfb` targets and never changes H5 or production output.
+     * This option affects only `vite serve` for `wx`, `zfb`, and `tt` targets and never changes H5 or production output.
+     * Prefer `interpreter` on TT; native DevTools patch execution has not been verified in TikTok DevTools.
      */
     hmr?: VptHmrOptions;
 }

package/dist/runtime/global/vpt-global.d.ts

@@ -0,0 +1,5 @@
+/**
+ * One shared host object.
+ * This must be same instance even if the file is copied.
+ * */
+export declare const vptGlobal: typeof globalThis;

package/dist/runtime/global/vpt-global.js

@@ -0,0 +1,62 @@
+/** Use the native object when available; otherwise recover it with the ungap/global-this getter technique. */
+function getGlobalThis() {
+    // This provider is bundled independently, without global injection or HMR instrumentation.
+    if (typeof globalThis === 'object' && globalThis) {
+        return globalThis;
+    }
+    // worker
+    if (typeof self === 'object' && self) {
+        return self;
+    }
+    // browser
+    if (typeof window === 'object' && window) {
+        return window;
+    }
+    if (typeof this === 'object' && this) {
+        return this;
+    }
+    // https://mathiasbynens.be/notes/globalthis
+    // This fallback requires a host that inherits Object.prototype and permits its temporary modification.
+    // Both paths assign this local result so the return follows cleanup, avoiding an unreachable V8 coverage branch.
+    let resolved;
+    try {
+        Object.defineProperty(Object.prototype, '__vpt_global__', {
+            get() {
+                return this || self;
+            },
+            configurable: true
+        });
+        resolved = __vpt_global__;
+    }
+    catch (cause) {
+        console.error('Unable to resolve globalThis', cause);
+        resolved = getOrCreateFakeGlobal();
+    }
+    finally {
+        delete Object.prototype.__vpt_global__;
+    }
+    return resolved;
+}
+function getOrCreateFakeGlobal() {
+    // Separately bundled copies share one mutable fallback through this realm's Object constructor, not its possibly
+    // locked prototype. The non-enumerable, immutable cache slot is created only after the first failed discovery.
+    const key = typeof Symbol === 'function' && typeof Symbol.for === 'function'
+        ? Symbol.for('vpt.fake.global')
+        : 'vpt.fake.global';
+    const cached = Reflect.get(Object, key);
+    if (cached) {
+        return cached;
+    }
+    const fakeGlobal = {
+        Object: Object
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    };
+    fakeGlobal.globalThis = fakeGlobal;
+    Object.defineProperty(Object, key, { value: fakeGlobal });
+    return fakeGlobal;
+}
+/**
+ * One shared host object.
+ * This must be same instance even if the file is copied.
+ * */
+export const vptGlobal = getGlobalThis();

package/dist/runtime/mini/amphibious/bootstrap.d.ts

@@ -1,3 +1,3 @@
 import '\0vpt:mini-polyfills';
-import '../systemjs/system-core.js';
+export declare const System: any;
 export declare const __vitePreload: <Value>(load: () => Value) => Value;

package/dist/runtime/mini/amphibious/bootstrap.js

@@ -1,17 +1,20 @@
+import { vptGlobal } from '\0vpt:global-binding';
+// This file must not have any raw reference to the `globalThis` free binding.
+// biome-ignore lint/suspicious/noShadowRestrictedNames: intentional shadow
+const globalThis = vptGlobal;
 // Install the selected polyfills before the runtime or application uses them.
 // @ts-expect-error: The Mini build resolves this private polyfills entry.
 import '\0vpt:mini-polyfills';
 // Install the minimal SystemJS loader and its synchronous-import extension before any native entry requests a capsule.
-import '../systemjs/system-core.js';
+import { System as createdSystem } from '../systemjs/system-core.js';
 import { transport } from './transport.js';
+// install the System on globalThis
+globalThis.System = createdSystem;
+// Publish the installed loader as an explicit native dependency; callers need no ambient globalThis binding.
+export const System = createdSystem;
+// Transport returns synchronous registrations for main-package capsules and amphibious modules, and promise-like
+// registrations only for capsules that physically live in generated subpackages.
+System.instantiate = transport;
 // 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 the language global before this dependent module evaluates.
-const installedSystem = globalThis.System;
-if (!installedSystem) {
-    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.
-installedSystem.instantiate = transport;

package/dist/runtime/mini/dev/modes/devtools/devtools-runtime.d.ts

@@ -5,7 +5,7 @@ import { injectPageHmr as injectDevtoolsPageHmr } from './page-hmr.ts';
  * factories but does not execute application modules, allowing the shared runtime to install a complete batch before one render.
  */
 type DevtoolsPatch = RuntimePatch & {
-    readonly factory: () => void;
+    readonly factory: (runtime: MiniHmrRuntime) => void;
 };
 type HmrPageConfig = Parameters<typeof injectDevtoolsPageHmr>[0];
 /** Adapts physical DevTools patch modules and Page replacement onto the shared Mini Program HMR runtime. */