tailwind-styled-v4 5.0.11 → 5.0.12

package/dist/compiler.d.ts

@@ -18,11 +18,122 @@ interface NativeRscResult {
     needsClientDirective: boolean;
     clientReasons: string[];
 }
+interface ScanWorkspaceResult {
+    files: string[];
+    total_files: number;
+    classes: string[];
+    unique_classes: number;
+    duration_ms: number;
+    errors: string[];
+}
+interface ScanFileResult {
+    file: string;
+    classes: string[];
+    class_count: number;
+    has_tw_usage: boolean;
+    size_bytes: number;
+    duration_ms: number;
+}
+interface BatchExtractResult {
+    file: string;
+    classes: string[];
+    contentHash: string;
+    ok: boolean;
+    error?: string;
+}
+interface SafelistCheckResult {
+    matched: string[];
+    unmatched: string[];
+    safelistSize: number;
+}
+interface PrefilterFileResult {
+    file: string;
+    has_tw_usage: boolean;
+    duration_ms: number;
+    size_bytes: number;
+    status: "processed" | "skipped" | "error";
+    error?: string;
+}
+interface DeadCodeResult {
+    deadInCss: string[];
+    deadInSource: string[];
+    liveClasses: string[];
+    totalCssClasses: number;
+    totalSourceClasses: number;
+}
+interface ProcessedCssResult {
+    css: string;
+    size_bytes: number;
+    resolved_classes: string[];
+    unknown_classes: string[];
+}
+interface ContainerConfig {
+    tag: string;
+    containerJson: string;
+    containerName?: string;
+    breakpoints: Array<{
+        key: string;
+        classes: string;
+    }>;
+}
+interface HoistResult {
+    code: string;
+    hoisted: string[];
+    warnings: string[];
+}
+interface VariantTableResult {
+    id: string;
+    tableJson: string;
+    keys: string[];
+    defaultKey: string;
+    combinations: number;
+}
+interface ClassifyResult {
+    className: string;
+    bucket: string;
+    sortOrder: number;
+}
+interface MergeResult {
+    declarationsJson: string;
+    declarationString: string;
+    count: number;
+}
+interface ClassUsageItem {
+    className: string;
+    usageCount: number;
+    filesJson: string;
+    bundleSizeBytes: number;
+    isDeadCode: boolean;
+}
+interface StateCssConfig {
+    tag: string;
+    componentName: string;
+    statesJson: string;
+    sourceFile: string;
+}
+interface GeneratedStateCss {
+    selector: string;
+    declarations: string;
+    cssRule: string;
+    componentName: string;
+    stateName: string;
+}
 interface NativeBridge {
+    generateCssNative?: (classes: string[], theme_json: string) => string;
+    getCacheStats?: () => [number, number];
+    clearThemeCache?: () => void;
     transformSource?: (source: string, opts?: Record<string, string>) => NativeTransformResult | null;
     extractClassesFromSource?: (source: string) => string[];
     hasTwUsage?: (source: string) => boolean;
     isAlreadyTransformed?: (source: string) => boolean;
+    scan_workspace?: (root: string, extensions?: string[]) => ScanWorkspaceResult;
+    extract_classes_from_source?: (source: string) => string[];
+    batch_extract_classes?: (filePaths: string[]) => BatchExtractResult[];
+    check_against_safelist?: (classes: string[], safelist: string[]) => SafelistCheckResult;
+    scan_file?: (filePath: string) => ScanFileResult;
+    collect_files?: (root: string, extensions?: string[]) => string[];
+    walk_and_prefilter_source_files?: (root: string, extensions?: string[]) => PrefilterFileResult[];
+    generate_sub_component_types?: (root: string, outputPath?: string) => string;
     extractAllClasses?: (source: string) => string[];
     parseClasses?: (raw: string) => Array<{
         raw: string;
@@ -55,35 +166,11 @@ interface NativeBridge {
         unmatched: string[];
         safelistSize: number;
     };
-    hoistComponents?: (source: string) => {
-        code: string;
-        hoisted: string[];
-        warnings: string[];
-    };
-    compileVariantTable?: (configJson: string) => {
-        id: string;
-        tableJson: string;
-        keys: string[];
-        defaultKey: string;
-        combinations: number;
-    };
-    classifyAndSortClasses?: (classes: string[]) => Array<{
-        className: string;
-        bucket: string;
-        sortOrder: number;
-    }>;
-    mergeCssDeclarations?: (cssChunks: string[]) => {
-        declarationsJson: string;
-        declarationString: string;
-        count: number;
-    };
-    analyzeClassUsage?: (classes: string[], scanResultJson: string, css: string) => Array<{
-        className: string;
-        usageCount: number;
-        filesJson: string;
-        bundleSizeBytes: number;
-        isDeadCode: boolean;
-    }>;
+    hoistComponents?: (source: string) => HoistResult;
+    compileVariantTable?: (configJson: string) => VariantTableResult;
+    classifyAndSortClasses?: (classes: string[]) => ClassifyResult[];
+    mergeCssDeclarations?: (cssChunks: string[]) => MergeResult;
+    analyzeClassUsage?: (classes: string[], scanResultJson: string, css: string) => ClassUsageItem[];
     analyzeRsc?: (source: string, filename: string) => {
         isServer: boolean;
         needsClientDirective: boolean;
@@ -104,19 +191,8 @@ interface NativeBridge {
     };
     compileCssLightning?: (classes: string[]) => string;
     /** Post-process raw Tailwind-generated CSS dengan LightningCSS di Rust */
-    detectDeadCode?: (scanResultJson: string, css: string) => {
-        deadInCss: string[];
-        deadInSource: string[];
-        liveClasses: string[];
-        totalCssClasses: number;
-        totalSourceClasses: number;
-    };
-    processTailwindCssLightning?: (css: string) => {
-        css: string;
-        size_bytes: number;
-        resolved_classes: string[];
-        unknown_classes: string[];
-    };
+    detectDeadCode?: (scanResultJson: string, css: string) => DeadCodeResult;
+    processTailwindCssLightning?: (css: string) => ProcessedCssResult;
     processTailwindCssWithTargets?: (css: string, targets: string | null) => {
         css: string;
         size_bytes: number;
@@ -129,42 +205,2404 @@ interface NativeBridge {
     calculateImpact?: (impactJson: string) => string;
     calculateRisk?: (className: string, totalComponents: number) => string;
     calculateSavings?: (bundleSizeBytes: number, componentCount: number) => number;
+    extractTwStateConfigs?: (source: string, filename: string) => StateCssConfig[];
+    generateStaticStateCss?: (inputs: Array<{
+        tag: string;
+        componentName: string;
+        statesJson: string;
+    }>, resolvedCss: string | null) => GeneratedStateCss[];
+    extractAndGenerateStateCss?: (source: string, filename: string) => GeneratedStateCss[];
+    /**
+     * Convert layout/utility class string ke CSS declarations.
+     * Dipakai oleh extractContainerCssFromSource sebagai Rust-accelerated fallback.
+     */
+    layoutClassesToCss?: (classes: string) => string;
+    /**
+     * Hash string dengan algoritma tertentu, return n karakter pertama.
+     * Dipakai untuk generate deterministic container CSS IDs.
+     */
+    hashContent?: (input: string, algo: string, length: number) => string;
+    /** Hapus dead CSS selectors + minify via Lightning CSS. */
+    eliminateDeadCss?: (css: string, deadClasses: string[]) => string;
+    /** Dead code detection + strip + Lightning CSS minify dalam satu call. */
+    optimizeCss?: (css: string) => string;
+    /** Extract tw container configs dari source untuk static @container CSS generation. */
+    extractTwContainerConfigs?: (source: string) => Array<{
+        tag: string;
+        containerJson: string;
+        containerName?: string;
+        breakpoints: Array<{
+            key: string;
+            classes: string;
+        }>;
+    }>;
+    get_cache_statistics?: () => string;
+    clear_all_caches?: () => void;
+    clear_parse_cache?: () => void;
+    clear_resolve_cache?: () => void;
+    clear_compile_cache?: () => void;
+    clear_css_gen_cache?: () => void;
+    get_cache_optimization_hints?: (hit_rate_percent: number, memory_used_mb: number) => string;
+    estimate_optimal_cache_config_native?: (total_budget_mb: number, workload_type: string) => string;
+    cache_read?: (cache_path: string) => {
+        entries_json: string;
+    };
+    cache_write?: (cache_path: string, entries: Array<{
+        file: string;
+        content_hash: string;
+        classes: string[];
+        mtime_ms: number;
+        size_bytes: number;
+    }>) => boolean;
+    cache_priority?: (mtime_ms: number, size_bytes: number, hit_count: number) => number;
+    resolve_variants?: (configJson: string) => string;
+    validate_variant_config?: (configJson: string) => string;
+    resolve_cascade?: (baseThemeJson: string, overridesJson: string) => string;
+    resolve_class_names?: (classNames: string[], themeJson: string) => string;
+    resolve_conflict_group?: (groupName: string, themeJson: string) => string;
+    resolve_theme_value?: (keyPath: string, themeJson: string) => string | null;
+    resolve_simple_variants?: (configJson: string) => string;
+    process_file_change?: (fileChangeJson: string) => string;
+    compute_incremental_diff?: (oldScanJson: string, newScanJson: string) => string;
+    create_fingerprint?: (filePath: string, fileContent: string) => string;
+    inject_state_hash?: (css: string, stateHash: string) => string;
+    prune_stale_entries?: (maxAgeSeconds: number, maxEntries: number) => string;
+    rebuild_workspace_result?: (rootDir: string, extensions?: string[]) => string;
+    scan_file_native?: (filePath: string, fileContent: string) => string;
+    scan_files_batch_native?: (filesJson: string) => string;
+    compile_class?: (input: string) => string;
+    compile_classes?: (inputs: string[]) => string;
+    compile_to_css?: (input: string, minify: boolean) => string;
+    compile_to_css_batch?: (inputs: string[], minify: boolean) => string;
+    minify_css?: (css: string) => string;
+    compile_animation?: (animationName: string, from: string, to: string) => string;
+    compile_keyframes?: (name: string, stopsJson: string) => string;
+    compile_theme?: (tokensJson: string, themeName: string, prefix: string) => string;
+    tw_merge?: (classString: string) => string;
+    tw_merge_many?: (classStrings: string[]) => string;
+    tw_merge_with_separator?: (classString: string, options: Record<string, unknown>) => string;
+    tw_merge_many_with_separator?: (classStrings: string[], options: Record<string, unknown>) => string;
+    tw_merge_raw?: (classLists: string[]) => string;
+    id_registry_create?: () => number;
+    id_registry_generate?: (handle: number, name: string) => number;
+    id_registry_lookup?: (handle: number, name: string) => number;
+    id_registry_next?: (handle: number) => number;
+    id_registry_destroy?: (handle: number) => void;
+    id_registry_reset?: (handle: number) => void;
+    id_registry_snapshot?: (handle: number) => string;
+    id_registry_active_count?: () => number;
+    register_property_name?: (propertyName: string) => number;
+    register_value_name?: (valueName: string) => number;
+    property_id_to_string?: (propertyId: number) => string;
+    value_id_to_string?: (valueId: number) => string;
+    reverse_lookup_property?: (propertyId: number) => string;
+    reverse_lookup_value?: (valueId: number) => string;
+    id_registry_export?: (handle: number) => string;
+    id_registry_import?: (importedData: string) => number;
+    redis_ping?: () => string;
+    redis_get?: (key: string) => string;
+    redis_set?: (key: string, value: string, ttl_seconds?: number) => string;
+    redis_delete?: (key: string) => number;
+    redis_exists?: (key: string) => number;
+    redis_mget?: (keys: string[]) => string;
+    redis_mset?: (pairs: Array<[string, string]>) => string;
+    redis_flush_db?: () => number;
+    redis_flush_all?: () => number;
+    redis_pool_connect?: (host: string, port: number, pool_size?: number) => string;
+    redis_pool_stats?: () => string;
+    redis_pool_reconnect?: () => string;
+    redis_enable_cluster?: (initial_nodes: string[]) => string;
+    redis_disable_cluster?: () => string;
+    redis_cluster_status?: () => string;
+    redis_subscribe?: (channel: string) => string;
+    redis_publish?: (channel: string, message: string) => number;
+    redis_expiration_set?: (key: string, ttl_seconds: number) => number;
+    redis_expiration_get?: (key: string) => string;
+    redis_info?: () => string;
+    redis_monitor?: () => string;
+    redis_cache_size?: () => number;
+    redis_cache_key_count?: () => number;
+    redis_cache_clear?: () => number;
+    redis_cache_hit_rate?: () => number;
+    redis_enable_persistence?: (mode: string) => string;
+    redis_disable_persistence?: () => string;
+    redis_snapshot?: () => string;
+    redis_memory_stats?: () => string;
+    redis_optimize_memory?: () => number;
+    redis_set_eviction_policy?: (policy: string) => string;
+    redis_get_eviction_policy?: () => string;
+    redis_replicate?: (target_host: string, target_port: number) => number;
+    redis_replication_status?: () => string;
+    redis_cache_sync?: (peers: string[]) => number;
+    redis_enable_cache_warming?: (key_pattern: string) => string;
+    redis_disable_cache_warming?: () => string;
+    redis_diagnose?: () => string;
+    start_watch?: (root_path: string, patterns?: string[]) => number;
+    poll_watch_events?: (handle: number, timeout_ms?: number) => string;
+    stop_watch?: (handle: number) => number;
+    watch_add_pattern?: (handle: number, pattern: string) => string;
+    watch_remove_pattern?: (handle: number, pattern: string) => string;
+    watch_get_active_handles?: () => string;
+    watch_clear_all?: () => number;
+    watch_event_type_to_string?: (event_type_code: number) => string;
+    is_watch_running?: (handle: number) => boolean;
+    get_watch_stats?: () => string;
+    watch_pause?: (handle: number) => string;
+    watch_resume?: (handle: number) => string;
+    scan_cache_optimizations?: () => string;
+    get_plugin_hooks?: () => string;
+    register_plugin_hook?: (hook_name: string, handler_id: string) => string;
+    unregister_plugin_hook?: (hook_name: string, handler_id: string) => string;
+    emit_plugin_hook?: (hook_name: string, data_json: string) => string;
+    get_compilation_metrics?: () => string;
+    reset_compilation_metrics?: () => string;
+    validate_css_output?: (css: string) => string;
+    get_compiler_diagnostics?: () => string;
+}
+interface NativeTransformResult {
+    code: string;
+    classes: string[];
+    changed: boolean;
+    rscJson?: string;
+    metadataJson?: string;
+}
+interface ClassExtractResult {
+    classes: string[];
+    component_names: string[];
+    has_tw_usage: boolean;
+    has_use_client: boolean;
+    imports: string[];
+}
+declare const getNativeBridge: () => NativeBridge;
+declare const resetNativeBridgeCache: () => void;
+declare const adaptNativeResult: (raw: NativeTransformResult) => {
+    code: string;
+    classes: string[];
+    changed: boolean;
+    rsc?: NativeRscResult;
+    metadata?: ComponentMetadata[];
+};
+
+/**
+ * cssGeneratorNative.ts
+ *
+ * High-performance CSS generator using Rust compiler via NAPI binding.
+ * Falls back to JavaScript Tailwind if Rust binding is unavailable.
+ */
+interface GenerateCssNativeOptions {
+    theme: Record<string, unknown>;
+    fallbackToJs?: boolean;
+    logFallback?: boolean;
+}
+/**
+ * Generate CSS from Tailwind classes using the Rust compiler.
+ *
+ * @param classes - Array of Tailwind class names (e.g., ["px-4", "hover:bg-blue-600"])
+ * @param options - Configuration including theme object
+ * @returns Promise resolving to CSS string
+ *
+ * @example
+ * ```ts
+ * const css = await generateCssNative(
+ *   ["px-4", "hover:bg-blue-600", "md:text-lg"],
+ *   {
+ *     theme: defaultTheme,
+ *     fallbackToJs: true,
+ *     logFallback: process.env.DEBUG === "true"
+ *   }
+ * )
+ * ```
+ *
+ * **Performance**: Rust compiler typically 40-60% faster than Tailwind JS
+ * - Rust: 60-90ms for 100 classes
+ * - JavaScript: 150ms baseline
+ *
+ * **Error Handling**:
+ * - If Rust binding fails and fallbackToJs=true, falls back to Tailwind JS
+ * - If Rust binding fails and fallbackToJs=false, throws error
+ * - Invalid classes log warnings but don't stop compilation
+ */
+declare function generateCssNative(classes: string[], options: GenerateCssNativeOptions): Promise<string>;
+/**
+ * Get cache statistics from the Rust compiler.
+ *
+ * @returns Object with cache hit/miss counts, or null if binding unavailable
+ *
+ * @example
+ * ```ts
+ * const stats = getCacheStats()
+ * if (stats) {
+ *   console.log(`Cache hits: ${stats.hits}, misses: ${stats.misses}`)
+ *   console.log(`Hit rate: ${(stats.hits / (stats.hits + stats.misses) * 100).toFixed(1)}%`)
+ * }
+ * ```
+ */
+declare function getCacheStats(): {
+    hits: number;
+    misses: number;
+} | null;
+/**
+ * Clear the theme resolver cache.
+ *
+ * Useful for:
+ * - Testing with different themes
+ * - Freeing memory in long-running processes
+ * - Resetting state between build cycles
+ *
+ * @example
+ * ```ts
+ * // Clear cache before each build
+ * clearThemeCache()
+ * const css = await generateCssNative(classes, { theme })
+ * ```
+ */
+declare function clearThemeCache(): void;
+
+declare function scanWorkspace(root: string, extensions?: string[]): ScanWorkspaceResult;
+declare function extractClassesFromSourceNative(source: string): string[];
+declare function batchExtractClassesNative(filePaths: string[]): BatchExtractResult[];
+declare function checkAgainstSafelistNative(classes: string[], safelist: string[]): SafelistCheckResult;
+declare function scanFile(filePath: string): ScanFileResult;
+declare function collectFiles(root: string, extensions?: string[]): string[];
+declare function walkAndPrefilterSourceFiles(root: string, extensions?: string[], _parallel?: boolean): PrefilterFileResult[];
+declare function generateSubComponentTypes(root: string, outputPath?: string): string;
+
+/**
+ * Detect dead CSS selectors in generated CSS.
+ */
+declare function detectDeadCode(scanResultJson: string, css: string): DeadCodeResult;
+/**
+ * Analyze class usage across scanned files.
+ */
+declare function analyzeClassUsageNative(classes: string[], scanResultJson: string, css: string): ClassUsageItem[];
+/**
+ * Analyze entire class list and generate CSS.
+ */
+declare function analyzeClassesNative(filesJson: string, cwd: string, flags?: number): {
+    css?: string;
+    code: string;
+    classes: string[];
+    changed: boolean;
+    rscJson?: string;
+    metadataJson?: string;
+    safelist?: string[];
+} | null;
+/**
+ * Analyze React Server Component requirements.
+ */
+declare function analyzeRscNative(source: string, filename: string): {
+    isServer: boolean;
+    needsClientDirective: boolean;
+    clientReasons: string[];
+};
+/**
+ * Optimize CSS by removing dead code and minifying.
+ */
+declare function optimizeCssNative(css: string): {
+    css: string;
+    originalSize: number;
+    optimizedSize: number;
+    reductionPercentage: number;
+};
+/**
+ * Process Tailwind CSS with Lightning CSS post-processing.
+ */
+declare function processTailwindCssLightning(css: string): ProcessedCssResult;
+/**
+ * Eliminate dead CSS selectors.
+ */
+declare function eliminateDeadCssNative(css: string, deadClasses: string[]): string;
+/**
+ * Hoist components from source code.
+ */
+declare function hoistComponentsNative(source: string): HoistResult;
+/**
+ * Compile variant configuration table.
+ */
+declare function compileVariantTableNative(configJson: string): VariantTableResult;
+/**
+ * Classify and sort classes by bucket.
+ */
+declare function classifyAndSortClassesNative(classes: string[]): ClassifyResult[];
+/**
+ * Merge CSS declarations from multiple chunks.
+ */
+declare function mergeCssDeclarationsNative(cssChunks: string[]): MergeResult;
+
+/**
+ * Compile Tailwind classes directly to CSS.
+ */
+declare function compileCssNative2(classes: string[], prefix?: string | null): {
+    css: string;
+    classes: string[];
+};
+/**
+ * Compile CSS using Lightning CSS post-processing.
+ */
+declare function compileCssLightning(classes: string[]): string;
+/**
+ * Extract Tailwind state configurations from source code.
+ */
+declare function extractTwStateConfigsNative(source: string, filename: string): StateCssConfig[];
+/**
+ * Generate static state CSS from configuration.
+ */
+declare function generateStaticStateCssNative(inputs: Array<{
+    tag: string;
+    componentName: string;
+    statesJson: string;
+}>, resolvedCss?: string | null): GeneratedStateCss[];
+/**
+ * Extract and generate state CSS in one step.
+ */
+declare function extractAndGenerateStateCssNative(source: string, filename: string): GeneratedStateCss[];
+/**
+ * Convert layout/utility class string to CSS declarations.
+ */
+declare function layoutClassesToCss(classes: string): string;
+/**
+ * Hash content for deterministic ID generation.
+ */
+declare function hashContent(input: string, algorithm?: string, length?: number): string;
+/**
+ * Extract container query configurations from source.
+ */
+declare function extractTwContainerConfigs(source: string): {
+    tag: string;
+    containerJson: string;
+    containerName?: string;
+    breakpoints: Array<{
+        key: string;
+        classes: string;
+    }>;
+}[];
+/**
+ * Parse Tailwind class into atomic CSS representation.
+ */
+declare function parseAtomicClass(twClass: string): string | null;
+/**
+ * Generate atomic CSS from rules.
+ */
+declare function generateAtomicCss(rulesJson: string): string;
+/**
+ * Convert Tailwind classes to atomic CSS classes.
+ */
+declare function toAtomicClasses(twClasses: string): string;
+/**
+ * Clear atomic CSS registry.
+ */
+declare function clearAtomicRegistry(): void;
+/**
+ * Get atomic registry size.
+ */
+declare function atomicRegistrySize(): number;
+
+/**
+ * cacheNative.ts
+ *
+ * Phase 5.1: Cache Management - Advanced caching strategies and optimization
+ * Exposes 9 cache-related Rust functions for improved performance tuning
+ */
+/**
+ * Cache optimization hints and recommendations
+ */
+interface CacheOptimizationHints {
+    current_strategy: string;
+    recommended_strategy: string;
+    estimated_improvement_percent: number;
+    suggested_memory_mb: number;
+    notes: string[];
+}
+/**
+ * Optimal cache configuration recommendations
+ */
+interface OptimalCacheConfig {
+    parse_cache_size: number;
+    resolve_cache_size: number;
+    compile_cache_size: number;
+    css_gen_cache_size: number;
+    recommended_eviction_policy: string;
+    ttl_seconds: number;
+    expected_hit_rate_percent: number;
+}
+/**
+ * Cache statistics from all layers
+ */
+interface CacheStatistics {
+    parse_cache: {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+    resolve_cache: {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+    compile_cache: {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+    css_gen_cache: {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+    overall_hit_rate: number;
+    total_memory_bytes: number;
+}
+/**
+ * Get comprehensive cache statistics across all layers
+ * Useful for monitoring and optimization
+ *
+ * @returns Cache stats including hit rates, sizes, and recommendations
+ * @example
+ * ```ts
+ * const stats = getCacheStatistics()
+ * console.log(`Overall hit rate: ${stats.overall_hit_rate}%`)
+ * console.log(`Total memory used: ${stats.total_memory_bytes / 1024}KB`)
+ * ```
+ */
+declare function getCacheStatistics(): CacheStatistics;
+/**
+ * Clear all caches (parse, resolve, compile, CSS generation)
+ * Use when switching themes or major configuration changes
+ *
+ * @example
+ * ```ts
+ * // Clear before switching themes
+ * clearAllCaches()
+ * const css = await generateCssNative(classes, { theme: newTheme })
+ * ```
+ */
+declare function clearAllCaches(): void;
+/**
+ * Clear only the parse cache
+ * Useful when parser behavior changes or cache gets stale
+ */
+declare function clearParseCache(): void;
+/**
+ * Clear only the resolve cache
+ * Use when theme configuration changes
+ */
+declare function clearResolveCache(): void;
+/**
+ * Clear only the compile cache
+ * Use when Tailwind configuration changes
+ */
+declare function clearCompileCache(): void;
+/**
+ * Clear only the CSS generation cache
+ * Use when theme or layout changes
+ */
+declare function clearCssGenCache(): void;
+/**
+ * Get optimization hints based on current cache performance
+ * Analyzes hit rates and suggests improvements
+ *
+ * @param hitRatePercent - Current hit rate (0-100)
+ * @param memoryUsedMb - Memory currently used in MB
+ * @returns Optimization recommendations
+ *
+ * @example
+ * ```ts
+ * const stats = getCacheStatistics()
+ * const hints = getCacheOptimizationHints(
+ *   stats.overall_hit_rate,
+ *   stats.total_memory_bytes / (1024 * 1024)
+ * )
+ * console.log(`Recommendation: ${hints.recommended_strategy}`)
+ * console.log(`Potential improvement: ${hints.estimated_improvement_percent}%`)
+ * ```
+ */
+declare function getCacheOptimizationHints(hitRatePercent: number, memoryUsedMb: number): CacheOptimizationHints;
+/**
+ * Estimate optimal cache configuration for your workload
+ * Analyzes typical patterns and recommends sizes
+ *
+ * @param totalBudgetMb - Maximum memory budget in MB
+ * @param workloadType - "small" (< 100 files), "medium" (100-1000), "large" (1000+)
+ * @returns Recommended cache configuration
+ *
+ * @example
+ * ```ts
+ * const config = estimateOptimalCacheConfig(512, 'large')
+ * console.log(`Parse cache: ${config.parse_cache_size}MB`)
+ * console.log(`Expected hit rate: ${config.expected_hit_rate_percent}%`)
+ * ```
+ */
+declare function estimateOptimalCacheConfig(totalBudgetMb: number, workloadType: "small" | "medium" | "large"): OptimalCacheConfig;
+/**
+ * Read cache from disk (persistence)
+ * Restores cached data from previous sessions
+ *
+ * @param cachePath - Path to cache file
+ * @returns Entries loaded from disk
+ *
+ * @example
+ * ```ts
+ * const entries = cacheRead('./.tw-cache/scan.json')
+ * // Warm up cache with persisted data
+ * ```
+ */
+declare function cacheRead(cachePath: string): Array<{
+    file: string;
+    contentHash: string;
+    classes: string[];
+    mtimeMs: number;
+    sizeBytes: number;
+}>;
+/**
+ * Write cache to disk (persistence)
+ * Saves cached data for next session
+ *
+ * @param cachePath - Path where cache should be written
+ * @param entries - Cache entries to persist
+ * @returns Success status
+ *
+ * @example
+ * ```ts
+ * const stats = getCacheStatistics()
+ * const success = cacheWrite(
+ *   './.tw-cache/scan.json',
+ *   // entries array from previous scan
+ * )
+ * ```
+ */
+declare function cacheWrite(cachePath: string, entries: Array<{
+    file: string;
+    contentHash: string;
+    classes: string[];
+    mtimeMs: number;
+    sizeBytes: number;
+}>): boolean;
+/**
+ * Calculate cache priority score for file ordering
+ * Useful for prioritizing which files to scan first
+ *
+ * @param mtimeMs - File modification time in milliseconds
+ * @param sizeBytes - File size in bytes
+ * @param hitCount - Number of times this file was accessed from cache
+ * @returns Priority score (higher = process first)
+ *
+ * @example
+ * ```ts
+ * const priority = cachePriority(Date.now(), 2048, 5)
+ * // Use priority to sort files for scanning
+ * ```
+ */
+declare function cachePriority(mtimeMs: number, sizeBytes: number, hitCount: number): number;
+
+/**
+ * themeResolutionNative.ts
+ *
+ * Phase 5.1: Theme Resolution Extended - Advanced theme configuration handling
+ * Exposes 7 theme resolution functions for complex Tailwind configurations
+ */
+/**
+ * Validation result for theme config
+ */
+interface ThemeValidationResult {
+    is_valid: boolean;
+    errors: string[];
+    warnings: string[];
+    suggestions: string[];
+}
+/**
+ * Resolved variant configuration
+ */
+interface ResolvedVariantConfig {
+    variants: string[];
+    supported: string[];
+    deprecated: string[];
+    conflicting: string[];
+}
+/**
+ * Theme cascade resolution result
+ */
+interface ThemeCascadeResult {
+    base_theme: Record<string, unknown>;
+    user_overrides: Record<string, unknown>;
+    merged_theme: Record<string, unknown>;
+    conflict_resolutions: Array<{
+        key: string;
+        base_value: unknown;
+        override_value: unknown;
+        resolution: "override" | "merge" | "error";
+    }>;
+}
+/**
+ * Class name resolution from theme
+ */
+interface ResolvedClassName {
+    class_name: string;
+    property: string;
+    value: string;
+    from_theme_path: string;
+    is_responsive: boolean;
+    variants: string[];
+}
+/**
+ * Conflict group information
+ */
+interface ConflictGroupInfo {
+    group_name: string;
+    conflicting_classes: string[];
+    description: string;
+    resolution_strategy: string;
+}
+/**
+ * Get all resolved variants from theme configuration
+ * Parses theme config and returns all variant prefixes
+ *
+ * @param configJson - JSON string of theme configuration
+ * @returns Resolved variants with metadata
+ *
+ * @example
+ * ```ts
+ * const config = {
+ *   screens: { md: '768px', lg: '1024px' },
+ *   state: { hover: '&:hover', focus: '&:focus' }
+ * }
+ * const variants = resolveVariants(JSON.stringify(config))
+ * console.log(variants.variants)  // ['md', 'lg', 'hover', 'focus', ...]
+ * ```
+ */
+declare function resolveVariants(configJson: string): ResolvedVariantConfig;
+/**
+ * Validate theme configuration for correctness
+ * Checks for common issues and provides warnings
+ *
+ * @param configJson - JSON string of theme configuration
+ * @returns Validation result with errors and suggestions
+ *
+ * @example
+ * ```ts
+ * const result = validateThemeConfig(JSON.stringify(myTheme))
+ * if (!result.is_valid) {
+ *   console.error('Errors:', result.errors)
+ *   console.warn('Warnings:', result.warnings)
+ * }
+ * ```
+ */
+declare function validateThemeConfig(configJson: string): ThemeValidationResult;
+/**
+ * Resolve theme cascade (base + overrides)
+ * Merges base theme with user overrides intelligently
+ *
+ * @param baseThemeJson - Base theme configuration
+ * @param overridesJson - User overrides configuration
+ * @returns Merged theme with conflict information
+ *
+ * @example
+ * ```ts
+ * const cascade = resolveCascade(
+ *   JSON.stringify(baseTheme),
+ *   JSON.stringify(userOverrides)
+ * )
+ * console.log(cascade.merged_theme)
+ * console.log('Conflicts resolved:', cascade.conflict_resolutions.length)
+ * ```
+ */
+declare function resolveCascade(baseThemeJson: string, overridesJson: string): ThemeCascadeResult;
+/**
+ * Resolve class names from theme
+ * Maps Tailwind class names to theme values
+ *
+ * @param classNames - Array of Tailwind class names (e.g., ["text-lg", "bg-blue-600"])
+ * @param themeJson - Theme configuration
+ * @returns Resolved class name information
+ *
+ * @example
+ * ```ts
+ * const resolved = resolveClassNames(
+ *   ['text-lg', 'bg-blue-600', 'md:p-4'],
+ *   JSON.stringify(theme)
+ * )
+ * resolved.forEach(item => {
+ *   console.log(`${item.class_name} -> ${item.property}: ${item.value}`)
+ * })
+ * ```
+ */
+declare function resolveClassNames(classNames: string[], themeJson: string): ResolvedClassName[];
+/**
+ * Get conflict group information
+ * Identifies classes that conflict with each other
+ *
+ * @param groupName - Conflict group name (e.g., "display", "position", "flex-direction")
+ * @param themeJson - Theme configuration
+ * @returns Information about the conflict group
+ *
+ * @example
+ * ```ts
+ * const info = resolveConflictGroup('display', JSON.stringify(theme))
+ * console.log('Conflicting classes:', info.conflicting_classes)
+ * console.log('Strategy:', info.resolution_strategy)
+ * ```
+ */
+declare function resolveConflictGroup(groupName: string, themeJson: string): ConflictGroupInfo;
+/**
+ * Resolve theme value from key path
+ * Navigates nested theme config to find values
+ *
+ * @param keyPath - Dot-separated path (e.g., "colors.blue.600")
+ * @param themeJson - Theme configuration
+ * @returns Resolved value or null if not found
+ *
+ * @example
+ * ```ts
+ * const color = resolveThemeValue('colors.blue.600', JSON.stringify(theme))
+ * console.log(color)  // "#2563eb" or similar
+ * ```
+ */
+declare function resolveThemeValue(keyPath: string, themeJson: string): string | null;
+/**
+ * Get all simple variants from configuration
+ * Returns variants that don't require complex selector nesting
+ *
+ * @param configJson - Theme/variant configuration
+ * @returns Array of simple variant names
+ *
+ * @example
+ * ```ts
+ * const simpleVariants = resolveSimpleVariants(JSON.stringify(config))
+ * console.log(simpleVariants)
+ * // ["hover", "focus", "active", "group-hover", ...]
+ * ```
+ */
+declare function resolveSimpleVariants(configJson: string): string[];
+
+/**
+ * streamingNative.ts
+ *
+ * Phase 5.1: Streaming & Incremental Processing - Handle file changes efficiently
+ * Exposes 8 functions for real-time incremental compilation
+ */
+/**
+ * File change notification
+ */
+interface FileChangeEvent {
+    file_path: string;
+    event_type: "added" | "modified" | "deleted";
+    old_content?: string;
+    new_content?: string;
+    timestamp_ms: number;
+}
+/**
+ * Processed file change result
+ */
+interface ProcessedFileChange {
+    file_path: string;
+    status: "processed" | "skipped" | "error";
+    old_classes: string[];
+    new_classes: string[];
+    added_classes: string[];
+    removed_classes: string[];
+    changed: boolean;
+    fingerprint: string;
+    error?: string;
+}
+/**
+ * Diff between two scan results
+ */
+interface FileDiff {
+    added_files: string[];
+    removed_files: string[];
+    modified_files: string[];
+    added_classes: string[];
+    removed_classes: string[];
+    total_changes: number;
+}
+/**
+ * File fingerprint for change detection
+ */
+interface FileFingerprint {
+    file_path: string;
+    content_hash: string;
+    size_bytes: number;
+    mtime_ms: number;
+    class_hash: string;
+    signature: string;
+}
+/**
+ * Incremental diff result
+ */
+interface IncrementalDiffResult {
+    is_changed: boolean;
+    changes_count: number;
+    diff: FileDiff;
+    processing_time_ms: number;
+}
+/**
+ * State injection result
+ */
+interface StateInjectionResult {
+    injected: boolean;
+    state_hash: string;
+    affected_files: number;
+    total_injected_bytes: number;
+}
+/**
+ * Stale entry pruning result
+ */
+interface PruneResult {
+    entries_before: number;
+    entries_after: number;
+    entries_removed: number;
+    freed_bytes: number;
+}
+/**
+ * Rebuilt workspace result
+ */
+interface RebuildWorkspaceResult {
+    total_files_scanned: number;
+    total_classes_found: number;
+    unique_classes: number;
+    build_time_ms: number;
+    files_with_changes: number;
+}
+/**
+ * Process a single file change event
+ * Called when a file is added, modified, or deleted
+ *
+ * @param fileChangeJson - JSON string describing the file change
+ * @returns Processing result with class changes
+ *
+ * @example
+ * ```ts
+ * const change = processFileChange(JSON.stringify({
+ *   file_path: 'src/Button.tsx',
+ *   event_type: 'modified',
+ *   new_content: 'export const Button = ...',
+ *   timestamp_ms: Date.now()
+ * }))
+ *
+ * console.log('Added classes:', change.added_classes)
+ * console.log('Removed classes:', change.removed_classes)
+ * ```
+ */
+declare function processFileChange(fileChangeJson: string): ProcessedFileChange;
+/**
+ * Compute incremental diff between old and new scan results
+ * Efficient way to identify only what changed
+ *
+ * @param oldScanJson - JSON string of previous scan result
+ * @param newScanJson - JSON string of new scan result
+ * @returns Diff showing what changed
+ *
+ * @example
+ * ```ts
+ * const oldResult = scanWorkspace('./src')
+ * // ... files changed ...
+ * const newResult = scanWorkspace('./src')
+ *
+ * const diff = computeIncrementalDiff(
+ *   JSON.stringify(oldResult),
+ *   JSON.stringify(newResult)
+ * )
+ *
+ * if (diff.is_changed) {
+ *   console.log(`${diff.changes_count} files changed`)
+ *   console.log('Added:', diff.diff.added_classes)
+ *   console.log('Removed:', diff.diff.removed_classes)
+ * }
+ * ```
+ */
+declare function computeIncrementalDiff(oldScanJson: string, newScanJson: string): IncrementalDiffResult;
+/**
+ * Create a fingerprint of a file for change detection
+ * Use fingerprints to quickly check if file needs reprocessing
+ *
+ * @param filePath - Path to file
+ * @param fileContent - File content
+ * @returns File fingerprint
+ *
+ * @example
+ * ```ts
+ * const fingerprint = createFingerprint('src/Button.tsx', fileContent)
+ * // Store fingerprint, check later if content changed
+ * const newFingerprint = createFingerprint('src/Button.tsx', newContent)
+ * if (fingerprint.signature !== newFingerprint.signature) {
+ *   // Content changed, needs reprocessing
+ * }
+ * ```
+ */
+declare function createFingerprint(filePath: string, fileContent: string): FileFingerprint;
+/**
+ * Inject state hash into compiled CSS
+ * Marks CSS with version/state hash for cache busting
+ *
+ * @param css - Raw CSS string
+ * @param stateHash - State hash to inject
+ * @returns Modified CSS with injected state
+ *
+ * @example
+ * ```ts
+ * const css = compileCssNative2(['px-4', 'bg-blue-600'])
+ * const withState = injectStateHash(css, 'v5-hash-123')
+ * // CSS now includes version marker for cache control
+ * ```
+ */
+declare function injectStateHash(css: string, stateHash: string): StateInjectionResult;
+/**
+ * Prune stale entries from cache
+ * Removes old/unused cache entries to free memory
+ *
+ * @param maxAgeSeconds - Remove entries older than this many seconds
+ * @param maxEntries - Keep only this many most-recent entries
+ * @returns Result of pruning operation
+ *
+ * @example
+ * ```ts
+ * // Remove cache entries older than 1 hour, keep max 10000 entries
+ * const result = pruneStaleCacheEntries(3600, 10000)
+ * console.log(`Freed ${result.freed_bytes / 1024}KB`)
+ * ```
+ */
+declare function pruneStaleCacheEntries(maxAgeSeconds: number, maxEntries: number): PruneResult;
+/**
+ * Rebuild workspace result from scratch
+ * Useful after major configuration changes
+ *
+ * @param rootDir - Root directory to scan
+ * @param extensions - File extensions to scan (e.g., [".tsx", ".ts"])
+ * @returns Rebuilt workspace result
+ *
+ * @example
+ * ```ts
+ * const result = rebuildWorkspaceResult('./src', ['.tsx', '.ts'])
+ * console.log(`Found ${result.unique_classes} unique classes`)
+ * console.log(`${result.files_with_changes} files had changes`)
+ * ```
+ */
+declare function rebuildWorkspaceResult(rootDir: string, extensions?: string[]): RebuildWorkspaceResult;
+/**
+ * Scan a single file with incremental state
+ * Returns only new/changed classes since last scan
+ *
+ * @param filePath - Path to file
+ * @param fileContent - File content
+ * @returns Updated classes and change status
+ *
+ * @example
+ * ```ts
+ * // On file change, get only what changed
+ * const file = scanFileNative('src/Button.tsx', newContent)
+ * if (file.changed) {
+ *   console.log('Added:', file.added_classes)
+ *   console.log('Removed:', file.removed_classes)
+ * }
+ * ```
+ */
+declare function scanFileNative(filePath: string, fileContent: string): {
+    file: string;
+    classes: string[];
+    added_classes: string[];
+    removed_classes: string[];
+    changed: boolean;
+};
+/**
+ * Scan multiple files in batch with incremental state
+ * Efficient batch processing of file changes
+ *
+ * @param filesJson - JSON array of {file, content} objects
+ * @returns Results for each file
+ *
+ * @example
+ * ```ts
+ * const files = [
+ *   { file: 'src/Button.tsx', content: newButtonContent },
+ *   { file: 'src/Card.tsx', content: newCardContent }
+ * ]
+ * const results = scanFilesBatchNative(JSON.stringify(files))
+ * ```
+ */
+declare function scanFilesBatchNative(filesJson: string): Array<{
+    file: string;
+    classes: string[];
+    changed: boolean;
+}>;
+
+/**
+ * cssCompilationNative.ts
+ *
+ * Phase 5.2: Advanced CSS Compilation - Complex CSS generation and transformations
+ * Exposes 12 CSS compilation functions for animations, themes, and merging
+ */
+/**
+ * Compiled CSS rule result
+ */
+interface CompiledCssRule {
+    selector: string;
+    declarations: string;
+    properties: Array<{
+        key: string;
+        value: string;
+    }>;
+    specificity: number;
+}
+/**
+ * Compiled animation result
+ */
+interface CompiledAnimation {
+    animation_id: string;
+    keyframes_css: string;
+    animation_rule: string;
+    duration_ms: number;
+}
+/**
+ * Compiled theme result
+ */
+interface CompiledTheme {
+    selector: string;
+    variables: Array<{
+        name: string;
+        value: string;
+    }>;
+    variables_css: string;
+    theme_name: string;
+}
+/**
+ * CSS compile result with metadata
+ */
+interface CssCompileResult {
+    css: string;
+    resolved_classes: string[];
+    unknown_classes: string[];
+    size_bytes: number;
+    duration_ms: number;
+}
+/**
+ * tw_merge options
+ */
+interface TwMergeOptions {
+    separator?: string;
+    debug?: boolean;
+}
+/**
+ * Compile a single Tailwind class to CSS rule
+ * Full compilation pipeline: parse → resolve → generate
+ *
+ * @param input - Single Tailwind class (e.g., "md:hover:bg-blue-600/50")
+ * @returns Compiled CSS rule as JSON
+ *
+ * @example
+ * ```ts
+ * const rule = compileClass('md:hover:bg-blue-600')
+ * // Returns: {
+ * //   selector: '.md\\:hover\\:bg-blue-600',
+ * //   declarations: 'background-color: #2563eb;',
+ * //   ...
+ * // }
+ * ```
+ */
+declare function compileClass(input: string): CompiledCssRule;
+/**
+ * Compile multiple Tailwind classes to CSS rules
+ * Batch processing with parallel compilation
+ *
+ * @param inputs - Array of Tailwind classes
+ * @returns JSON string of compiled rules
+ *
+ * @example
+ * ```ts
+ * const rules = compileClasses(['px-4', 'bg-blue-600', 'hover:opacity-80'])
+ * ```
+ */
+declare function compileClasses(inputs: string[]): CssCompileResult;
+/**
+ * One-step: class → CSS string
+ * Compiles and generates in single call
+ *
+ * @param input - Single Tailwind class
+ * @param minify - Whether to minify output (default: false)
+ * @returns Generated CSS string
+ *
+ * @example
+ * ```ts
+ * const css = compileToCss('bg-blue-600')
+ * // Returns: ".bg-blue-600 { background-color: #2563eb; }"
+ *
+ * const minified = compileToCss('bg-blue-600', true)
+ * // Returns: ".bg-blue-600{background-color:#2563eb}"
+ * ```
+ */
+declare function compileToCss(input: string, minify?: boolean): string;
+/**
+ * Batch compile to CSS
+ * Compiles multiple classes and generates combined CSS
+ *
+ * @param inputs - Array of Tailwind classes
+ * @param minify - Whether to minify output
+ * @returns Combined CSS string
+ *
+ * @example
+ * ```ts
+ * const css = compileToCssBatch(['px-4', 'bg-blue-600'], true)
+ * ```
+ */
+declare function compileToCssBatch(inputs: string[], minify?: boolean): string;
+/**
+ * Minify CSS string
+ * Removes unnecessary whitespace and formatting
+ *
+ * @param css - Raw CSS string
+ * @returns Minified CSS (40-60% size reduction)
+ *
+ * @example
+ * ```ts
+ * const css = ".px-4 { padding-left: 1rem; padding-right: 1rem; }"
+ * const minified = minifyCss(css)
+ * // Returns: ".px-4{padding-left:1rem;padding-right:1rem}"
+ * ```
+ */
+declare function minifyCss(css: string): string;
+/**
+ * Compile animation from from/to states
+ * Generates @keyframes and animation rule
+ *
+ * @param animationName - Animation name
+ * @param from - From state classes (e.g., "opacity-0 scale-95")
+ * @param to - To state classes (e.g., "opacity-100 scale-100")
+ * @returns Compiled animation with keyframes
+ *
+ * @example
+ * ```ts
+ * const anim = compileAnimation('fade-in', 'opacity-0', 'opacity-100')
+ * console.log(anim.keyframes_css)  // @keyframes fade-in { ... }
+ * console.log(anim.animation_rule) // animation: fade-in 300ms;
+ * ```
+ */
+declare function compileAnimation(animationName: string, from: string, to: string): CompiledAnimation;
+/**
+ * Compile keyframes from stop definitions
+ * Creates @keyframes from percentage stops
+ *
+ * @param name - Keyframes name
+ * @param stopsJson - JSON array of stops: `[{"stop":"0%","classes":"opacity-0"}...]`
+ * @returns Compiled @keyframes rule
+ *
+ * @example
+ * ```ts
+ * const kf = compileKeyframes('slide-in', JSON.stringify([
+ *   { stop: '0%', classes: 'translate-x-full' },
+ *   { stop: '100%', classes: 'translate-x-0' }
+ * ]))
+ * ```
+ */
+declare function compileKeyframes(name: string, stopsJson: string): CompiledAnimation;
+/**
+ * Compile theme to CSS variables
+ * Converts token map to CSS custom properties
+ *
+ * @param tokensJson - Theme tokens as JSON
+ * @param themeName - Theme name ("light", "dark", etc.)
+ * @param prefix - CSS variable prefix (e.g., "tw" → "--tw-color-primary")
+ * @returns Compiled theme with variables CSS
+ *
+ * @example
+ * ```ts
+ * const theme = compileTheme(
+ *   JSON.stringify({ colors: { blue: { 600: '#2563eb' } } }),
+ *   'light',
+ *   'tw'
+ * )
+ * // Returns CSS: :root { --tw-color-blue-600: #2563eb; }
+ * ```
+ */
+declare function compileTheme(tokensJson: string, themeName: string, prefix: string): CompiledTheme;
+/**
+ * Merge conflicting Tailwind classes
+ * Resolves conflicts intelligently (last-one-wins by default)
+ *
+ * @param classString - Space-separated class string (e.g., "px-4 px-8 bg-red-500 bg-blue-600")
+ * @returns Merged classes with conflicts resolved
+ *
+ * @example
+ * ```ts
+ * const merged = twMerge('px-4 px-8 bg-red-500 bg-blue-600')
+ * // Returns: "px-8 bg-blue-600"
+ * ```
+ */
+declare function twMerge(classString: string): string;
+/**
+ * Merge multiple class strings
+ * Combines and resolves conflicts across multiple strings
+ *
+ * @param classStrings - Array of class strings
+ * @returns Merged result
+ *
+ * @example
+ * ```ts
+ * const merged = twMergeMany([
+ *   'px-4 hover:bg-blue-600',
+ *   'px-8 hover:opacity-80'
+ * ])
+ * // Returns: "px-8 hover:bg-blue-600 hover:opacity-80"
+ * ```
+ */
+declare function twMergeMany(classStrings: string[]): string;
+/**
+ * Merge with custom separator
+ * Useful for non-standard class separators
+ *
+ * @param classString - Classes to merge
+ * @param options - Merge options (separator, debug)
+ * @returns Merged classes
+ *
+ * @example
+ * ```ts
+ * const merged = twMergeWithSeparator(
+ *   'px-4,px-8,bg-red-500,bg-blue-600',
+ *   { separator: ',' }
+ * )
+ * ```
+ */
+declare function twMergeWithSeparator(classString: string, options: TwMergeOptions): string;
+/**
+ * Merge many with custom separator
+ * Batch merge with custom separator
+ *
+ * @param classStrings - Array of class strings
+ * @param options - Merge options
+ * @returns Merged result
+ */
+declare function twMergeManyWithSeparator(classStrings: string[], options: TwMergeOptions): string;
+/**
+ * Raw merge from class lists
+ * Direct merge without preprocessing
+ *
+ * @param classLists - Array of class lists
+ * @returns Merged classes
+ *
+ * @example
+ * ```ts
+ * const merged = twMergeRaw(['px-4 px-8', 'bg-red bg-blue'])
+ * ```
+ */
+declare function twMergeRaw(classLists: string[]): string;
+
+/**
+ * idRegistryNative.ts
+ *
+ * Phase 5.2: ID Registry Management - Efficient ID generation and lookup
+ * Exposes 16 ID registry functions for deterministic class/component identification
+ */
+/**
+ * Registry snapshot data
+ */
+interface RegistrySnapshot {
+    handle: number;
+    next_id: number;
+    entries: Array<{
+        name: string;
+        id: number;
+    }>;
+    total_entries: number;
+}
+/**
+ * Create a new ID generator
+ * Returns a handle to be used in subsequent operations
+ *
+ * @returns Generator handle (u32)
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryCreate()
+ * // Use handle for all subsequent operations
+ * try {
+ *   const id = idRegistryGenerate(handle, 'MyComponent')
+ *   // ... use id ...
+ * } finally {
+ *   idRegistryDestroy(handle)  // Clean up
+ * }
+ * ```
+ */
+declare function idRegistryCreate(): number;
+/**
+ * Generate a new ID for a name
+ * Same name always returns same ID (deterministic)
+ *
+ * @param handle - Generator handle from idRegistryCreate()
+ * @param name - Identifier name (e.g., component name, class name)
+ * @returns Generated ID
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryCreate()
+ * const id1 = idRegistryGenerate(handle, 'Button')  // Returns 1
+ * const id2 = idRegistryGenerate(handle, 'Button')  // Returns 1 (same)
+ * const id3 = idRegistryGenerate(handle, 'Card')    // Returns 2 (different)
+ * ```
+ */
+declare function idRegistryGenerate(handle: number, name: string): number;
+/**
+ * Lookup existing ID for a name
+ * Returns -1 if not found
+ *
+ * @param handle - Generator handle
+ * @param name - Name to look up
+ * @returns ID if found, -1 if not found
+ *
+ * @example
+ * ```ts
+ * const id = idRegistryLookup(handle, 'Button')
+ * if (id !== -1) {
+ *   console.log(`Button has ID: ${id}`)
+ * } else {
+ *   console.log('Button not in registry yet')
+ * }
+ * ```
+ */
+declare function idRegistryLookup(handle: number, name: string): number;
+/**
+ * Get the next ID that would be assigned
+ * Useful for knowing how many unique IDs exist
+ *
+ * @param handle - Generator handle
+ * @returns Next available ID
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryCreate()
+ * idRegistryGenerate(handle, 'Button')
+ * idRegistryGenerate(handle, 'Card')
+ * const nextId = idRegistryNext(handle)  // Returns 2 (next available)
+ * ```
+ */
+declare function idRegistryNext(handle: number): number;
+/**
+ * Destroy a registry (clean up resources)
+ * Must be called when done with registry
+ *
+ * @param handle - Generator handle
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryCreate()
+ * try {
+ *   // Use registry
+ * } finally {
+ *   idRegistryDestroy(handle)
+ * }
+ * ```
+ */
+declare function idRegistryDestroy(handle: number): void;
+/**
+ * Reset registry to initial state
+ * Clears all entries but reuses handle
+ *
+ * @param handle - Generator handle
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryCreate()
+ * idRegistryGenerate(handle, 'Component1')
+ * idRegistryGenerate(handle, 'Component2')
+ * idRegistryReset(handle)  // Clear all
+ * const id = idRegistryNext(handle)  // Back to 0
+ * ```
+ */
+declare function idRegistryReset(handle: number): void;
+/**
+ * Get snapshot of current registry state
+ * Useful for serialization/debugging
+ *
+ * @param handle - Generator handle
+ * @returns Snapshot with all entries
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryCreate()
+ * idRegistryGenerate(handle, 'Button')
+ * idRegistryGenerate(handle, 'Card')
+ * const snapshot = idRegistrySnapshot(handle)
+ * console.log(JSON.stringify(snapshot, null, 2))
+ * ```
+ */
+declare function idRegistrySnapshot(handle: number): RegistrySnapshot;
+/**
+ * Get count of active registries
+ * Useful for monitoring resource usage
+ *
+ * @returns Number of active generator handles
+ *
+ * @example
+ * ```ts
+ * console.log(`Active registries: ${idRegistryActiveCount()}`)
+ * ```
+ */
+declare function idRegistryActiveCount(): number;
+/**
+ * Register a property name with global registry
+ * Maps property names to consistent IDs
+ *
+ * @param propertyName - Property name (e.g., "background-color")
+ * @returns Assigned property ID
+ *
+ * @example
+ * ```ts
+ * const bgColorId = registerPropertyName('background-color')
+ * const paddingId = registerPropertyName('padding')
+ * ```
+ */
+declare function registerPropertyName(propertyName: string): number;
+/**
+ * Register a value name with global registry
+ * Maps values to consistent IDs
+ *
+ * @param valueName - Value name (e.g., "blue-600")
+ * @returns Assigned value ID
+ *
+ * @example
+ * ```ts
+ * const blueId = registerValueName('blue-600')
+ * const redId = registerValueName('red-500')
+ * ```
+ */
+declare function registerValueName(valueName: string): number;
+/**
+ * Convert property ID back to name
+ * Reverse lookup for serialized data
+ *
+ * @param propertyId - Property ID
+ * @returns Property name or empty string if not found
+ *
+ * @example
+ * ```ts
+ * const bgColorId = registerPropertyName('background-color')
+ * const name = propertyIdToString(bgColorId)
+ * console.log(name)  // "background-color"
+ * ```
+ */
+declare function propertyIdToString(propertyId: number): string;
+/**
+ * Convert value ID back to name
+ * Reverse lookup for serialized data
+ *
+ * @param valueId - Value ID
+ * @returns Value name or empty string if not found
+ *
+ * @example
+ * ```ts
+ * const blueId = registerValueName('blue-600')
+ * const value = valueIdToString(blueId)
+ * console.log(value)  // "blue-600"
+ * ```
+ */
+declare function valueIdToString(valueId: number): string;
+/**
+ * Reverse lookup: find property by ID
+ * Alternative way to look up property names
+ *
+ * @param propertyId - Property ID to look up
+ * @returns Property name
+ */
+declare function reverseLookupProperty(propertyId: number): string;
+/**
+ * Reverse lookup: find value by ID
+ * Alternative way to look up value names
+ *
+ * @param valueId - Value ID to look up
+ * @returns Value name
+ */
+declare function reverseLookupValue(valueId: number): string;
+/**
+ * Export registry state for persistence
+ * Useful for saving/restoring registry data
+ *
+ * @param handle - Generator handle
+ * @returns Serialized registry state
+ *
+ * @example
+ * ```ts
+ * const exported = idRegistryExport(handle)
+ * // Save to file/database
+ * ```
+ */
+declare function idRegistryExport(handle: number): string;
+/**
+ * Import registry state
+ * Restore registry from saved state
+ *
+ * @param importedData - Serialized registry data
+ * @returns New handle with imported data
+ *
+ * @example
+ * ```ts
+ * const handle = idRegistryImport(savedData)
+ * // Registry restored with same IDs
+ * ```
+ */
+declare function idRegistryImport(importedData: string): number;
+
+/**
+ * redisNative.ts
+ *
+ * Phase 5.3: Redis Integration - Distributed caching and cluster support
+ * Exposes 40 Redis functions for high-performance distributed CSS compilation caching
+ */
+/**
+ * Redis pool configuration
+ */
+interface RedisCacheConfig {
+    host: string;
+    port: number;
+    database: number;
+    password?: string;
+    pool_size: number;
+    connection_timeout_ms: number;
+}
+/**
+ * Redis pool statistics
+ */
+interface RedisPoolStats {
+    connected_count: number;
+    idle_count: number;
+    waiting_count: number;
+    total_requests: number;
+    total_errors: number;
+}
+/**
+ * Redis cluster node information
+ */
+interface RedisClusterNode {
+    node_id: string;
+    host: string;
+    port: number;
+    is_master: boolean;
+    slot_range: Array<{
+        start: number;
+        end: number;
+    }>;
+    connected: boolean;
+}
+/**
+ * Redis cluster status
+ */
+interface RedisClusterStatus {
+    enabled: boolean;
+    cluster_state: string;
+    nodes: RedisClusterNode[];
+    slots_assigned: number;
+    slots_ok: number;
+    slots_fail: number;
+}
+/**
+ * Key expiration information
+ */
+interface KeyExpiration {
+    key: string;
+    ttl_seconds: number;
+    expiration_timestamp: number;
+    is_persistent: boolean;
+}
+/**
+ * Pub/Sub message
+ */
+interface PubSubMessage {
+    channel: string;
+    message: string;
+    timestamp_ms: number;
+    subscriber_count: number;
+}
+/**
+ * Connection pool information
+ */
+interface PoolInfo {
+    host: string;
+    port: number;
+    pool_size: number;
+    active_connections: number;
+    idle_connections: number;
+    average_latency_ms: number;
+}
+/**
+ * Ping Redis server for connectivity check
+ *
+ * @returns "PONG" if connected, error message otherwise
+ *
+ * @example
+ * ```ts
+ * const response = redisPing()
+ * if (response === "PONG") console.log("Connected")
+ * ```
+ */
+declare function redisPing(): string;
+/**
+ * Get value from Redis
+ *
+ * @param key - Cache key
+ * @returns Value if found, null if not found
+ *
+ * @example
+ * ```ts
+ * const value = redisGet('compiled:bg-blue-600')
+ * if (value) console.log(JSON.parse(value))
+ * ```
+ */
+declare function redisGet(key: string): string | null;
+/**
+ * Set value in Redis
+ *
+ * @param key - Cache key
+ * @param value - Value to store
+ * @param ttl_seconds - Time to live in seconds (optional)
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisSet('compiled:bg-blue-600', JSON.stringify(css), 3600)
+ * ```
+ */
+declare function redisSet(key: string, value: string, ttl_seconds?: number): string;
+/**
+ * Delete key from Redis
+ *
+ * @param key - Cache key
+ * @returns Number of keys deleted
+ *
+ * @example
+ * ```ts
+ * const deleted = redisDelete('compiled:bg-blue-600')
+ * console.log(`Deleted ${deleted} keys`)
+ * ```
+ */
+declare function redisDelete(key: string): number;
+/**
+ * Check if key exists in Redis
+ *
+ * @param key - Cache key
+ * @returns 1 if exists, 0 if not
+ *
+ * @example
+ * ```ts
+ * if (redisExists('compiled:bg-blue-600')) {
+ *   console.log('Cache hit')
+ * }
+ * ```
+ */
+declare function redisExists(key: string): number;
+/**
+ * Get multiple values from Redis (atomic operation)
+ *
+ * @param keys - Array of cache keys
+ * @returns Array of values (null for missing keys)
+ *
+ * @example
+ * ```ts
+ * const values = redisMget(['key1', 'key2', 'key3'])
+ * ```
+ */
+declare function redisMget(keys: string[]): Array<string | null>;
+/**
+ * Set multiple key-value pairs in Redis (atomic operation)
+ *
+ * @param pairs - Array of [key, value] tuples
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisMset([
+ *   ['key1', 'value1'],
+ *   ['key2', 'value2']
+ * ])
+ * ```
+ */
+declare function redisMset(pairs: Array<[string, string]>): string;
+/**
+ * Flush all keys from current Redis database
+ *
+ * @returns Number of keys deleted
+ *
+ * @example
+ * ```ts
+ * const flushed = redisFlushDb()
+ * console.log(`Flushed ${flushed} keys from database`)
+ * ```
+ */
+declare function redisFlushDb(): number;
+/**
+ * Flush all keys from all Redis databases (cluster-wide)
+ *
+ * @returns Number of keys deleted
+ *
+ * @example
+ * ```ts
+ * const flushed = redisFlushAll()
+ * console.log(`Flushed ${flushed} keys from all databases`)
+ * ```
+ */
+declare function redisFlushAll(): number;
+/**
+ * Initialize Redis connection pool
+ *
+ * @param host - Redis host (e.g., "localhost")
+ * @param port - Redis port (default: 6379)
+ * @param pool_size - Connection pool size (default: 32)
+ * @returns Pool info JSON
+ *
+ * @example
+ * ```ts
+ * const info = redisPoolConnect('localhost', 6379, 32)
+ * console.log(info)
+ * ```
+ */
+declare function redisPoolConnect(host: string, port: number, pool_size?: number): string;
+/**
+ * Get Redis pool statistics
+ *
+ * @returns Pool stats as JSON string
+ *
+ * @example
+ * ```ts
+ * const stats = redisPoolStats()
+ * const parsed: RedisPoolStats = JSON.parse(stats)
+ * console.log(`Connected: ${parsed.connected_count}`)
+ * ```
+ */
+declare function redisPoolStats(): RedisPoolStats;
+/**
+ * Reconnect Redis pool after disconnect
+ *
+ * @returns "OK" if reconnected
+ *
+ * @example
+ * ```ts
+ * const result = redisPoolReconnect()
+ * console.log(result)
+ * ```
+ */
+declare function redisPoolReconnect(): string;
+/**
+ * Enable Redis cluster mode
+ *
+ * @param initial_nodes - Initial cluster nodes (host:port format)
+ * @returns Cluster status JSON
+ *
+ * @example
+ * ```ts
+ * const status = redisEnableCluster(['localhost:6379', 'localhost:6380'])
+ * ```
+ */
+declare function redisEnableCluster(initial_nodes: string[]): RedisClusterStatus;
+/**
+ * Disable Redis cluster mode
+ *
+ * @returns "OK" when disabled
+ *
+ * @example
+ * ```ts
+ * const result = redisDisableCluster()
+ * ```
+ */
+declare function redisDisableCluster(): string;
+/**
+ * Get current Redis cluster status
+ *
+ * @returns Cluster status information
+ *
+ * @example
+ * ```ts
+ * const status = redisClusterStatus()
+ * if (status.enabled) console.log(`Cluster has ${status.nodes.length} nodes`)
+ * ```
+ */
+declare function redisClusterStatus(): RedisClusterStatus;
+/**
+ * Subscribe to Redis pub/sub channel
+ *
+ * @param channel - Channel name
+ * @param callback - Function to call on message (optional)
+ * @returns Subscription ID
+ *
+ * @example
+ * ```ts
+ * const id = redisSubscribe('cache:updates', (msg) => {
+ *   console.log(`Update: ${msg.message}`)
+ * })
+ * ```
+ */
+declare function redisSubscribe(channel: string): string;
+/**
+ * Publish message to Redis pub/sub channel
+ *
+ * @param channel - Channel name
+ * @param message - Message to publish
+ * @returns Number of subscribers that received the message
+ *
+ * @example
+ * ```ts
+ * const count = redisPublish('cache:updates', 'CSS compiled')
+ * console.log(`Delivered to ${count} subscribers`)
+ * ```
+ */
+declare function redisPublish(channel: string, message: string): number;
+/**
+ * Set expiration on key
+ *
+ * @param key - Cache key
+ * @param ttl_seconds - Time to live in seconds
+ * @returns 1 if timeout set, 0 if key doesn't exist
+ *
+ * @example
+ * ```ts
+ * redisExpirationSet('compiled:bg-blue-600', 3600)
+ * ```
+ */
+declare function redisExpirationSet(key: string, ttl_seconds: number): number;
+/**
+ * Get expiration info for key
+ *
+ * @param key - Cache key
+ * @returns Expiration information
+ *
+ * @example
+ * ```ts
+ * const info = redisExpirationGet('compiled:bg-blue-600')
+ * console.log(`TTL: ${info.ttl_seconds} seconds`)
+ * ```
+ */
+declare function redisExpirationGet(key: string): KeyExpiration;
+/**
+ * Get Redis server info
+ *
+ * @returns Server information JSON
+ *
+ * @example
+ * ```ts
+ * const info = redisInfo()
+ * ```
+ */
+declare function redisInfo(): string;
+/**
+ * Monitor Redis operations in real-time (for debugging)
+ *
+ * @returns Monitor output stream
+ *
+ * @example
+ * ```ts
+ * const monitor = redisMonitor()
+ * // Logs all Redis operations
+ * ```
+ */
+declare function redisMonitor(): string;
+/**
+ * Get size of cache in bytes
+ *
+ * @returns Total memory usage in bytes
+ *
+ * @example
+ * ```ts
+ * const bytes = redisCacheSize()
+ * console.log(`Cache: ${bytes / 1024 / 1024} MB`)
+ * ```
+ */
+declare function redisCacheSize(): number;
+/**
+ * Get number of keys in cache
+ *
+ * @returns Total key count
+ *
+ * @example
+ * ```ts
+ * const count = redisCacheKeyCount()
+ * console.log(`Cached keys: ${count}`)
+ * ```
+ */
+declare function redisCacheKeyCount(): number;
+/**
+ * Clear Redis cache and reset statistics
+ *
+ * @returns Number of keys cleared
+ *
+ * @example
+ * ```ts
+ * const cleared = redisCacheClear()
+ * console.log(`Cleared ${cleared} keys`)
+ * ```
+ */
+declare function redisCacheClear(): number;
+/**
+ * Get Redis cache hit rate statistics
+ *
+ * @returns Hit rate percentage (0-100)
+ *
+ * @example
+ * ```ts
+ * const hitRate = redisCacheHitRate()
+ * console.log(`Hit rate: ${hitRate}%`)
+ * ```
+ */
+declare function redisCacheHitRate(): number;
+/**
+ * Enable Redis persistence (AOF/RDB)
+ *
+ * @param mode - "aof" or "rdb"
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisEnablePersistence('aof')
+ * ```
+ */
+declare function redisEnablePersistence(mode: string): string;
+/**
+ * Disable Redis persistence
+ *
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisDisablePersistence()
+ * ```
+ */
+declare function redisDisablePersistence(): string;
+/**
+ * Save Redis data to disk (snapshot)
+ *
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisSnapshot()
+ * ```
+ */
+declare function redisSnapshot(): string;
+/**
+ * Get Redis memory statistics and recommendations
+ *
+ * @returns Memory info JSON
+ *
+ * @example
+ * ```ts
+ * const memory = redisMemoryStats()
+ * console.log(memory)
+ * ```
+ */
+declare function redisMemoryStats(): string;
+/**
+ * Optimize Redis memory usage
+ *
+ * @returns Number of keys optimized
+ *
+ * @example
+ * ```ts
+ * const optimized = redisOptimizeMemory()
+ * console.log(`Optimized ${optimized} keys`)
+ * ```
+ */
+declare function redisOptimizeMemory(): number;
+/**
+ * Set Redis key eviction policy
+ *
+ * @param policy - LRU, LFU, TTL, RANDOM, etc.
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisSetEvictionPolicy('allkeys-lru')
+ * ```
+ */
+declare function redisSetEvictionPolicy(policy: string): string;
+/**
+ * Get current Redis eviction policy
+ *
+ * @returns Current policy name
+ *
+ * @example
+ * ```ts
+ * const policy = redisGetEvictionPolicy()
+ * console.log(`Eviction policy: ${policy}`)
+ * ```
+ */
+declare function redisGetEvictionPolicy(): string;
+/**
+ * Replicate data to another Redis instance
+ *
+ * @param target_host - Target host
+ * @param target_port - Target port
+ * @returns Number of keys replicated
+ *
+ * @example
+ * ```ts
+ * const replicated = redisReplicate('replica.example.com', 6379)
+ * console.log(`Replicated ${replicated} keys`)
+ * ```
+ */
+declare function redisReplicate(target_host: string, target_port: number): number;
+/**
+ * Get replication status
+ *
+ * @returns Replication info JSON
+ *
+ * @example
+ * ```ts
+ * const status = redisReplicationStatus()
+ * console.log(status)
+ * ```
+ */
+declare function redisReplicationStatus(): string;
+/**
+ * Sync cache between Redis instances (distributed cache sync)
+ *
+ * @param peers - Array of peer Redis addresses
+ * @returns Number of keys synced
+ *
+ * @example
+ * ```ts
+ * const synced = redisCacheSync(['redis1:6379', 'redis2:6379'])
+ * console.log(`Synced ${synced} keys`)
+ * ```
+ */
+declare function redisCacheSync(peers: string[]): number;
+/**
+ * Enable automatic cache warming
+ *
+ * @param key_pattern - Glob pattern for keys to warm (e.g., "compiled:*")
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisEnableCacheWarming('compiled:*')
+ * ```
+ */
+declare function redisEnableCacheWarming(key_pattern: string): string;
+/**
+ * Disable cache warming
+ *
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * redisDisableCacheWarming()
+ * ```
+ */
+declare function redisDisableCacheWarming(): string;
+/**
+ * Diagnose Redis connection issues
+ *
+ * @returns Diagnostic report
+ *
+ * @example
+ * ```ts
+ * const diagnosis = redisDiagnose()
+ * console.log(diagnosis)
+ * ```
+ */
+declare function redisDiagnose(): string;
+
+/**
+ * watchSystemNative.ts
+ *
+ * Phase 5.4: Watch System & File Monitoring - Real-time CSS recompilation
+ * Exposes 12 watch/monitoring functions for hot-reload and incremental compilation
+ */
+/**
+ * File watch event
+ */
+interface WatchEvent {
+    event_type: "create" | "modify" | "delete" | "rename";
+    file_path: string;
+    timestamp_ms: number;
+    is_dir: boolean;
 }
-interface NativeTransformResult {
-    code: string;
-    classes: string[];
-    changed: boolean;
-    rscJson?: string;
-    metadataJson?: string;
+/**
+ * Watch handle for tracking active watchers
+ */
+interface WatchHandle {
+    handle_id: number;
+    patterns: string[];
+    is_running: boolean;
+    created_at_ms: number;
 }
-interface ClassExtractResult {
-    classes: string[];
-    component_names: string[];
-    has_tw_usage: boolean;
-    has_use_client: boolean;
-    imports: string[];
+/**
+ * Watch statistics
+ */
+interface WatchStats {
+    active_watchers: number;
+    total_events: number;
+    events_this_second: number;
+    average_latency_ms: number;
+    largest_batch_size: number;
 }
-declare const getNativeBridge: () => NativeBridge;
-declare const resetNativeBridgeCache: () => void;
-declare const adaptNativeResult: (raw: NativeTransformResult) => {
-    code: string;
-    classes: string[];
-    changed: boolean;
-    rsc?: NativeRscResult;
-    metadata?: ComponentMetadata[];
-};
-
 /**
- * tailwind-styled-v5 — Compiler Index
+ * Start file system watcher for directory
+ *
+ * @param root_path - Directory to watch
+ * @param patterns - Glob patterns to match (e.g., ["*.tsx", "*.ts"])
+ * @returns Handle ID for the watcher
+ *
+ * @example
+ * ```ts
+ * const handle = startWatch('./src', ['*.tsx', '*.ts'])
+ * // Watcher is now active
+ * ```
+ */
+declare function startWatch(root_path: string, patterns?: string[]): number;
+/**
+ * Poll for watch events (non-blocking)
+ *
+ * @param handle - Watcher handle from startWatch()
+ * @param timeout_ms - Max time to wait for events (default: 100)
+ * @returns Array of watch events
+ *
+ * @example
+ * ```ts
+ * const handle = startWatch('./src', ['*.tsx'])
+ * const events = pollWatchEvents(handle, 100)
+ * events.forEach(evt => {
+ *   console.log(`${evt.event_type}: ${evt.file_path}`)
+ * })
+ * ```
+ */
+declare function pollWatchEvents(handle: number, timeout_ms?: number): WatchEvent[];
+/**
+ * Stop file system watcher
+ *
+ * @param handle - Watcher handle
+ * @returns Number of events processed before stopping
+ *
+ * @example
+ * ```ts
+ * const eventsProcessed = stopWatch(handle)
+ * console.log(`Watcher processed ${eventsProcessed} events`)
+ * ```
+ */
+declare function stopWatch(handle: number): number;
+/**
+ * Add pattern to active watcher
+ *
+ * @param handle - Watcher handle
+ * @param pattern - Glob pattern to add (e.g., "*.md")
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * watchAddPattern(handle, '*.md')
+ * // Now watching markdown files too
+ * ```
+ */
+declare function watchAddPattern(handle: number, pattern: string): string;
+/**
+ * Remove pattern from watcher
+ *
+ * @param handle - Watcher handle
+ * @param pattern - Pattern to remove
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * watchRemovePattern(handle, '*.md')
+ * ```
+ */
+declare function watchRemovePattern(handle: number, pattern: string): string;
+/**
+ * Get all active watcher handles
+ *
+ * @returns Array of active watch handles
+ *
+ * @example
+ * ```ts
+ * const handles = watchGetActiveHandles()
+ * console.log(`${handles.length} active watchers`)
+ * ```
+ */
+declare function watchGetActiveHandles(): WatchHandle[];
+/**
+ * Clear all active watchers
+ *
+ * @returns Number of watchers cleared
+ *
+ * @example
+ * ```ts
+ * const cleared = watchClearAll()
+ * console.log(`Cleared ${cleared} watchers`)
+ * ```
+ */
+declare function watchClearAll(): number;
+/**
+ * Convert watch event type to string
+ *
+ * @param event_type_code - Event type code (0-3)
+ * @returns Event type as string
+ *
+ * @example
+ * ```ts
+ * const typeStr = watchEventTypeToString(0)
+ * console.log(typeStr)  // "create"
+ * ```
+ */
+declare function watchEventTypeToString(event_type_code: number): string;
+/**
+ * Check if watcher is running
+ *
+ * @param handle - Watcher handle
+ * @returns True if running
+ *
+ * @example
+ * ```ts
+ * if (isWatchRunning(handle)) {
+ *   console.log("Watcher is active")
+ * }
+ * ```
+ */
+declare function isWatchRunning(handle: number): boolean;
+/**
+ * Get watch system statistics
+ *
+ * @returns Watch statistics
+ *
+ * @example
+ * ```ts
+ * const stats = getWatchStats()
+ * console.log(`Active: ${stats.active_watchers}, Events: ${stats.total_events}`)
+ * ```
+ */
+declare function getWatchStats(): WatchStats;
+/**
+ * Pause watching (pause event delivery without stopping watcher)
+ *
+ * @param handle - Watcher handle
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * watchPause(handle)
+ * // Events still detected but not delivered
+ * ```
+ */
+declare function watchPause(handle: number): string;
+/**
+ * Resume watching after pause
+ *
+ * @param handle - Watcher handle
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * watchResume(handle)
+ * // Event delivery resumes
+ * ```
+ */
+declare function watchResume(handle: number): string;
+/**
+ * Scan cache and get optimization recommendations
+ *
+ * @returns Optimization hints JSON
+ *
+ * @example
+ * ```ts
+ * const hints = scanCacheOptimizations()
+ * console.log(hints)
+ * ```
+ */
+declare function scanCacheOptimizations(): string;
+/**
+ * Get plugin hook list
+ *
+ * @returns Available plugin hooks
+ *
+ * @example
+ * ```ts
+ * const hooks = getPluginHooks()
+ * console.log(hooks)
+ * ```
+ */
+declare function getPluginHooks(): string[];
+/**
+ * Register plugin hook handler
+ *
+ * @param hook_name - Hook name
+ * @param handler_id - Handler identifier
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * registerPluginHook('compile:before', 'my-handler-1')
+ * ```
+ */
+declare function registerPluginHook(hook_name: string, handler_id: string): string;
+/**
+ * Unregister plugin hook handler
+ *
+ * @param hook_name - Hook name
+ * @param handler_id - Handler identifier
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * unregisterPluginHook('compile:before', 'my-handler-1')
+ * ```
+ */
+declare function unregisterPluginHook(hook_name: string, handler_id: string): string;
+/**
+ * Emit plugin hook event
+ *
+ * @param hook_name - Hook name
+ * @param data_json - Event data as JSON
+ * @returns Modified data
+ *
+ * @example
+ * ```ts
+ * const result = emitPluginHook('compile:before', JSON.stringify({css: '...'}))
+ * ```
+ */
+declare function emitPluginHook(hook_name: string, data_json: string): string;
+/**
+ * Get compilation performance metrics
+ *
+ * @returns Performance metrics
+ *
+ * @example
+ * ```ts
+ * const metrics = getCompilationMetrics()
+ * console.log(metrics)
+ * ```
+ */
+declare function getCompilationMetrics(): string;
+/**
+ * Reset compilation performance counters
+ *
+ * @returns "OK" on success
+ *
+ * @example
+ * ```ts
+ * resetCompilationMetrics()
+ * ```
+ */
+declare function resetCompilationMetrics(): string;
+/**
+ * Validate CSS output for errors
+ *
+ * @param css - CSS to validate
+ * @returns Validation result as JSON
+ *
+ * @example
+ * ```ts
+ * const result = validateCssOutput('.test { color: red; }')
+ * ```
+ */
+declare function validateCssOutput(css: string): string;
+/**
+ * Get compiler diagnostics
  *
- * All functions are backed by native Rust bindings.
- * No JavaScript fallback - native is required.
+ * @returns Diagnostic information
+ *
+ * @example
+ * ```ts
+ * const diagnostics = getCompilerDiagnostics()
+ * console.log(diagnostics)
+ * ```
  */
+declare function getCompilerDiagnostics(): string;
 
 type LoaderOutput = {
     code: string;
     changed: boolean;
     classes: string[];
+    staticCss?: string;
     rsc?: {
         isServer?: boolean;
         needsClientDirective?: boolean;
@@ -182,7 +2620,7 @@ declare const compileCssNative: (classes: string[], prefix?: string | null) => N
 declare const generateCssForClasses: (classes: string[], _tailwindConfig?: Record<string, unknown>, root?: string, cssEntryContent?: string, minify?: boolean) => Promise<string>;
 declare const extractAllClasses: (source: string) => string[];
 declare const extractClassesFromSource: (source: string) => string;
-declare const astExtractClasses: (source: string, filename: string) => string[];
+declare const astExtractClasses: (source: string, _filename: string) => string[];
 declare const parseClasses: (raw: string) => Array<{
     raw: string;
     type: string;
@@ -228,42 +2666,12 @@ declare const checkAgainstSafelist: (classes: string[], safelist: string[]) => {
     unmatched: string[];
     safelistSize: number;
 };
-declare const hoistComponents: (source: string) => {
-    code: string;
-    hoisted: string[];
-    warnings: string[];
-};
-declare const compileVariantTable: (configJson: string) => {
-    id: string;
-    tableJson: string;
-    keys: string[];
-    defaultKey: string;
-    combinations: number;
-};
-declare const compileVariants: (componentId: string, config: Record<string, unknown>) => {
-    id: string;
-    tableJson: string;
-    keys: string[];
-    defaultKey: string;
-    combinations: number;
-};
-declare const classifyAndSortClasses: (classes: string[]) => {
-    className: string;
-    bucket: string;
-    sortOrder: number;
-}[];
-declare const mergeCssDeclarations: (cssChunks: string[]) => {
-    declarationsJson: string;
-    declarationString: string;
-    count: number;
-};
-declare const analyzeClassUsage: (classes: string[], scanResultJson: string, css: string) => {
-    className: string;
-    usageCount: number;
-    filesJson: string;
-    bundleSizeBytes: number;
-    isDeadCode: boolean;
-}[];
+declare const hoistComponents: (source: string) => HoistResult;
+declare const compileVariantTable: (configJson: string) => VariantTableResult;
+declare const compileVariants: (componentId: string, config: Record<string, unknown>) => VariantTableResult;
+declare const classifyAndSortClasses: (classes: string[]) => ClassifyResult[];
+declare const mergeCssDeclarations: (cssChunks: string[]) => MergeResult;
+declare const analyzeClassUsage: (classes: string[], scanResultJson: string, css: string) => ClassUsageItem[];
 declare const analyzeRsc: (source: string, filename: string) => {
     isServer: boolean;
     needsClientDirective: boolean;
@@ -276,7 +2684,7 @@ declare const analyzeFile: (source: string, filename: string) => {
     interactiveClasses: never[];
     canStaticResolveVariants: boolean;
 };
-declare const analyzeVariantUsage: (source: string, componentName: string, variantKeys: string[]) => {
+declare const analyzeVariantUsage: (_source: string, _componentName: string, _variantKeys: string[]) => {
     resolved: Record<string, string>;
     dynamic: string[];
 };
@@ -293,10 +2701,15 @@ declare const analyzeClasses: (filesJson: string, cwd: string, flags: number) =>
 } | null;
 declare const generateSafelist: (scanDirs: string[], outputPath?: string, cwd?: string) => string[];
 declare const loadSafelist: (safelistPath: string) => string[];
-declare const loadTailwindConfig: (cwd?: string) => any;
+declare const loadTailwindConfig: (cwd?: string) => {};
 declare const getContentPaths: (cwd?: string) => {
-    content: any[];
+    content: string[];
 };
+/**
+ * Extract container configs dari source dan generate static `@container` CSS.
+ * Native-only: delegates ke Rust extractTwContainerConfigs.
+ */
+declare function extractContainerCssFromSource(source: string): string;
 declare const runLoaderTransform: (ctx: {
     filepath: string;
     source: string;
@@ -328,7 +2741,28 @@ declare const BucketEngine: {
     };
 };
 declare const classifyNode: (_node: unknown) => string;
-declare const detectConflicts: (classes: string[]) => string[];
+declare const detectConflicts: (_classes: string[]) => string[];
 declare const bucketSort: (classes: string[]) => string[];
+interface TwStateConfigEntry {
+    tag: string;
+    componentName: string;
+    statesJson: string;
+    sourceFile: string;
+}
+interface StaticStateCssInput {
+    tag: string;
+    componentName: string;
+    statesJson: string;
+}
+interface GeneratedStateRule {
+    selector: string;
+    declarations: string;
+    cssRule: string;
+    componentName: string;
+    stateName: string;
+}
+declare const extractTwStateConfigs: (source: string, filename: string) => TwStateConfigEntry[];
+declare const generateStaticStateCss: (inputs: StaticStateCssInput[], resolvedCss?: string | null) => GeneratedStateRule[];
+declare const extractAndGenerateStateCss: (source: string, filename: string) => GeneratedStateRule[];
 
-export { BucketEngine, type ClassExtractResult, type ComponentMetadata, IncrementalEngine, type LoaderOutput, type NativeBridge, type NativeRscResult, type NativeTransformResult, adaptNativeResult, analyzeClassUsage, analyzeClasses, analyzeFile, analyzeRsc, analyzeVariantUsage, astExtractClasses, batchExtractClasses, bucketSort, buildStyleTag, checkAgainstSafelist, classifyAndSortClasses, classifyNode, compileCssFromClasses, compileCssNative, compileVariantTable, compileVariants, detectConflicts, diffClassLists, eliminateDeadCss, extractAllClasses, extractClassesFromSource, extractComponentUsage, fileToRoute, findDeadVariants, generateCssForClasses, generateSafelist, getAllRoutes, getBucketEngine, getContentPaths, getIncrementalEngine, getNativeBridge, getRouteClasses, hasTwUsage, hoistComponents, injectClientDirective, injectServerOnlyComment, isAlreadyTransformed, loadSafelist, loadTailwindConfig, mergeClassesStatic, mergeCssDeclarations, normalizeAndDedupClasses, normalizeClasses, optimizeCss, parseClasses, registerFileClasses, registerGlobalClasses, resetBucketEngine, resetIncrementalEngine, resetNativeBridgeCache, runElimination, runLoaderTransform, scanProjectUsage, shouldProcess, shouldSkipFile, transformSource };
+export { type BatchExtractResult, BucketEngine, type CacheOptimizationHints, type CacheStatistics, type ClassExtractResult, type ClassUsageItem, type ClassifyResult, type CompiledAnimation, type CompiledCssRule, type CompiledTheme, type ComponentMetadata, type ConflictGroupInfo, type ContainerConfig, type CssCompileResult, type DeadCodeResult, type FileChangeEvent, type FileDiff, type FileFingerprint, type GeneratedStateCss, type GeneratedStateRule, type HoistResult, type IncrementalDiffResult, IncrementalEngine, type KeyExpiration, type LoaderOutput, type MergeResult, type NativeBridge, type NativeRscResult, type NativeTransformResult, type OptimalCacheConfig, type PoolInfo, type PrefilterFileResult, type ProcessedCssResult, type ProcessedFileChange, type PruneResult, type PubSubMessage, type RebuildWorkspaceResult, type RedisCacheConfig, type RedisClusterNode, type RedisClusterStatus, type RedisPoolStats, type RegistrySnapshot, type ResolvedClassName, type ResolvedVariantConfig, type SafelistCheckResult, type ScanFileResult, type ScanWorkspaceResult, type StateCssConfig, type StateInjectionResult, type StaticStateCssInput, type ThemeCascadeResult, type ThemeValidationResult, type TwMergeOptions, type TwStateConfigEntry, type VariantTableResult, type WatchEvent, type WatchHandle, type WatchStats, adaptNativeResult, analyzeClassUsage, analyzeClassUsageNative, analyzeClasses, analyzeClassesNative, analyzeFile, analyzeRsc, analyzeRscNative, analyzeVariantUsage, astExtractClasses, atomicRegistrySize, batchExtractClasses, batchExtractClassesNative, bucketSort, buildStyleTag, cachePriority, cacheRead, cacheWrite, checkAgainstSafelist, checkAgainstSafelistNative, classifyAndSortClasses, classifyAndSortClassesNative, classifyNode, clearAllCaches, clearAtomicRegistry, clearCompileCache, clearCssGenCache, clearParseCache, clearResolveCache, clearThemeCache, collectFiles, compileAnimation, compileClass, compileClasses, compileCssFromClasses, compileCssLightning, compileCssNative, compileCssNative2, compileKeyframes, compileTheme, compileToCss, compileToCssBatch, compileVariantTable, compileVariantTableNative, compileVariants, computeIncrementalDiff, createFingerprint, detectConflicts, detectDeadCode, diffClassLists, eliminateDeadCss, eliminateDeadCssNative, emitPluginHook, estimateOptimalCacheConfig, extractAllClasses, extractAndGenerateStateCss, extractAndGenerateStateCssNative, extractClassesFromSource, extractClassesFromSourceNative, extractComponentUsage, extractContainerCssFromSource, extractTwContainerConfigs, extractTwStateConfigs, extractTwStateConfigsNative, fileToRoute, findDeadVariants, generateAtomicCss, generateCssForClasses, generateCssNative, generateSafelist, generateStaticStateCss, generateStaticStateCssNative, generateSubComponentTypes, getAllRoutes, getBucketEngine, getCacheOptimizationHints, getCacheStatistics, getCacheStats, getCompilationMetrics, getCompilerDiagnostics, getContentPaths, getIncrementalEngine, getNativeBridge, getPluginHooks, getRouteClasses, getWatchStats, hasTwUsage, hashContent, hoistComponents, hoistComponentsNative, idRegistryActiveCount, idRegistryCreate, idRegistryDestroy, idRegistryExport, idRegistryGenerate, idRegistryImport, idRegistryLookup, idRegistryNext, idRegistryReset, idRegistrySnapshot, injectClientDirective, injectServerOnlyComment, injectStateHash, isAlreadyTransformed, isWatchRunning, layoutClassesToCss, loadSafelist, loadTailwindConfig, mergeClassesStatic, mergeCssDeclarations, mergeCssDeclarationsNative, minifyCss, normalizeAndDedupClasses, normalizeClasses, optimizeCss, optimizeCssNative, parseAtomicClass, parseClasses, pollWatchEvents, processFileChange, processTailwindCssLightning, propertyIdToString, pruneStaleCacheEntries, rebuildWorkspaceResult, redisCacheClear, redisCacheHitRate, redisCacheKeyCount, redisCacheSize, redisCacheSync, redisClusterStatus, redisDelete, redisDiagnose, redisDisableCacheWarming, redisDisableCluster, redisDisablePersistence, redisEnableCacheWarming, redisEnableCluster, redisEnablePersistence, redisExists, redisExpirationGet, redisExpirationSet, redisFlushAll, redisFlushDb, redisGet, redisGetEvictionPolicy, redisInfo, redisMemoryStats, redisMget, redisMonitor, redisMset, redisOptimizeMemory, redisPing, redisPoolConnect, redisPoolReconnect, redisPoolStats, redisPublish, redisReplicate, redisReplicationStatus, redisSet, redisSetEvictionPolicy, redisSnapshot, redisSubscribe, registerFileClasses, registerGlobalClasses, registerPluginHook, registerPropertyName, registerValueName, resetBucketEngine, resetCompilationMetrics, resetIncrementalEngine, resetNativeBridgeCache, resolveCascade, resolveClassNames, resolveConflictGroup, resolveSimpleVariants, resolveThemeValue, resolveVariants, reverseLookupProperty, reverseLookupValue, runElimination, runLoaderTransform, scanCacheOptimizations, scanFile, scanFileNative, scanFilesBatchNative, scanProjectUsage, scanWorkspace, shouldProcess, shouldSkipFile, startWatch, stopWatch, toAtomicClasses, transformSource, twMerge, twMergeMany, twMergeManyWithSeparator, twMergeRaw, twMergeWithSeparator, unregisterPluginHook, validateCssOutput, validateThemeConfig, valueIdToString, walkAndPrefilterSourceFiles, watchAddPattern, watchClearAll, watchEventTypeToString, watchGetActiveHandles, watchPause, watchRemovePattern, watchResume };