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

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/plugins.d.ts

@@ -10,7 +10,7 @@ export declare function isMiniClientEnvironment(environment: Readonly<{
  * 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.
+ * from unrelated Rolldown shell and bootstrap entries.
  */
 export declare function createMiniDevelopmentPlugin(contract: Pick<MiniContract, 'options' | 'runtime' | 'styles'>, styles: MiniStylePlugin): PluginOption[];
 /**

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/mini-contract.d.ts

@@ -9,7 +9,6 @@ export type TaroContract = {
 /** Physical runtime modules selected by one Mini Program target. */
 export type RuntimeModulesContract = {
     bootstrap: string;
-    transport: string;
     appShell: string;
     appCapsule: string;
     componentShell: string;

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

@@ -3,8 +3,13 @@ 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";
+/** External bootstrap dependency emitted only after the bundled graph is finalized. */
+export declare const miniTransportId = "\0vpt:mini-transport";
+export declare const miniTransportFileName = "common/vpt/transport.js";
 /** Resolves the shared Taro facade's target initialization side effect. */
 export declare const taroTargetRuntimeId = "\0vpt:taro-target-runtime";
 /** Redirects Vite's injected browser preload helper to the bootstrap identity loader. */
@@ -20,25 +25,19 @@ 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 chunks by runtime roles and framework vendor membership. */
-export type MiniModuleClassifier = (chunk: MiniChunk) => MiniChunkClassification;
-/** Groups the generated entry and core-js into common/polyfills.js. */
+/** Distinguishes native shells, lifecycle entry capsules, ordinary capsules, and shared native/SystemJS infrastructure. */
+export type MiniChunkKind = 'native' | 'entry-capsule' | 'normal-capsule' | 'amphibious';
+/** Classifies chunks by their compiler-owned modules; ordinary application chunks are normal capsules. */
+export type MiniModuleClassifier = (chunk: MiniChunk) => MiniChunkKind;
+/** 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.
- * 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.
+ * The Mini graph separates lifecycle entries from bootstrap/polyfill/runtime infrastructure. A compiler-owned module
+ * identifies its chunk's kind; chunks containing only application or framework modules are normal capsules.
+ * One scan stops at the first known identity: O(M) worst-case time and O(1) extra space, without per-chunk collections.
  */
 export declare function createMiniModuleClassifier(modules: RuntimeModulesContract): MiniModuleClassifier;

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/output/create-transport-output.d.ts

@@ -0,0 +1,29 @@
+import type { Rolldown } from 'vite';
+import { type MiniModuleClassifier } from '../module/module.ts';
+import type { PackageLocation } from '../placer/placement.ts';
+/**
+ * Emits the closed transport table in generateBundle, after placement and content-hash resolution. Each switch case has two
+ * identities: the package-neutral final filename is the SystemJS registration ID, while the package-qualified filename
+ * supplies the literal native require path. Preliminary hash placeholders must not escape into this late-generated file.
+ *
+ * Transport itself executes only as native CommonJS in common/vpt/, separate from the bundled chunk namespace. Together
+ * with bootstrap it publishes native namespaces to SystemJS without re-evaluating their module bodies.
+ *
+ * Do not generate this table in renderChunk: that hook runs before Rolldown's final minifier/code generator, which can rewrite
+ * require.async("path") into require.async(`path`). TikTok (tt) misses these template-literal dependencies in its static scan,
+ * causing "Can't find module" even when the referenced subpackage file exists. This is a dependency-discovery issue, not a
+ * difference in JavaScript string values.
+ *
+ * Emit the finished CommonJS as an asset in generateBundle so Rolldown writes it without minifying or reprinting its quoted
+ * paths. Fixed compact syntax and JSON-encoded IDs need no AST or quote-repair pass, while application chunks retain full
+ * compression, mangling, and whitespace removal.
+ */
+export declare function createTransportOutput({ bundle, classifyModule, getPackageLocation }: {
+    bundle: Rolldown.OutputBundle;
+    classifyModule: MiniModuleClassifier;
+    getPackageLocation(chunk: Rolldown.OutputChunk): PackageLocation;
+}): {
+    type: "asset";
+    fileName: string;
+    source: string;
+};

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

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

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

@@ -1,14 +1,13 @@
 import type { Plugin, Rolldown } from 'vite';
 import type { RuntimeModulesContract } from '../mini-contract.ts';
-import { isMiniPolyfillModule, type MiniChunkClassification, type MiniModuleClassifier } from '../module/module.ts';
+import { isMiniPolyfillModule, type MiniChunkKind, type MiniModuleClassifier } from '../module/module.ts';
 import { type GeneratedSubpackage, type PackageLocation } from './placement.ts';
 export type { GeneratedSubpackage, Placement } from './placement.ts';
 /** Placement services consumed by the later Mini Program rendering and output hooks. */
 export type MiniPlacementPlugin = Plugin & Readonly<{
-    classifyChunk(chunk: Rolldown.PreRenderedChunk | Rolldown.RenderedChunk): MiniChunkClassification;
+    classifyChunk(chunk: Rolldown.PreRenderedChunk | Rolldown.RenderedChunk): MiniChunkKind;
     getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation;
-    getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string;
-    getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
+    getPhysicalChunkId(chunk: Rolldown.RenderedChunk | string): string;
     getSubpackages(): readonly GeneratedSubpackage[];
 }>;
 /**
@@ -56,7 +55,7 @@ export declare function createPlacementRolldownOptions(classifyChunk: MiniModule
  * 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:mini` asks this plugin only for package ownership, physical relocation, and native loading mode.
+ * 4. `vpt:mini` asks this plugin only for package ownership and physical relocation.
  * 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

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/resolve/resolver.d.ts

@@ -1,8 +1,9 @@
+import { type Rolldown } from 'vite';
 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;
+    resolveId(id: string, importer: string | undefined, projectRoot: string): string | Rolldown.PartialResolvedId | 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;