weapp-tailwindcss 5.1.16 → 5.2.1

package/dist/bundlers/vite/generate-bundle/css-composition-plan.d.ts

@@ -0,0 +1,58 @@
+import type { RememberedCssSource } from './types.js';
+export interface CssCompositionHandlerOptions {
+    isMainChunk?: boolean | undefined;
+    sourceOptions?: {
+        cssEntries?: string[] | undefined;
+        sourceFile?: string | undefined;
+    } | undefined;
+}
+export interface ResolveViteCssCompositionPlanOptions<HandlerOptions extends CssCompositionHandlerOptions> {
+    assetSourceFile: string;
+    configuredSourceFileKeys: ReadonlySet<string>;
+    cssEntries: string[] | undefined;
+    cssMatcher: (file: string) => boolean;
+    explicitSourceFileKeys: ReadonlySet<string>;
+    file: string;
+    getCssHandlerOptions: (file: string) => HandlerOptions;
+    getOriginalCssLayerSource: ((file: string) => string | undefined) | undefined;
+    isRootStyleOutputFile: (file: string) => boolean;
+    isWebGeneratorTarget: boolean;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    normalizeGeneratorSource: (source: string, outputFile: string) => string;
+    normalizeGeneratorUserSource: (source: string, sourceFile: string, fallbackFile: string) => string;
+    outputCssHandlerOptions: HandlerOptions;
+    outputFile: string;
+    rawSource: string;
+    rememberedSources: RememberedCssSource[];
+    resolveConfiguredRootInjectionTarget: (sourceFile: string, outputFile: string) => string | undefined;
+    resolveMatchedOutputFile: (sourceFile: string) => string | undefined;
+    resolvedFromTemporarySource: boolean;
+    rootImportShellOutputFile: string;
+    shouldKeepImportedCssShell: boolean;
+    shouldKeepRootImportShell: boolean;
+    shouldMoveRootImportShellToOrigin: boolean;
+    shouldSkipRememberedSource: (source: RememberedCssSource) => boolean;
+    viteProcessedCssAsset: boolean;
+}
+export interface ViteCssCompositionPlan<HandlerOptions extends CssCompositionHandlerOptions> {
+    cssHandlerOptions: HandlerOptions;
+    generatorCssHandlerOptions: HandlerOptions;
+    generatorRawSource: string;
+    generatorSourceFile: string;
+    generatorUserLayerRawSource: string | undefined;
+    hasCurrentTailwindGenerationDirective: boolean;
+    hasRememberedApplySource: boolean;
+    hasSameOutputRememberedTailwindGenerationSource: boolean;
+    hasStaleViteProcessedCssSource: boolean;
+    outputCssHandlerOptions: HandlerOptions;
+    outputFile: string;
+    preserveImportedCssShell: boolean;
+    rememberedSource: RememberedCssSource | undefined;
+    rememberedSources: RememberedCssSource[];
+    rootImportShellTarget: string | undefined;
+    usedConfiguredSourceFile: string | undefined;
+    usesConfiguredTailwindV4FallbackSource: boolean;
+    vitePipelineCssAsset: boolean;
+    webviewRootCssInjectionTarget: string | undefined;
+}
+export declare function resolveViteCssCompositionPlan<HandlerOptions extends CssCompositionHandlerOptions>(options: ResolveViteCssCompositionPlanOptions<HandlerOptions>): ViteCssCompositionPlan<HandlerOptions>;

package/dist/bundlers/vite/generate-bundle/css-config-directives.d.ts

@@ -1,2 +1,2 @@
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function normalizeRelativeCssConfigDirectives(source: string, file: string, outputRoot: string, opts: InternalUserDefinedOptions): string;

package/dist/bundlers/vite/generate-bundle/css-entry-processing.d.ts

@@ -0,0 +1 @@
+export declare function processViteCssBundleEntry(options: any): Promise<void>;

package/dist/bundlers/vite/generate-bundle/css-handler-options.d.ts

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../../types';
+import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../../types/index.js';
 type CssHandlerOptions = IStyleHandlerOptions & {
     postcssOptions: {
         options: {

package/dist/bundlers/vite/generate-bundle/css-output-helpers.d.ts

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function resolveCssBundleOutputFile(options: {
     bundleFiles: string[];
     defaultStyleOutputExtension: string;
@@ -28,6 +28,25 @@ export declare function createMatchedCssSourceOutputResolver(options: {
     originalFileNames?: string[] | undefined;
     resolveOutputFileFromMatchedCssSource: (sourceFile: string | undefined) => string | undefined;
 }): (sourceFile: string | undefined) => string | undefined;
+export type ResolveCssAssetOutputPlanOptions = Parameters<typeof resolveCssBundleOutputFile>[0] & {
+    assetSourceFile: string;
+    configuredEntries: Array<{
+        file: string;
+    }>;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    originalFileNames: string[] | undefined;
+    resolveOutputFileFromMatchedCssSource: (sourceFile: string | undefined) => string | undefined;
+    rootImportShellOutputFile: string;
+    rootImportShellTarget: string | undefined;
+    shouldReuseRootImportShell: () => boolean;
+};
+export interface CssAssetOutputPlan {
+    outputFile: string;
+    resolveMatchedOutputFile: (sourceFile: string | undefined) => string | undefined;
+    resolvedFromConfiguredOriginalCssEntry: boolean;
+    reusedRootImportShellTarget: boolean;
+}
+export declare function resolveCssAssetOutputPlan(options: ResolveCssAssetOutputPlanOptions): CssAssetOutputPlan;
 export declare function hasViteProcessedCssResultForSource(sourceFile: string, getViteProcessedCssAssetResults?: (() => Iterable<[string, unknown]> | undefined) | undefined): boolean;
 export declare function applyCssResultToBundle(options: {
     assetSourceFile: string;

package/dist/bundlers/vite/generate-bundle/css-output.d.ts

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare const SOURCE_STYLE_OUTPUT_EXT_RE: RegExp;
 export declare const CSS_SOURCE_OUTPUT_EXT_RE: RegExp;
 export declare function resolveMiniProgramStyleOutputExtension(options?: {

package/dist/bundlers/vite/generate-bundle/css-share-scope.d.ts

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function createCssTransformShareScope(file: string, rawSource: string): string;
 export declare function createCssTransformShareScopeKey(opts: InternalUserDefinedOptions, file: string, rawSource: string): string;
 export declare function createCssRuntimeSignature(runtimeSignature: string, generatorCandidateSignature: string): string;

package/dist/bundlers/vite/generate-bundle/css-source-plan.d.ts

@@ -0,0 +1,19 @@
+import type { ConfiguredCssSourceEntry } from './configured-css-sources.js';
+import type { RememberedCssSourcePlan, ResolveRememberedCssSourcePlanOptions } from './remembered-css-plan.js';
+export interface ResolveViteCssSourcePlanOptions extends ResolveRememberedCssSourcePlanOptions {
+    configuredEntries: ConfiguredCssSourceEntry[];
+    cwd: string | undefined;
+    getSourceStyleSource: ((file: string) => string | undefined) | undefined;
+    getSourceStyleSources: (() => Iterable<[string, string]>) | undefined;
+    inferenceSourceRoot: string | undefined;
+    isConfiguredSourceProcessed: (sourceFile: string) => boolean;
+    isConfiguredSourceUsed: (sourceFile: string) => boolean;
+    isCurrentRootMiniProgramStyleOutput: boolean;
+    projectRoot: string;
+    selectConfiguredRootSource: () => ConfiguredCssSourceEntry | undefined;
+    shouldKeepRootImportShell: (outputFile: string, rawSource: string) => boolean;
+}
+export interface ViteCssSourcePlan extends RememberedCssSourcePlan {
+    resolution: 'remembered' | 'configured' | 'inferred' | 'temporary' | 'unresolved';
+}
+export declare function resolveViteCssSourcePlan(options: ResolveViteCssSourcePlanOptions): Promise<ViteCssSourcePlan>;

package/dist/bundlers/vite/generate-bundle/css-transform-decision-plan.d.ts

@@ -0,0 +1,61 @@
+import type { ViteCssAssetIdentityKind } from '../css-asset-identity.js';
+export interface ResolveViteCssTransformDecisionPlanOptions {
+    alreadyProcessedCssAsset: boolean;
+    cssAssetIdentityKind: ViteCssAssetIdentityKind;
+    cssIsMainChunk: boolean;
+    generatorCandidateSignatureInitialized: boolean;
+    generatorCandidatesChanged: boolean;
+    generatorRawSource: string;
+    hasCurrentTailwindGenerationDirective: boolean;
+    hasRememberedApplySource: boolean;
+    hasRuntimeAffectingChanges: boolean;
+    hasSameOutputRememberedTailwindGenerationSource: boolean;
+    hasStaleViteProcessedCssSource: boolean;
+    isCollectedBundlerGeneratedCssFile: boolean;
+    isProcessCssFile: boolean;
+    isRuntimeLinkedCss: boolean;
+    rawSource: string;
+    rememberedRawSource?: string | undefined;
+    shouldProcessTailwindGeneration: boolean;
+    shouldRegenerateMainPackageCssWithScopedCandidates: boolean;
+    useIncrementalMode: boolean;
+    vitePipelineCssAsset: boolean;
+    viteProcessedCssAsset: boolean;
+}
+export interface ViteCssTransformDecisionPlan {
+    shouldPreserveCollectedViteCssAsset: boolean;
+    shouldPreserveStaleGeneratedCssAsset: boolean;
+    shouldRefreshViteProcessedCssByCandidates: boolean;
+    shouldRegenerateCollectedViteCss: boolean;
+    shouldReplayLastCss: boolean;
+    shouldReuseProcessedCss: boolean;
+    shouldTrackGeneratorRuntime: boolean;
+    strippedViteProcessedCss: string;
+}
+export declare function resolveViteCssTransformDecisionPlan(options: ResolveViteCssTransformDecisionPlanOptions): ViteCssTransformDecisionPlan;
+export interface ResolveViteCssTransformCachePlanOptions {
+    cssIsMainChunk: boolean;
+    cssRuntimeAffectingHash: string;
+    cssShareScope: string;
+    linkedImpactSignature: string;
+    outputFile: string;
+    runtimeSignature: string;
+    scopedGeneratorCandidateSignature: string;
+    sourceTraceSignature: string;
+    tailwindcssMajorVersion?: number | undefined;
+}
+export interface ViteCssTransformCachePlan {
+    cssCacheKey: string;
+    cssHashKey: string;
+    cssRuntimeSignature: string;
+    cssSharedCacheKey: string;
+    cssTaskHash: string;
+    rememberedCssRuntimeSignature: string;
+}
+export declare function resolveViteCssTransformCachePlan(options: ResolveViteCssTransformCachePlanOptions): ViteCssTransformCachePlan;
+export interface ResolveViteCssLinkedImpactSignatureOptions {
+    changedHtmlFiles: ReadonlySet<string>;
+    changedJsFiles: ReadonlySet<string>;
+    runtimeAffectingSignatureByFile: ReadonlyMap<string, string>;
+}
+export declare function resolveViteCssLinkedImpactSignature(options: ResolveViteCssLinkedImpactSignatureOptions): string;

package/dist/bundlers/vite/generate-bundle/css-transform-result.d.ts

@@ -0,0 +1,23 @@
+import type { ViteCssTransformTaskResult } from './css-transform-task.js';
+export interface ApplyViteCssTransformTaskResultOptions {
+    addWatchFile?: ((id: string) => void) | undefined;
+    debug: (format: string, ...args: unknown[]) => void;
+    debugCssDiff: boolean;
+    file: string;
+    generatorSourceFile: string;
+    outputFile: string;
+    outputIsMainChunk: boolean;
+    recordCssAssetResult?: ((file: string, css: string) => void) | undefined;
+    recordViteProcessedCssAssetResult?: ((file: string, css: string, options?: {
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }) => void) | undefined;
+    result: ViteCssTransformTaskResult;
+    shouldInjectVitePipelineCssIntoMain: boolean;
+    shouldRecordVitePipelineCssByOutput: boolean;
+    tailwindcssMajorVersion?: number | undefined;
+    transformRuntime: Set<string>;
+    vitePipelineCssAsset: boolean;
+    vitePipelineCssInjectionOutputFile: string;
+}
+export declare function applyViteCssTransformTaskResult(options: ApplyViteCssTransformTaskResultOptions): string;

package/dist/bundlers/vite/generate-bundle/css-transform-task.d.ts

@@ -0,0 +1,42 @@
+import type { TailwindV4GenerationCoreInput, TailwindV4GenerationCoreResult } from '../../shared/v4-generation-core.js';
+import { generateTailwindV4Css } from '../../shared/v4-generation-core.js';
+export type ViteCssTransformTaskKind = 'tailwind' | 'web' | 'import-shell' | 'style';
+export interface ViteCssTransformTaskResult {
+    classSet?: Set<string> | undefined;
+    css: string;
+    dependencies: string[];
+    diffSource?: string | undefined;
+    generatorTarget?: TailwindV4GenerationCoreResult['target'] | undefined;
+    kind: ViteCssTransformTaskKind;
+    shouldRecordCssAsset: boolean;
+}
+export interface ExecuteViteCssTransformTaskOptions {
+    annotateCss: (css: string) => string;
+    assetSourceFile?: string | undefined;
+    cssUserHandlerOptions: TailwindV4GenerationCoreInput['cssUserHandlerOptions'];
+    debug: TailwindV4GenerationCoreInput['debug'];
+    file: string;
+    generateCss?: typeof generateTailwindV4Css | undefined;
+    generatorPlatform?: string | undefined;
+    generatorCssHandlerOptions: TailwindV4GenerationCoreInput['cssHandlerOptions'];
+    generatorRawSource: string;
+    generatorSourceFile: string;
+    generatorUserLayerRawSource?: string | undefined;
+    getSourceCandidatesForEntries: TailwindV4GenerationCoreInput['getSourceCandidatesForEntries'];
+    isWebGeneratorTarget: boolean;
+    normalizeGeneratorUserRawSource: (source: string, sourceFile: string, fallbackFile?: string | undefined) => string;
+    normalizeMiniProgramGeneratorRawSource: (source: string, outputFile: string) => string;
+    opts: TailwindV4GenerationCoreInput['opts'];
+    outputFile: string;
+    previousCss?: string | undefined;
+    rawSource: string;
+    removeRootCoveredCssFromScopedAsset: (css: string) => string;
+    runtime: Set<string>;
+    runtimeState: TailwindV4GenerationCoreInput['runtimeState'];
+    styleHandlerOptions: TailwindV4GenerationCoreInput['cssHandlerOptions'];
+    styleHandler: TailwindV4GenerationCoreInput['styleHandler'];
+    transformWebTargetCss: (css: string) => string;
+    usesConfiguredTailwindV4FallbackSource: boolean;
+    vitePipelineCssAsset: boolean;
+}
+export declare function executeViteCssTransformTask(options: ExecuteViteCssTransformTaskOptions): Promise<ViteCssTransformTaskResult>;

package/dist/bundlers/vite/generate-bundle/final-css-assets.d.ts

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { GenerateBundleContext } from './types';
-import type { IStyleHandlerOptions } from '../../../types';
+import type { GenerateBundleContext } from './types.js';
+import type { IStyleHandlerOptions } from '../../../types/index.js';
 export declare function finalizeMiniProgramCssAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: {
     cssMatcher: GenerateBundleContext['opts']['cssMatcher'];
     getCssHandlerOptions: (file: string) => IStyleHandlerOptions;

package/dist/bundlers/vite/generate-bundle/finalize/bundle.d.ts

@@ -1,2 +1,2 @@
-import type { FinalizeGenerateBundleOptions } from './root-import-shell';
+import type { FinalizeGenerateBundleOptions } from './root-import-shell.js';
 export declare function finalizeGenerateBundle(options: FinalizeGenerateBundleOptions): Promise<void>;

package/dist/bundlers/vite/generate-bundle/finalize/root-import-shell.d.ts

@@ -1,8 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleBuildState, BundleSnapshot } from '../../bundle-state';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy';
-import type { BundleMetrics } from '../metrics';
-import type { GenerateBundleContext } from '../types';
+import type { BundleBuildState, BundleSnapshot } from '../../bundle-state.js';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy.js';
+import type { BundleMetrics } from '../metrics.js';
+import type { GenerateBundleContext } from '../types.js';
 export interface FinalizeGenerateBundleOptions {
     activeProcessCacheKeys: Set<string>;
     activeProcessHashKeys: Set<string | number>;
@@ -18,7 +18,7 @@ export interface FinalizeGenerateBundleOptions {
     formatIteration: number;
     generatorCandidateSignature: string;
     generatorRuntime: Set<string>;
-    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
     getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
     getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
     getViteCssCacheStats: GenerateBundleContext['getViteCssCacheStats'];

package/dist/bundlers/vite/generate-bundle/finalize.d.ts

@@ -1,2 +1,2 @@
-export { finalizeGenerateBundle } from './finalize/bundle';
-export { normalizeRootMiniProgramImportShellAssets } from './finalize/root-import-shell';
+export { finalizeGenerateBundle } from './finalize/bundle.js';
+export { normalizeRootMiniProgramImportShellAssets } from './finalize/root-import-shell.js';

package/dist/bundlers/vite/generate-bundle/html-processing.d.ts

@@ -1,6 +1,6 @@
 import type { OutputAsset } from 'rollup';
-import type { createEmptyMetrics } from './metrics';
-import { processCachedTask } from '../../shared/cache';
+import type { createEmptyMetrics } from './metrics.js';
+import { processCachedTask } from '../../shared/cache.js';
 export interface ProcessHtmlBundleEntryOptions {
     cache: Parameters<typeof processCachedTask<string>>[0]['cache'];
     context: {

package/dist/bundlers/vite/generate-bundle/js-entries.d.ts

@@ -1,2 +1,2 @@
-import type { OutputEntry } from '../bundle-entries';
+import type { OutputEntry } from '../bundle-entries.js';
 export declare function createJsEntryResolver(jsEntries: Map<string, OutputEntry>): (id: string) => OutputEntry | undefined;

package/dist/bundlers/vite/generate-bundle/js-handler-options.d.ts

@@ -1,5 +1,6 @@
-import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types';
+import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types/index.js';
 interface JsHandlerOptionsFactoryOptions {
+    getExperimentalJsFastPath?: () => CreateJsHandlerOptions['experimentalJsFastPath'];
     getMajorVersion: () => number | undefined;
     moduleGraph: CreateJsHandlerOptions['moduleGraph'];
 }

package/dist/bundlers/vite/generate-bundle/js-linking.d.ts

@@ -1,5 +1,5 @@
-import type { OutputEntry } from '../bundle-entries';
-import type { LinkedJsModuleResult } from '../../../types';
+import type { OutputEntry } from '../bundle-entries.js';
+import type { LinkedJsModuleResult } from '../../../types/index.js';
 interface LinkedUpdateHelpersOptions {
     jsEntries: Map<string, OutputEntry>;
     onUpdate: (fileName: string, previous: string, next: string) => void;

package/dist/bundlers/vite/generate-bundle/js-processing.d.ts

@@ -1,8 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleSnapshot, BundleStateEntry } from '../bundle-state';
-import type { BundleMetrics } from './metrics';
-import type { GenerateBundleContext } from './types';
-import type { CreateJsHandlerOptions, LinkedJsModuleResult } from '../../../types';
+import type { BundleSnapshot, BundleStateEntry } from '../bundle-state.js';
+import type { BundleMetrics } from './metrics.js';
+import type { GenerateBundleContext } from './types.js';
+import type { CreateJsHandlerOptions, LinkedJsModuleResult } from '../../../types/index.js';
 interface ProcessJsBundleEntryOptions {
     applyLinkedUpdates: (linked?: Record<string, LinkedJsModuleResult>) => void;
     bundle: Record<string, OutputAsset | OutputChunk>;
@@ -11,7 +11,8 @@ interface ProcessJsBundleEntryOptions {
     debug: GenerateBundleContext['debug'];
     disableJsPrecheck: boolean;
     entry: BundleStateEntry;
-    getJsEntry: ReturnType<typeof import('./js-entries').createJsEntryResolver>;
+    getJsEntry: ReturnType<typeof import('./js-entries.js').createJsEntryResolver>;
+    deferUniAppXStylePlaceholder?: boolean;
     jsHandler: GenerateBundleContext['opts']['jsHandler'];
     jsTaskFactories: Array<() => Promise<void>>;
     linkedByEntry: Map<string, Set<string>> | undefined;

package/dist/bundlers/vite/generate-bundle/memory-debug.d.ts

@@ -1,4 +1,4 @@
-import type { GenerateBundleContext } from './types';
+import type { GenerateBundleContext } from './types.js';
 export declare function resolveViteMemoryDebugStats(context: {
     activeProcessCacheKeys: Set<string>;
     activeProcessHashKeys: Set<string | number>;

package/dist/bundlers/vite/generate-bundle/process-plan.d.ts

@@ -1,4 +1,4 @@
-import type { BundleSnapshot } from '../bundle-state';
+import type { BundleSnapshot } from '../bundle-state.js';
 interface LogBundleProcessPlanOptions {
     debug: (format: string, ...args: unknown[]) => void;
     snapshot: BundleSnapshot;

package/dist/bundlers/vite/generate-bundle/remembered-css-plan.d.ts

@@ -0,0 +1,35 @@
+import type { OutputAsset } from 'rollup';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { RememberedCssSource } from './types.js';
+export interface ResolveRememberedCssSourcePlanOptions {
+    configuredSourceFileKeys: ReadonlySet<string>;
+    currentRawSourceHasExplicitScanContext: boolean;
+    debug: (format: string, ...args: unknown[]) => void;
+    explicitConfiguredSourceFileKeys: ReadonlySet<string>;
+    file: string;
+    getRememberedCssSources: (() => Iterable<[string, RememberedCssSource]>) | undefined;
+    getSfcSource: ((file: string) => string | undefined) | undefined;
+    hasExplicitConfiguredRootSource: boolean;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    originalSource: OutputAsset;
+    outputFile: string;
+    outputRoot: string;
+    rawSource: string;
+    resolveConfiguredRootSource: () => RememberedCssSource | undefined;
+    resolveMatchedOutputFile: (sourceFile: string) => string | undefined;
+    resolveTemporarySource: (outputFile: string, rawSource: string) => RememberedCssSource | undefined;
+    shouldKeepCurrentRootOutput: (sourceFile: string, outputFile: string) => boolean;
+    snapshot: BundleSnapshot;
+    sourceRoot: string | undefined;
+    temporaryOutput: boolean;
+    cssMatcher: ((file: string) => boolean) | undefined;
+}
+export interface RememberedCssSourcePlan {
+    forceNonMainChunk: boolean;
+    hasUsableTailwindSource: boolean;
+    outputFile: string;
+    resolvedFromTemporarySource: boolean;
+    sources: RememberedCssSource[];
+    usedConfiguredSourceFiles: string[];
+}
+export declare function resolveRememberedCssSourcePlan(options: ResolveRememberedCssSourcePlanOptions): Promise<RememberedCssSourcePlan>;

package/dist/bundlers/vite/generate-bundle/remembered-css-replay.d.ts

@@ -1,7 +1,7 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { BundleMetrics } from './metrics';
-import type { GenerateBundleContext, RememberedCssSource } from './types';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { BundleMetrics } from './metrics.js';
+import type { GenerateBundleContext, RememberedCssSource } from './types.js';
 interface ProcessRememberedCssReplayOptions {
     addWatchFile: (id: string) => void;
     bundle: Record<string, OutputAsset | OutputChunk>;
@@ -25,8 +25,8 @@ interface ProcessRememberedCssReplayOptions {
     emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset | undefined;
     generatorRuntime: Set<string>;
     generatorPlatform?: string | undefined;
-    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
-    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
     getRememberedCssSignature?: ((file: string) => string | undefined) | undefined;
     getRememberedCssSources?: (() => Iterable<[string, RememberedCssSource]>) | undefined;
     isNativeAppStyleTarget: boolean;
@@ -41,7 +41,6 @@ interface ProcessRememberedCssReplayOptions {
     opts: GenerateBundleContext['opts'];
     recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
     recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
-    refreshRememberedCssSource?: GenerateBundleContext['refreshRememberedCssSource'];
     rootDir: string;
     runtimeState: GenerateBundleContext['runtimeState'];
     setRememberedCssSignature?: ((file: string, cssRuntimeSignature: string) => void) | undefined;

package/dist/bundlers/vite/generate-bundle/remembered-css.d.ts

@@ -1,6 +1,6 @@
 import type { OutputAsset } from 'rollup';
-import type { RememberedCssSource } from './types';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { RememberedCssSource } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function createRememberedCssRuntimeSignature(cssRuntimeSignature: string, cssRuntimeAffectingHash: string): string;
 export declare function resolveRememberedCssSourceForTest(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource | undefined;
 export declare function findRememberedCssSources(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource[];

package/dist/bundlers/vite/generate-bundle/root-style-output.d.ts

@@ -12,6 +12,26 @@ export declare function shouldPreserveFrameworkRootMiniProgramImportShell(option
     matchesCss: boolean;
     shouldKeep: () => boolean | undefined;
 }): boolean;
+export interface ResolveFrameworkRootImportShellPlanOptions {
+    assetSourceFile: string;
+    configuredTargetFiles: Iterable<string | undefined>;
+    file: string;
+    isMainChunk: boolean;
+    isWebGeneratorTarget: boolean;
+    matchesCss: boolean;
+    processedTargetFiles: Iterable<string | undefined>;
+    rawSource: string;
+    rememberedTarget: string | undefined;
+    rootImportShellOutputFile: string;
+    shouldKeep: () => boolean | undefined;
+    shouldMoveToOrigin: () => boolean | undefined;
+}
+export interface FrameworkRootImportShellPlan {
+    isCurrentImportShell: boolean;
+    reusableTarget: string | undefined;
+    targetToRemember: string | undefined;
+}
+export declare function resolveFrameworkRootImportShellPlan(options: ResolveFrameworkRootImportShellPlanOptions): FrameworkRootImportShellPlan;
 export declare function restoreFrameworkRootMiniProgramImportShellAssets(bundle: OutputBundle, options: {
     debug?: ((format: string, ...args: unknown[]) => void) | undefined;
     isWebGeneratorTarget: boolean;

package/dist/bundlers/vite/generate-bundle/runtime-configured-css.d.ts

@@ -0,0 +1,54 @@
+import type { OutputBundle } from 'rollup';
+import type { ViteFrameworkCssPipelineContext } from '../shared/framework-strategy.js';
+import type { ConfiguredCssSourceEntry } from './configured-css-sources.js';
+import type { GenerateBundleContext } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export interface CreateConfiguredCssSourceRegistryOptions {
+    bundleFiles: string[];
+    defaultStyleOutputExtension: string;
+    getCssSource: (file: string) => string | undefined;
+    isWebGeneratorTarget: boolean;
+    opts: InternalUserDefinedOptions;
+    outDir: string;
+    rootDir: string;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    sourceRoot?: string | undefined;
+}
+export declare function createConfiguredCssSourceRegistry(options: CreateConfiguredCssSourceRegistryOptions): {
+    explicitCssEntryFiles: string[];
+    getSourceEntries: () => ConfiguredCssSourceEntry[];
+    normalizeGeneratorUserRawSource: (source: string, sourceFile: string, fallbackFile?: string | undefined) => string;
+    resolveMatchedSourceOutputFile: (sourceFile: string) => string | undefined;
+};
+export interface CreateConfiguredCssRootResolversOptions {
+    bundle: OutputBundle;
+    bundleFiles: string[];
+    cssPipelineContext: ViteFrameworkCssPipelineContext;
+    cssPipelineStrategy: GenerateBundleContext['cssPipelineStrategy'];
+    currentSubpackageRoots?: Set<string> | undefined;
+    defaultStyleOutputExtension: string;
+    entries: ConfiguredCssSourceEntry[];
+    explicitCssEntryFiles: string[];
+    isWebGeneratorTarget: boolean;
+    opts: InternalUserDefinedOptions;
+    rootDir: string;
+    shouldPreserveAppCssExtension: boolean;
+    sourceRoot?: string | undefined;
+}
+export declare function createConfiguredCssRootResolvers(options: CreateConfiguredCssRootResolversOptions): {
+    configuredTailwindV4ExplicitCssEntryFileKeysForScope: Set<string>;
+    configuredTailwindV4CssSourceFileKeysForScope: Set<string>;
+    hasExplicitConfiguredRootCssEntryForOutput: (outputFile: string) => boolean;
+    isMiniProgramStyleOutputFile: (file: string) => boolean;
+    normalizeConfiguredTailwindV4CssEntryFileKey: (file: string) => string;
+    resolveConfiguredCssEntryRootInjectionTarget: (sourceFile: string | undefined, outputFile: string) => string | undefined;
+    resolveConfiguredRootCssSourceStyle: (outputFile: string, entries: ConfiguredCssSourceEntry[], originalFileNames?: string[] | undefined) => {
+        outputFile: string;
+        rawSource: string;
+        sourceFile: string;
+    } | undefined;
+    selectConfiguredRootCssSourceEntry: (outputFile: string, entries: ConfiguredCssSourceEntry[], originalFileNames?: string[] | undefined) => ConfiguredCssSourceEntry | undefined;
+    shouldKeepCurrentRootCssOutputForConfiguredSource: (sourceFile: string | undefined, outputFile: string) => boolean;
+    shouldKeepCurrentRootMiniProgramStyleOutputAsImportShell: (outputFile: string, css?: string | undefined) => boolean;
+    shouldSelectConfiguredRootCssOutput: (outputFile: string) => boolean;
+};

package/dist/bundlers/vite/generate-bundle/runtime-linked-css.d.ts

@@ -1,4 +1,4 @@
-import type { BundleSnapshot } from '../bundle-state';
+import type { BundleSnapshot } from '../bundle-state.js';
 export declare function collectCssExtensionByStem(files: string[], cssMatcher: (file: string) => boolean): Map<string, string>;
 export declare function collectRuntimeLinkedCssFiles(snapshot: BundleSnapshot, extensionByStem: Map<string, string>, fallbackExtension: string): Set<string>;
 export declare function collectJsImportedCssFiles(snapshot: BundleSnapshot): Set<string>;

package/dist/bundlers/vite/generate-bundle/runtime-linked-source-memory.d.ts

@@ -1,6 +1,6 @@
-import type { BundleSnapshot } from '../bundle-state';
-import type { RememberedCssSource } from './types';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { RememberedCssSource } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export interface RememberRuntimeLinkedCssSourcesOptions {
     bundleFiles: string[];
     defaultStyleOutputExtension: string;

package/dist/bundlers/vite/{generate-bundle-runtime.d.ts → generate-bundle/runtime.d.ts}

@@ -1,6 +1,6 @@
-import { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names';
-import { resolveMiniProgramStyleOutputExtension as resolveMiniProgramStyleOutputExtension2, resolveReplayCssOutputFile as resolveReplayCssOutputFile2, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile as resolveViteCssPipelineOutputFile2, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output';
-import { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css';
-import { shouldKeepRootMiniProgramStyleAsImportShell as shouldKeepRootMiniProgramStyleAsImportShell2, shouldMoveRootMiniProgramStyleToImportShellOrigin as shouldMoveRootMiniProgramStyleToImportShellOrigin2 } from './generate-bundle/root-style-output';
+import { normalizeBundleFileNameKeysForTest } from './bundle-file-names.js';
+import { resolveMiniProgramStyleOutputExtension as resolveMiniProgramStyleOutputExtension2, resolveReplayCssOutputFile as resolveReplayCssOutputFile2, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile as resolveViteCssPipelineOutputFile2, resolveViteCssPipelineOutputFileFromSourceFile } from './css-output.js';
+import { resolveRememberedCssSourceForTest } from './remembered-css.js';
+import { shouldKeepRootMiniProgramStyleAsImportShell as shouldKeepRootMiniProgramStyleAsImportShell2, shouldMoveRootMiniProgramStyleToImportShellOrigin as shouldMoveRootMiniProgramStyleToImportShellOrigin2 } from './root-style-output.js';
 declare function createGenerateBundleHook(context: any): any;
 export { createGenerateBundleHook, normalizeBundleFileNameKeysForTest, resolveMiniProgramStyleOutputExtension2 as resolveMiniProgramStyleOutputExtension, resolveRememberedCssSourceForTest, resolveReplayCssOutputFile2 as resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile2 as resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile, shouldKeepRootMiniProgramStyleAsImportShell2 as shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin2 as shouldMoveRootMiniProgramStyleToImportShellOrigin };

package/dist/bundlers/vite/generate-bundle/scoped-generator.d.ts

@@ -1,5 +1,5 @@
-import type { SourceCandidateFilterOptions } from '../source-candidates';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 export declare function createScopedGeneratorCandidateSignature(rawSource: string, sourceFile: string, fallbackSignature: string, getSourceCandidatesForEntries: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined, options?: {
     includeFallbackSignature?: boolean | undefined;
     majorVersion?: number | undefined;

package/dist/bundlers/vite/generate-bundle/sfc-style-source.d.ts

@@ -1,6 +1,6 @@
 import type { OutputChunk } from 'rollup';
-import type { BundleSnapshot } from '../bundle-state';
-import type { RememberedCssSource } from './types';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { RememberedCssSource } from './types.js';
 export declare function isSfcStyleSourceFile(file: string): boolean;
 export interface SfcStyleBlock {
     attrs: string;

package/dist/bundlers/vite/generate-bundle/signatures.d.ts

@@ -1,8 +1 @@
-import type { EntryType } from '../bundle-state';
-export declare function summarizeStringDiff(previous: string, next: string): string;
-export declare function createLinkedImpactSignature(entry: string, linkedImpactsByEntry: Map<string, Set<string>>, sourceHashByFile: Map<string, string>): string | undefined;
-export declare function createJsHashSalt(runtimeSignature: string, linkedImpactSignature?: string): string;
-export declare function createStableTextSignature(input: string): string;
-export declare function createCandidateSignature(candidates: Set<string>): string;
-export declare function getSnapshotHash(snapshotMap: Map<string, string>, file: string, fallback: string): string;
-export declare function hasRuntimeAffectingSourceChanges(changedByType: Record<EntryType, Set<string>>): boolean;
+export { createCandidateSignature, createJsHashSalt, createLinkedImpactSignature, createStableTextSignature, getSnapshotHash, hasRuntimeAffectingSourceChanges, summarizeStringDiff, } from '../../shared/runtime-signatures.js';