vite-plugin-taro 0.7.8 → 0.7.10-beta.0

package/dist/node/plugins/mini/dev/create-hmr-results-stream.d.ts

@@ -3,13 +3,15 @@ import { type SchedulerLike, Subject } from 'rxjs';
 type HmrUpdatesResult = Parameters<NonNullable<DevOptions['onHmrUpdates']>>[0];
 type HmrUpdates = Exclude<HmrUpdatesResult, Error>;
 /**
- * Adapts Rolldown's non-awaited HMR callback into lossless quiet-window publications.
+ * Adapts Rolldown's non-awaited HMR callback into lossless fixed-duration batch publications.
  *
- * Debouncing the result stream itself would retain only the final callback and lose incremental patch factories that later
- * patches provably do not reproduce. Instead, the debounced view is only a closing notifier for `buffer`: every callback is
- * retained in arrival order, and one configured quiet period emits the complete window to the host's existing serialized
- * writer. This first stream migration deliberately does not own physical state; `publish` and `reportError` remain synchronous
- * admission callbacks so the dev host can enqueue both through its single writer.
+ * Applying auditTime to the result stream itself would retain only the final callback and lose incremental patch factories
+ * that later patches do not reproduce. Instead, it only closes `buffer`: the first meaningful callback starts one timed window,
+ * and later callbacks join without postponing its deadline. No timer runs while idle. `publish` and `reportError` remain
+ * synchronous admission callbacks so the dev host can enqueue both through its existing serialized writer.
+ *
+ * Empty and Noop-only callbacks are excluded from both the buffer and its closing notifier, so they cannot delay meaningful
+ * work or enqueue empty publications. Mixed callbacks remain intact; the host still owns per-update selection.
  *
  * DevEngine failures are values, not Observable errors. They represent transient editor generations and carry no executable
  * patch, so the stream reports the final error but otherwise removes them. Successful callbacks on either side remain ordered
@@ -17,7 +19,7 @@ type HmrUpdates = Exclude<HmrUpdatesResult, Error>;
  * Completing the returned Subject flushes its current buffer synchronously, allowing host shutdown to await the resulting
  * serialized task rather than silently dropping an admitted patch.
  *
- * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until the quiet edge.
+ * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until its closing edge.
  */
-export declare function createHmrResultsStream(settleMilliseconds: number, scheduler: SchedulerLike, publish: (result: HmrUpdates) => void, reportError: (error: Error) => void): Subject<HmrUpdatesResult>;
+export declare function createHmrResultsStream(batchMilliseconds: number, scheduler: SchedulerLike, publish: (result: HmrUpdates) => void, reportError: (error: Error) => void): Subject<HmrUpdatesResult>;
 export {};

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

@@ -2,7 +2,7 @@ import type { HmrInfo } from './hmr-protocol.ts';
 export declare const hmrInfoFileName = "hmr/info.js";
 /**
  * Renders immutable CommonJS metadata because App startup must initialize the runtime synchronously before any entry capsule.
- * Freezing also prevents application code from accidentally changing the build identity or socket endpoint for the App heap.
+ * Freezing also prevents application code from accidentally changing the running App's build identity or socket endpoint.
  */
 export declare function renderHmrInfo(info: HmrInfo): string;
 /**
@@ -10,7 +10,7 @@ export declare function renderHmrInfo(info: HmrInfo): string;
  *
  * Imported global CSS can change while the entry remains byte-identical. DevTools may then reuse an older persistent compile
  * cache after it restarts. Tying this inert comment to the build identity invalidates that cache once per complete build,
- * while incremental style updates continue changing only the imported file and therefore preserve the App heap.
+ * while incremental style updates continue changing only the imported file and therefore keep the App running.
  */
 export declare function renderDevelopmentAppStyle(globalStyleFileName: string, buildId: string): string;
 /**

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

@@ -1,5 +1,5 @@
 import type { Plugin } from 'vite';
-import type { MiniHmrOptions, RuntimeModulesContract } from '../mini-contract.ts';
+import type { MiniHmrOptions, RuntimeContract } from '../mini-contract.ts';
 import type { PatchPublication } from './hmr-protocol.ts';
 /** One mode-selected effect executed by the development host. */
 export type MiniHmrAction = Readonly<{
@@ -29,4 +29,4 @@ export type MiniHmrMode = Readonly<{
     }>) => string;
 }>;
 /** Resolves exactly one implementation before the Mini Program development host is created. */
-export declare function createMiniHmrMode(options: MiniHmrOptions, modules: RuntimeModulesContract): MiniHmrMode;
+export declare function createMiniHmrMode(options: MiniHmrOptions, runtime: RuntimeContract): MiniHmrMode;

package/dist/node/plugins/mini/dev/inject-dev-page-component.d.ts

@@ -0,0 +1,11 @@
+import type { AstTransformResult } from '../../../utils/transform.ts';
+/**
+ * In serve, a native Page may load its original physical capsule after HMR has already installed a newer component factory.
+ * Taro captures the component at createPageConfig() time; without this lookup, that Page first mounts with stale source even
+ * though the patch was acknowledged. Replace only the component argument, leaving the production capsule untouched.
+ */
+export declare function injectDevPageComponent({ capsuleCode, componentId, capsuleId }: {
+    capsuleCode: string;
+    componentId: string;
+    capsuleId: string;
+}): AstTransformResult;

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

@@ -1,31 +1,25 @@
-import type { InputOptions, OutputOptions } from 'rolldown';
+import type { OutputOptions, RolldownOptions } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
 import type { MiniContract } from '../mini-contract.ts';
 import type { MiniHmrMode } from './hmr-mode.ts';
-type BundledDevRolldownOptions = InputOptions & {
-    experimental?: {
-        [key: string]: unknown;
-        devMode?: boolean | Record<string, unknown>;
-    };
-    output?: OutputOptions | OutputOptions[];
-};
 export type BundledDev = {
     _devEngine?: DevEngine;
-    getRolldownOptions(): Promise<BundledDevRolldownOptions>;
+    getRolldownOptions(): Promise<RolldownOptions>;
     listen(): Promise<void>;
     triggerBundleRegenerationIfStale(): Promise<boolean>;
 };
 /**
- * Installs physical Mini Program output and runtime conventions over Vite's browser-oriented bundled-development options.
+ * Applies physical Mini Program output and runtime conventions through Rolldown's public options hook.
  * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.
  */
-export declare function installMiniDevOptions({ bundledDev, server, contract, hmrMode }: {
-    bundledDev: BundledDev;
+export declare function createMiniDevOptionsPlugin({ server, contract, hmrMode }: {
     server: ViteDevServer;
     contract: Pick<MiniContract, 'options'>;
     hmrMode: MiniHmrMode;
-}): void;
+}): {
+    name: string;
+    options(rolldownOptions: RolldownOptions): Promise<RolldownOptions>;
+};
 /** Returns the configured output after rejecting states unsupported by the physical Mini Program engine. */
-export declare function requireSingleOutput(rolldownOptions: BundledDevRolldownOptions): OutputOptions;
-export {};
+export declare function requireSingleOutput(rolldownOptions: RolldownOptions): OutputOptions;

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

@@ -1,4 +1,3 @@
-import type { RuntimeModulesContract } from '../../../mini-contract.ts';
 import type { MiniHmrMode } from '../../hmr-mode.ts';
 import type { PatchUpdate } from '../../hmr-protocol.ts';
 export declare const devtoolsPatchesFileName = "hmr/patches.js";
@@ -9,7 +8,7 @@ export declare const devtoolsPatchesFileName = "hmr/patches.js";
  * DevTools observes a changed Page dependency, re-executes the Page shell, and that shell synchronously gives the cumulative
  * native factory payload to the persistent App runtime. Mixing any one of these pieces with another mode would break that chain.
  */
-export declare function createDevtoolsHmrMode(modules: RuntimeModulesContract): MiniHmrMode;
+export declare function createDevtoolsHmrMode(runtimeFile: string): MiniHmrMode;
 /** Provides a valid, inert CommonJS dependency before the host has a patch range to publish. */
 export declare function renderInitialDevtoolsPatches(): string;
 /**

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

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

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

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

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

@@ -29,7 +29,7 @@ export declare function createMiniDevelopmentPlugin(contract: MiniContract, styl
  * but removes the prior physical App stylesheet; recovery builds do not clean. The host publishes the stylesheet once afterward.
  * Patch modes first reset delivery and publish matching `hmr/info.js`; rebuild mode has no patch state and writes a fresh marker
  * directly. Incremental HMR never enters this complete-output hook and changes only the imported global stylesheet; rewriting
- * the App root would reload the heap while a JavaScript patch is awaiting acknowledgement. The serve-only plugin leaves
+ * the App root would reload the runtime while a JavaScript patch is awaiting acknowledgement. The serve-only plugin leaves
  * production output unchanged.
  */
 export declare function removeDevelopmentAppStyle(bundle: Record<string, unknown>, appStyleFileName: string): void;

package/dist/node/plugins/mini/dev/replace-vite-transform-plugin.d.ts

@@ -0,0 +1,6 @@
+import type { RolldownPluginOption } from 'rolldown';
+import type { DevEnvironment } from 'vite';
+type TransformConfig = Pick<DevEnvironment['config'], 'root' | 'tsconfig' | 'consumer' | 'oxc'>;
+/** Reconstructs Vite's native transform through its exported factory, without reading or mutating builtin internals. */
+export declare function replaceViteTransformPlugin(pluginOption: RolldownPluginOption, config: TransformConfig): Promise<RolldownPluginOption>;
+export {};

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

@@ -6,23 +6,11 @@ export type TaroContract = {
     componentsReactPath: string;
     targetRuntimePath: string;
 };
-/** Physical runtime modules selected by one Mini Program target. */
-export type RuntimeModulesContract = {
-    bootstrap: string;
-    appShell: string;
-    appCapsule: string;
-    componentShell: string;
-    componentCapsule: string;
-    customWrapperShell: string;
-    pageShell: string;
-    pageCapsule: string;
+/** Target-specific development runtimes; shared Mini entry IDs live beside their source modules. */
+export type RuntimeContract = {
     devtoolsHmrRuntime: string;
     interpreterHmrRuntime: string;
 };
-/** Physical runtime selection for one Mini Program target. */
-export type RuntimeContract = {
-    modules: RuntimeModulesContract;
-};
 /** Style output names selected by one Mini Program target. */
 export type StyleContract = {
     appFileName: string;
@@ -51,6 +39,10 @@ export type OutputContract = {
     projectPrivateConfigFilename: string;
     generateProjectSkeleton(input: MiniProjectSkeletonInput, contract: MiniContract): Rolldown.EmittedAsset[];
 };
+/** Native project config fields overridden only in physical build-watch output. */
+export type WatchContract = {
+    override: Readonly<Record<string, VptJsonObject>>;
+};
 /** Complete input consumed by the shared Mini Program pipeline. */
 export type MiniContract = {
     options: VptOptions;
@@ -58,6 +50,7 @@ export type MiniContract = {
     runtime: RuntimeContract;
     styles: StyleContract;
     output: OutputContract;
+    watch: WatchContract;
 };
 /** Application JSON represented by the current Mini Program contract. */
 export type MiniJsonObject = VptJsonObject;

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

@@ -1,6 +1,21 @@
 import { type Rolldown } from 'vite';
-import type { RuntimeModulesContract } from '../mini-contract.ts';
-export declare const miniRuntimeId: string;
+/** Installs SystemJS, transport, and polyfills before native entries load capsules. */
+export declare const miniBootstrapId: string;
+/** Registers the native App using its generated configuration capsule. */
+export declare const miniAppShellId: string;
+/** Builds the App configuration and activates its React runtime. */
+export declare const miniAppCapsuleId: string;
+/** Registers the recursive native Component from its capsule configuration. */
+export declare const miniComponentShellId: string;
+/** Supplies the recursive Component and CustomWrapper configurations. */
+export declare const miniComponentCapsuleId: string;
+/** Registers the native CustomWrapper from the shared component capsule. */
+export declare const miniCustomWrapperShellId: string;
+/** Registers each route's native Page using its route-qualified capsule. */
+export declare const miniPageShellId: string;
+/** Specializes each route's Page configuration and component import. */
+export declare const miniPageCapsuleId: string;
+export declare const miniTaroRuntimeId: 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. */
@@ -9,7 +24,7 @@ export declare const vptGlobalBindingId = "\0vpt:global-binding";
 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";
+export declare const miniTransportOutputPath = "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. */
@@ -27,17 +42,11 @@ export declare const pageCapsuleId = "\0vpt:page-capsule";
 export type MiniChunk = Rolldown.PreRenderedChunk | Rolldown.RenderedChunk;
 /** 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;
 /** Groups framework modules by resolved package roots; Rolldown includes their dependencies. */
 export declare function isMiniFrameworkVendorModule(moduleId: string): boolean;
-/**
- * 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;
+/** Classifies each chunk by its compiler-owned modules; ordinary application chunks are normal capsules. O(M) time. */
+export declare function classifyMiniModule(chunk: MiniChunk): MiniChunkKind;

package/dist/node/plugins/mini/output/create-transport-output.d.ts

@@ -1,5 +1,4 @@
 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
@@ -18,9 +17,8 @@ import type { PackageLocation } from '../placer/placement.ts';
  * 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 }: {
+export declare function createTransportOutput({ bundle, getPackageLocation }: {
     bundle: Rolldown.OutputBundle;
-    classifyModule: MiniModuleClassifier;
     getPackageLocation(chunk: Rolldown.OutputChunk): PackageLocation;
 }): {
     type: "asset";

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

@@ -1,11 +1,9 @@
 import type { Plugin, Rolldown } from 'vite';
-import type { RuntimeModulesContract } from '../mini-contract.ts';
-import { isMiniPolyfillModule, type MiniChunkKind, type MiniModuleClassifier } from '../module/module.ts';
+import { isMiniPolyfillModule } 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): MiniChunkKind;
     getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation;
     getPhysicalChunkId(chunk: Rolldown.RenderedChunk | string): string;
     getSubpackages(): readonly GeneratedSubpackage[];
@@ -14,7 +12,7 @@ export type MiniPlacementPlugin = Plugin & Readonly<{
  * Rolldown options owned by Mini Program placement. Every field enforces a distinct output invariant. The plugin returns this object
  * from its config hook, while direct Rolldown integration tests reuse the same value to exercise the identical lifecycle.
  */
-export declare function createPlacementRolldownOptions(classifyChunk: MiniModuleClassifier): {
+export declare function createPlacementRolldownOptions(): {
     /**
      * Rolldown owns shared chunk names and collision handling. LTHP adds physical package prefixes
      * to those names later without copying or replacing the chunks.
@@ -62,4 +60,4 @@ export declare function createPlacementRolldownOptions(classifyChunk: MiniModule
  * performs one whole-state transition, so stale graph state, duplicate planning, and partially reset generations are
  * unrepresentable.
  */
-export declare function createMiniPlacementPlugin(modules: RuntimeModulesContract): MiniPlacementPlugin;
+export declare function createMiniPlacementPlugin(): MiniPlacementPlugin;

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

@@ -1,6 +1,5 @@
 import type { Rolldown } from 'vite';
 import type { AstTransformResult } from '../../../utils/transform.ts';
-import type { MiniModuleClassifier } from '../module/module.ts';
 /**
  * Materializes one final native/amphibious Rolldown chunk as executable Mini Program CommonJS.
  *
@@ -22,12 +21,10 @@ 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, bootstrapModuleId, getPhysicalChunkId, classifyModule, sourcemap }: {
+export declare function renderNative({ code, chunk, chunks, getPhysicalChunkId, 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/resolve/resolver.d.ts

@@ -1,9 +1,22 @@
 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'>): {
+export declare function createResolver(contract: Pick<MiniContract, 'options' | 'taro'>): {
     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[];
+    entries: {
+        appEntries: {
+            capsuleId: string;
+            capsuleName: string;
+            shellId: string;
+            shellName: string;
+        };
+        pageEntries: {
+            capsuleId: string;
+            capsuleName: string;
+            shellId: string;
+            shellName: string;
+        }[];
+    };
     input: any;
 };

package/dist/node/plugins/mini/styles/minify-mini-stylesheet.d.ts

@@ -1,5 +1,5 @@
 import type { BuildOptions } from 'vite';
-/** Minifies only the completed global native stylesheet, without another browser compatibility or preprocessing pass. */
+/** Minifies one completed native stylesheet, without another browser compatibility or preprocessing pass. */
 export declare function minifyMiniStylesheet(css: string, options: Readonly<{
     filename: string;
     minify: BuildOptions['cssMinify'];

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

@@ -1,25 +1,26 @@
 import { type Plugin } from 'vite';
 import type { MiniContract } from '../mini-contract.ts';
+import type { createResolver } from '../resolve/resolver.ts';
 /** JavaScript code plus the physical filename required by the Mini Program class-name transformer. */
 type JavaScriptArtifact = Readonly<{
     code: string;
     filename: string;
 }>;
-/** Vite plugin with the host operation that finalizes one coherent native-style/JavaScript transaction. */
+/** Vite plugin that finalizes native CSS and JavaScript without discarding HMR patches on CSS errors. */
 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[]>;
+    /** Publishes valid native CSS before JavaScript; CSS failures only log errors and retain the last valid styles. */
+    finalizeUpdate: <Artifact extends JavaScriptArtifact>(artifacts: readonly Artifact[], writeStylesheet: (fileName: string, source: string) => Promise<void>) => Promise<readonly Artifact[]>;
 }>;
 /**
- * Creates the single owner of global native-style compilation, graph projection, class rewriting, and publication.
+ * Creates the single owner of App/Page native-style compilation, graph projection, class rewriting, and publication.
  *
  * ## Architectural invariant
  *
- * 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
- * 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.
+ * Successful Mini Program updates 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 both sides share the current candidate union. Complete builds
+ * reject any conversion failure. HMR instead logs native CSS errors and retains the last valid stylesheet for each failed file.
+ * Failed CSS is never published. Valid JavaScript still arrives with its assigned patch sequence; dropping that sequence would
+ * force the running client to rebuild and lose state. Separate build/update finalizers share conversion and caching.
  *
  * ## Ownership boundaries
  *
@@ -33,12 +34,12 @@ export type MiniStylePlugin = Plugin & Readonly<{
  *    `vite:css-post` hook only after the original hook succeeds; it never rereads source files or repeats CSS preprocessing.
  * 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.
+ * 5. VPT owns physical App/Page CSS and patch publication. Vite's browser CSS asset is only an intermediate carrier and is
+ *    removed before VPT emits the App stylesheet and each native Page companion.
  *
- * 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.
+ * Opaque native-component styles stay outside this pipeline and are emitted by later native output hooks. The requested
+ * `build.cssCodeSplit` controls native projection. Vite's intermediate browser carrier remains unsplit after that request
+ * is captured, preventing browser CSS-loading code from leaking into native output.
  *
  * ## Compilation phases
  *
@@ -61,72 +62,84 @@ export type MiniStylePlugin = Plugin & Readonly<{
  *
  * `configResolved` wraps the concrete `vite:css-post` transform while preserving its hook metadata, filter, ordering, and
  * plugin context. The original Vite hook executes first, which preserves CSS Module exports and Vite's internal extraction
- * state. Only a successful transform updates `styleByModuleId`; syntax errors therefore leave the last successful CSS available
- * to the currently running application. Query modes such as `?raw`, `?url`, and `?inline` are excluded because they represent
+ * state. Only a successful transform updates `styleByModuleId`; Vite processing errors leave the last successful CSS available.
+ * Native conversion may still reject CSS accepted by this hook. Query modes such as `?raw`, `?url`, and `?inline` represent
  * values rather than graph-owned stylesheets.
  *
  * ### 3. Live-graph projection
  *
- * Output finalization starts from resolved App/Page entry IDs and traverses Rolldown's current static and dynamic import edges
- * in dependency-first post-order. Transaction-local visited sets terminate cycles and deduplicate shared modules and physical
- * stylesheets. A retained stylesheet contributes only when its module is still reachable, so removing an import prunes its CSS
- * 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.
+ * The resolver supplies App/Page entry records; capsule resolution preserves those records and their native output paths.
+ * Each capsule traverses Rolldown's current static and dynamic import edges in dependency-first post-order. Root-local visited
+ * sets terminate cycles and deduplicate physical styles without suppressing another Page's independent cascade. App-reachable
+ * styles belong to the App and are excluded from every Page projection; styles shared only by Pages remain in each consumer.
+ * With splitting disabled, one traversal visits App then configured Pages and collects all reachable CSS into the App file,
+ * deduplicating shared styles and leaving Page companions empty. A retained stylesheet contributes only while reachable,
+ * so import removals prune CSS and candidates without a topology cache. Candidate sets contain only surviving Tailwind roots.
+ *
+ * App CSS is emitted at the contract's global filename; Page CSS is emitted beside each native Page shell. Only the App file
+ * receives HTML display defaults. JavaScript rewriting uses the union of all surviving App/Page Tailwind candidates.
  *
  * ### 4. Shared native-style finalization
  *
- * `finalizeOutput()` converts the concatenated reachable CSS to native CSS, optionally minifies that complete global file
- * (including HTML defaults), then transforms each JavaScript artifact with the same projected class set. Both builds and HMR
- * follow `build.cssMinify`, defaulting to `build.minify`, using Lightning CSS. Vite's intermediate CSS minification
+ * Both output finalizers convert and optionally minify each entry's CSS, then transform every JavaScript artifact using
+ * the shared candidate union. Builds and HMR follow `build.cssMinify`, defaulting to `build.minify`, using Lightning CSS.
+ * Vite's intermediate CSS minification
  * remains disabled so only final native bytes are optimized. The function returns data without bundle mutation or filesystem
- * 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.
+ * publication. Complete builds reject conversion or minification failures. HMR logs CSS errors and reuses the affected file's
+ * last valid output, if any; neither invalid CSS nor partially processed CSS is published. JavaScript conversion stays strict
+ * and uses current candidates, even with stale CSS. It 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.
+ * `createFinalizeOutput()` composes a strict build converter and an HMR-only recovery wrapper. Both retain the same latest
+ * successful conversion per file and candidate identity. Every transaction supplies a fresh live-graph projection, but byte-identical CSS skips PostCSS and
+ * Lightning CSS independently for each file. Equal candidate contents reuse the same set and replacement table even when
+ * the projection allocated a new set. Changed candidates never reuse stale replacements. Invalid CSS is never cached; rejected
+ * transactions 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
  * bundle. It assigns converted code, clears invalid source maps, removes Vite's intermediate browser stylesheet, and always
- * emits the contract-selected global file, including the HTML compatibility base even when the application has no styles.
- * Native output hooks run afterward and emit Page/component companion files independently.
+ * emits the App stylesheet with HTML defaults and every Page stylesheet, including empty Pages. Native output hooks run
+ * afterward without Page-style placeholders; opaque native-component styles remain independently owned.
  *
  * ### 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 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.
+ * Finalization uses the `PluginContext` captured by `buildStart`, so it observes the same current graph as the compiler. The host's
+ * atomic writer publishes valid native CSS before `finalizeUpdate()` returns converted patch factories. CSS conversion errors
+ * retain only the affected file's last valid styles; they do not block valid patches or healthy stylesheets. Captured Vite CSS
+ * literals are emptied first; factories, exports, changed IDs, and sequences remain intact.
+ * Each file's publication frontier advances only after its atomic write succeeds. A failed later write blocks JavaScript
+ * delivery; retry skips files already made durable. Empty Page CSS overwrites stale styles after import removal.
  *
  * ## Retained state and lifecycle
  *
  * 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;
+ * - `cssCodeSplit`: requested native-style ownership policy captured before disabling Vite's browser-only splitting;
+ * - `cssMinify`: requested native-style minification captured before disabling Vite's intermediate pass, then resolved once;
+ * - `resolvedEntries`: App/Page metadata with graph-exact capsule 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;
- * - `finalizeOutput`: resolved output options, the fixed Mini transformer, and the latest successful CSS/candidate snapshot.
+ * - `publishedStylesheets`: the last durably published bytes per development stylesheet for unchanged-write suppression;
+ * - `finalizeOutput`: resolved output options, the fixed transformer, and the latest successful per-file CSS/candidate snapshot.
  *
- * The state owners remain scoped to one plugin instance; `entryIds` is atomically replaced after each complete resolution.
+ * The state owners remain scoped to one plugin instance; `resolvedEntries` is atomically replaced after each complete resolution.
  * A development watcher retains them across updates; build and watcher shutdown clear the complete style store.
  *
  * ## Cost model
  *
- * Projection is `O(V + E + B + C)` for reachable modules, import edges, concatenated CSS bytes, and candidate insertions.
+ * Split projection is `O(sum(Vᵢ + Eᵢ + Bᵢ + Cᵢ))` across App/Page roots for reachable modules, import edges, projected CSS
+ * bytes, and candidate insertions. Combined projection is `O(V + E + B + C + P)` with one traversal and P Page companions.
+ * Candidate unioning needs no extra graph traversal.
  * 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. 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;
+ * compiler initialization. Successful native CSS conversions are reused while projected CSS is unchanged; failures retry;
  * no extra source reads or graph traversals are needed.
  */
-export declare function createMiniStylePlugin(contract: Pick<MiniContract, 'styles'>, applicationEntryIds: readonly string[]): MiniStylePlugin;
+export declare function createMiniStylePlugin(contract: Pick<MiniContract, 'styles'>, entries: ReturnType<typeof createResolver>['entries']): MiniStylePlugin;
 export {};

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

@@ -0,0 +1,52 @@
+import type { createResolver } from '../resolve/resolver.ts';
+type MiniEntries = ReturnType<typeof createResolver>['entries'];
+/** Projection needs captured CSS and candidates, not the retained compiler or its invalidation state. */
+type StyleSource = Readonly<{
+    css: string | undefined;
+    tailwind: Readonly<{
+        classSet: ReadonlySet<string>;
+    }> | undefined;
+}>;
+/** Read only current import edges while retaining the caller's graph context. */
+type ModuleGraph = Readonly<{
+    getModuleInfo: (id: string) => Readonly<{
+        importedIds: readonly string[];
+        dynamicallyImportedIds: readonly string[];
+    }> | null;
+}>;
+/**
+ * Projects native CSS according to build.cssCodeSplit. Split output preserves each Page's dependency-first cascade;
+ * combined output traverses App then configured Pages once, deduplicating shared CSS in the global stylesheet.
+ * Page companions stay empty in combined output. Both policies share one union of surviving Tailwind candidates.
+ *
+ * Split work is O(sum(Vᵢ + Eᵢ + Bᵢ + Cᵢ)) across roots. Combined work is O(V + E + B + C + P), where P is the Page count.
+ * All visited/style collections are transaction-local, so cycles terminate and graph removals need no retained cache.
+ */
+export declare function projectMiniStyles(entries: MiniEntries, styleByModuleId: ReadonlyMap<string, StyleSource>, context: ModuleGraph, cssCodeSplit: boolean): {
+    appEntries: {
+        capsuleId: string;
+        capsuleName: string;
+        shellId: string;
+        shellName: string;
+        styles: ReadonlyMap<string, Readonly<{
+            css: string;
+            classSet: ReadonlySet<string> | undefined;
+        }>>;
+        css: string;
+        classSet: Set<string>;
+    };
+    pageEntries: {
+        capsuleId: string;
+        capsuleName: string;
+        shellId: string;
+        shellName: string;
+        styles: ReadonlyMap<string, Readonly<{
+            css: string;
+            classSet: ReadonlySet<string> | undefined;
+        }>>;
+        css: string;
+        classSet: Set<string>;
+    }[];
+    classSet: Set<string>;
+};
+export {};