chaincss 2.1.39 → 2.3.0

package/dist/compiler/pattern-learner.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Style Pattern Learner
+ *
+ * Observes all styles across a codebase and:
+ *   1. DETECTS repeated patterns by content-hashing style blocks
+ *   2. RANKS by frequency × property count
+ *   3. SUGGESTS extraction as chain.recipe() or intent macros
+ *   4. REPORTS savings (lines eliminated, bundle size reduction)
+ *
+ * This is compiler-assisted design system extraction.
+ */
+import type { IRRule, IRPass } from './style-ir.js';
+export interface StyleFingerprint {
+    /** Content hash of the property set */
+    hash: string;
+    /** Human-readable signature */
+    signature: string;
+    /** Properties and their values */
+    properties: Record<string, string | number>;
+    /** Number of properties */
+    propertyCount: number;
+}
+export interface PatternCluster {
+    /** The fingerprint that defines this cluster */
+    fingerprint: StyleFingerprint;
+    /** All rules that match this pattern */
+    occurrences: Array<{
+        ruleId: string;
+        selector: string;
+        sourceFile?: string;
+        component?: string;
+    }>;
+    /** How many times it appears */
+    frequency: number;
+    /** Across how many files */
+    fileCount: number;
+    /** Importance score (frequency × propertyCount) */
+    score: number;
+    /** Suggested recipe name */
+    suggestedName: string;
+    /** Suggested extraction as recipe */
+    suggestedRecipe: string;
+    /** Estimated savings */
+    savings: {
+        declarations: number;
+        linesEliminated: number;
+        bundleReduction: string;
+    };
+}
+export interface LearningReport {
+    clusters: PatternCluster[];
+    totalPatterns: number;
+    highValuePatterns: PatternCluster[];
+    totalSavings: {
+        declarations: number;
+        estimatedBytes: number;
+    };
+    summary: string;
+}
+/**
+ * Create a content hash from a set of declarations.
+ * Ignores selectors, focuses on the actual style properties.
+ */
+declare function fingerprintDeclarations(declarations: Array<{
+    property: string;
+    value: string | number;
+}>): StyleFingerprint;
+/**
+ * Cluster rules by their style fingerprint.
+ * Only considers rules with a minimum number of declarations.
+ */
+declare function clusterPatterns(rules: IRRule[], options?: {
+    minProperties?: number;
+    minFrequency?: number;
+}): PatternCluster[];
+/**
+ * Generate a full learning report from clustered patterns.
+ */
+declare function generateReport(clusters: PatternCluster[]): LearningReport;
+/**
+ * Pattern Learning IR pass.
+ * Analyzes rules, clusters patterns, and adds diagnostics.
+ */
+export declare const patternLearningPass: IRPass;
+/**
+ * Learn patterns from a set of style rules.
+ */
+export declare function learnPatterns(rules: Array<{
+    selector: string;
+    declarations: Record<string, string | number>;
+    sourceFile?: string;
+}>, options?: {
+    minProperties?: number;
+    minFrequency?: number;
+}): LearningReport;
+/**
+ * Get the top patterns worth extracting.
+ */
+export declare function getExtractionCandidates(rules: Array<{
+    selector: string;
+    declarations: Record<string, string | number>;
+    sourceFile?: string;
+}>, minScore?: number): PatternCluster[];
+export declare const patternLearner: {
+    learn: typeof learnPatterns;
+    extract: typeof getExtractionCandidates;
+    fingerprint: typeof fingerprintDeclarations;
+    cluster: typeof clusterPatterns;
+    report: typeof generateReport;
+    pass: IRPass;
+};
+export default patternLearner;

package/dist/compiler/responsive-inference.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Automatic Responsive Inference Engine
+ *
+ * Detects layout patterns that will break on mobile and suggests fixes.
+ * Positions ChainCSS as a layout advisor, not just a compiler.
+ *
+ * Detection rules:
+ *   - Fixed widths > 768px → suggest min(100%, width)
+ *   - Grid columns > 2 → suggest auto-fit
+ *   - Large font sizes → suggest clamp()
+ *   - Fixed height: 100vh → suggest 100dvh
+ *   - Large padding/gap → suggest responsive reduction
+ *   - Multiple fixed-width columns → suggest auto-fit grid
+ */
+import type { IRPass } from './style-ir.js';
+export interface ResponsiveIssue {
+    ruleId: string;
+    selector: string;
+    property: string;
+    currentValue: string;
+    severity: 'error' | 'warning' | 'info';
+    category: 'overflow' | 'grid' | 'typography' | 'spacing' | 'viewport' | 'columns';
+    message: string;
+    suggestedFix: string;
+    autoFixAvailable: boolean;
+    affectedViewports: string[];
+}
+export interface ResponsiveReport {
+    issues: ResponsiveIssue[];
+    criticalCount: number;
+    warningCount: number;
+    infoCount: number;
+    summary: string;
+}
+/**
+ * Responsive Inference IR pass.
+ * Detects responsive issues and adds diagnostics with suggested fixes.
+ */
+export declare const responsiveInferencePass: IRPass;
+/**
+ * Analyze declarations and return responsive issues.
+ */
+export declare function analyzeResponsive(selector: string, declarations: Record<string, string | number>): ResponsiveIssue[];
+/**
+ * Generate a full responsive report.
+ */
+export declare function generateResponsiveReport(issues: ResponsiveIssue[]): ResponsiveReport;
+/**
+ * Auto-fix a single responsive issue.
+ */
+export declare function autoFixIssue(issue: ResponsiveIssue): string;
+/**
+ * Auto-fix all auto-fixable issues.
+ */
+export declare function autoFixAll(issues: ResponsiveIssue[]): string[];
+export declare const responsiveInference: {
+    analyze: typeof analyzeResponsive;
+    report: typeof generateResponsiveReport;
+    autoFix: typeof autoFixIssue;
+    autoFixAll: typeof autoFixAll;
+    pass: IRPass;
+};
+export default responsiveInference;

package/dist/compiler/scroll-timeline.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Scroll-Driven Animations Engine
+ *
+ * Compiles timeline-based animation descriptions into:
+ *   1. Native CSS scroll-timeline / view-timeline (Chromium 115+)
+ *   2. @supports fallback with JavaScript polyfill hint
+ *
+ * API inspiration: GSAP's ScrollTrigger, but compiles to 0kb JS.
+ */
+export interface ScrollTimelineConfig {
+    /** Name of the timeline */
+    name: string;
+    /** What drives the timeline */
+    source: 'scroll' | 'view';
+    /** The scrollable element (default: nearest scrollable ancestor) */
+    scroller?: 'nearest' | 'root' | 'self' | string;
+    /** Scroll axis */
+    axis?: 'block' | 'inline' | 'x' | 'y';
+    /** For view timelines: when does the element enter/exit */
+    inset?: string | {
+        start: string;
+        end: string;
+    };
+    /** Timeline range (for view timelines) */
+    range?: 'cover' | 'contain' | 'entry' | 'exit' | 'entry-crossing' | 'exit-crossing' | string;
+}
+export interface KeyframeStep {
+    /** Percentage or keyword (e.g., '0%', 'from', 'to') */
+    offset: string;
+    /** CSS properties at this keyframe */
+    properties: Record<string, string | number>;
+    /** Easing for this segment */
+    easing?: string;
+}
+export interface ScrollAnimation {
+    /** Selector to animate */
+    selector: string;
+    /** Timeline configuration */
+    timeline: ScrollTimelineConfig;
+    /** Keyframes */
+    keyframes: KeyframeStep[];
+    /** Animation duration (maps to timeline range) */
+    duration?: string;
+    /** Fill mode */
+    fill?: 'none' | 'forwards' | 'backwards' | 'both';
+    /** Iteration count */
+    iterations?: number | 'infinite';
+    /** Delay before starting */
+    delay?: string;
+}
+export interface ScrollTimelineResult {
+    /** Native CSS for scroll-driven animation */
+    css: string;
+    /** The @keyframes name generated */
+    animationName: string;
+    /** The timeline name generated */
+    timelineName: string;
+    /** Fallback CSS for browsers without scroll-timeline */
+    fallback: string;
+}
+export declare const SCROLL_PRESETS: Record<string, ScrollAnimation>;
+/**
+ * Compile a scroll animation into CSS.
+ *
+ * Output includes:
+ *   - @keyframes definition
+ *   - animation-timeline property
+ *   - animation-range (for view timelines)
+ *   - @supports fallback for older browsers
+ */
+export declare function compileScrollAnimation(animation: ScrollAnimation): ScrollTimelineResult;
+/**
+ * Compile multiple scroll animations for a page.
+ */
+export declare function compileScrollAnimations(animations: ScrollAnimation[]): string;
+/**
+ * Create a scroll animation from a preset.
+ */
+export declare function createScrollAnimation(preset: keyof typeof SCROLL_PRESETS, selector: string, overrides?: Partial<ScrollAnimation>): ScrollAnimation;
+/**
+ * Get available scroll animation presets.
+ */
+export declare function getScrollPresets(): string[];
+export declare const scrollTimeline: {
+    compile: typeof compileScrollAnimation;
+    compileAll: typeof compileScrollAnimations;
+    create: typeof createScrollAnimation;
+    presets: Record<string, ScrollAnimation>;
+    getPresets: typeof getScrollPresets;
+};
+export default scrollTimeline;

package/dist/compiler/semantic-tokens.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Semantic Token System
+ *
+ * Intent-based styling that maps semantic concepts to design tokens.
+ * Wraps the existing token system — both coexist.
+ *
+ * @example
+ *   chain.surface('interactive')  // → maps to background, color, border-radius
+ *   chain.text('primary')         // → maps to color, font-weight
+ *   chain.elevation('floating')   // → maps to box-shadow, z-index
+ *   chain.state('hover')          // → maps to hover pseudo-class
+ *   chain.spacing('comfortable')  // → maps to padding
+ */
+import type { IRPass } from './style-ir.js';
+export type SurfaceIntent = 'interactive' | 'container' | 'overlay' | 'sheet' | 'tooltip' | 'input';
+export type TextIntent = 'primary' | 'secondary' | 'muted' | 'link' | 'inverse' | 'code';
+export type ElevationIntent = 'flat' | 'raised' | 'floating' | 'sticky' | 'overlay' | 'modal';
+export type StateIntent = 'hover' | 'active' | 'focus' | 'disabled' | 'loading' | 'selected';
+export type SpacingIntent = 'none' | 'tight' | 'compact' | 'comfortable' | 'spacious' | 'generous';
+export interface SemanticMapping {
+    properties: Record<string, string | number>;
+    pseudoClass?: string;
+    description: string;
+}
+export interface ThemeContext {
+    mode: 'light' | 'dark' | 'high-contrast';
+    brand?: Record<string, string>;
+    containerContext?: 'light' | 'dark';
+}
+/**
+ * Resolve a semantic intent to concrete CSS properties.
+ * Applies theme overrides based on context.
+ */
+export declare function resolveSemantic(category: 'surface' | 'text' | 'elevation' | 'state' | 'spacing', intent: string, themeContext?: ThemeContext): SemanticMapping | null;
+/**
+ * Get all available intents for a category.
+ */
+export declare function getSemanticIntents(category: 'surface' | 'text' | 'elevation' | 'state' | 'spacing'): string[];
+/**
+ * Get the description of a semantic intent.
+ */
+export declare function getSemanticDescription(category: 'surface' | 'text' | 'elevation' | 'state' | 'spacing', intent: string): string | null;
+/**
+ * Semantic Token IR pass.
+ * Resolves any _semantic metadata on rules into concrete declarations.
+ */
+export declare const semanticTokensPass: IRPass;
+export declare const semanticTokens: {
+    resolve: typeof resolveSemantic;
+    getIntents: typeof getSemanticIntents;
+    getDescription: typeof getSemanticDescription;
+    pass: IRPass;
+    theme: Record<string, Record<string, SemanticMapping>>;
+    darkOverrides: Record<string, Record<string, Partial<Record<string, string | number>>>>;
+    highContrastOverrides: Record<string, Record<string, Partial<Record<string, string | number>>>>;
+};
+export default semanticTokens;

package/dist/compiler/source-optimizer.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Source-Aware Optimization Engine
+ *
+ * Unifies all analysis modules into an enterprise-grade optimization report.
+ * Tracks where every style originates and detects:
+ *   - Duplicate styles across files
+ *   - Dead/unreachable rules
+ *   - Specificity wars
+ *   - Conflicting animations
+ *   - Redundant media queries
+ *   - Unused variants and recipes
+ */
+import type { IRRule, IRPass } from './style-ir.js';
+export interface DuplicateGroup {
+    /** The shared signature */
+    signature: string;
+    /** All occurrences with source locations */
+    occurrences: Array<{
+        selector: string;
+        file?: string;
+        line?: number;
+        component?: string;
+    }>;
+    /** How many times it appears */
+    count: number;
+    /** Suggested extraction */
+    suggestion: string;
+    /** Estimated savings in bytes */
+    savingsBytes: number;
+}
+export interface DeadRule {
+    ruleId: string;
+    selector: string;
+    file?: string;
+    line?: number;
+    reason: string;
+    bytesWasted: number;
+}
+export interface SpecificityConflict {
+    higher: {
+        selector: string;
+        specificity: number;
+        file?: string;
+        line?: number;
+    };
+    lower: {
+        selector: string;
+        specificity: number;
+        file?: string;
+        line?: number;
+    };
+    property?: string;
+    severity: 'warning' | 'info';
+}
+export interface AnimationConflict {
+    name: string;
+    locations: Array<{
+        file?: string;
+        line?: number;
+        selector: string;
+    }>;
+    count: number;
+}
+export interface MediaQueryRedundancy {
+    query: string;
+    count: number;
+    files: string[];
+    suggestion: string;
+    savingsBytes: number;
+}
+export interface OptimizationReport {
+    duplicates: DuplicateGroup[];
+    deadRules: DeadRule[];
+    specificityConflicts: SpecificityConflict[];
+    animationConflicts: AnimationConflict[];
+    mediaQueryRedundancies: MediaQueryRedundancy[];
+    summary: {
+        totalIssues: number;
+        duplicatesCount: number;
+        deadCount: number;
+        specificityCount: number;
+        animationCount: number;
+        mediaQueryCount: number;
+        totalSavingsBytes: number;
+        totalSavingsKB: string;
+    };
+    formattedReport: string;
+}
+declare function findDuplicates(rules: IRRule[]): DuplicateGroup[];
+declare function findDeadRules(rules: IRRule[]): DeadRule[];
+declare function findSpecificityConflicts(rules: IRRule[]): SpecificityConflict[];
+declare function findAnimationConflicts(rules: IRRule[]): AnimationConflict[];
+declare function findMediaQueryRedundancies(rules: IRRule[]): MediaQueryRedundancy[];
+declare function formatReport(report: OptimizationReport): string;
+declare function generateOptimizationReport(rules: IRRule[]): OptimizationReport;
+export declare const sourceOptimizerPass: IRPass;
+export declare function optimizeSource(rules: IRRule[]): OptimizationReport;
+export declare const sourceOptimizer: {
+    optimize: typeof optimizeSource;
+    findDuplicates: typeof findDuplicates;
+    findDeadRules: typeof findDeadRules;
+    findSpecificityConflicts: typeof findSpecificityConflicts;
+    findAnimationConflicts: typeof findAnimationConflicts;
+    findMediaQueryRedundancies: typeof findMediaQueryRedundancies;
+    report: typeof generateOptimizationReport;
+    format: typeof formatReport;
+    pass: IRPass;
+};
+export default sourceOptimizer;

package/dist/compiler/style-ir.d.ts

@@ -0,0 +1,183 @@
+/**
+ * ChainCSS Intermediate Representation (IR)
+ *
+ * The single source of truth that all compiler passes read from and write to.
+ * Replaces direct object mutation with a typed, traceable AST.
+ *
+ * Architecture:
+ *   StyleDefinition → parseIR() → StyleIR → [passes] → generateCSS()
+ */
+import type { StyleDefinition } from '../core/types.js';
+/** Unique identifier for every IR node */
+export type IRNodeId = string;
+/** Source location for debugging and source maps */
+export interface SourceLocation {
+    file?: string;
+    line?: number;
+    column?: number;
+    component?: string;
+}
+/** A single CSS declaration (property: value) */
+export interface IRDeclaration {
+    id: IRNodeId;
+    property: string;
+    value: string | number;
+    important?: boolean;
+    source?: SourceLocation;
+    /** Transform history — who modified this and why */
+    history: IRTransformRecord[];
+    /** Metadata from passes */
+    meta: Record<string, any>;
+}
+/** A CSS rule (selector + declarations + nested rules) */
+export interface IRRule {
+    id: IRNodeId;
+    selector: string;
+    declarations: IRDeclaration[];
+    pseudoClasses: IRPseudoClass[];
+    atRules: IRAtRule[];
+    nestedRules: IRRule[];
+    /** Conditional if() expressions */
+    conditions: IRCondition[];
+    /** Dead code flag — set by optimizer passes */
+    isDead: boolean;
+    /** Specificity — set by graph pass */
+    specificity: number;
+    /** Content hash for deduplication */
+    hash: string;
+    source: SourceLocation;
+    history: IRTransformRecord[];
+    meta: Record<string, any>;
+}
+/** Pseudo-class block (hover, focus, etc.) */
+export interface IRPseudoClass {
+    id: IRNodeId;
+    name: string;
+    declarations: IRDeclaration[];
+    source: SourceLocation;
+    history: IRTransformRecord[];
+}
+/** At-rule block (media, keyframes, supports, etc.) */
+export interface IRAtRule {
+    id: IRNodeId;
+    type: 'media' | 'keyframes' | 'font-face' | 'supports' | 'container' | 'layer';
+    query?: string;
+    name?: string;
+    declarations: IRDeclaration[];
+    nestedRules: IRRule[];
+    source: SourceLocation;
+    history: IRTransformRecord[];
+}
+/** CSS if() conditional */
+export interface IRCondition {
+    id: IRNodeId;
+    property: string;
+    variable: string;
+    conditions: Record<string, string | number>;
+    defaultValue: string | number;
+    source: SourceLocation;
+}
+/** Transform record — who touched this node and why */
+export interface IRTransformRecord {
+    pass: string;
+    action: string;
+    timestamp: number;
+    previous?: any;
+    reason?: string;
+}
+/** The full IR tree */
+export interface StyleIR {
+    id: string;
+    rules: IRRule[];
+    diagnostics: IRDiagnostic[];
+    meta: {
+        version: string;
+        createdAt: number;
+        sourceFiles: string[];
+        passCount: number;
+        passes: string[];
+    };
+}
+/** Diagnostic attached to an IR node */
+export interface IRDiagnostic {
+    id: IRNodeId;
+    nodeId: IRNodeId;
+    severity: 'error' | 'warning' | 'info' | 'hint';
+    message: string;
+    suggestion?: string;
+    pass: string;
+}
+export declare function resetIdCounter(): void;
+export declare function createDeclaration(property: string, value: string | number, source?: SourceLocation, meta?: Record<string, any>): IRDeclaration;
+export declare function createRule(selector: string, source?: SourceLocation): IRRule;
+export declare function createIR(sourceFiles?: string[]): StyleIR;
+/**
+ * Parse a StyleDefinition (or Record<string, any>) into the IR.
+ * This is the bridge — existing code produces StyleDefinition,
+ * this converts it to typed IR for all downstream passes.
+ */
+export declare function parseIR(styles: Record<string, StyleDefinition> | Record<string, any>, sourceFile?: string): StyleIR;
+/**
+ * Generate a CSS string from the IR.
+ * This replaces the ad-hoc CSS generation scattered across modules.
+ */
+export declare function generateCSS(ir: StyleIR, options?: {
+    minify?: boolean;
+}): string;
+/** Count all nodes in the IR */
+export declare function countNodes(ir: StyleIR): {
+    rules: number;
+    declarations: number;
+    pseudoClasses: number;
+    atRules: number;
+    conditions: number;
+};
+/** Find a rule by selector */
+export declare function findRule(ir: StyleIR, selector: string): IRRule | undefined;
+/** Clone an IR (deep copy) */
+export declare function cloneIR(ir: StyleIR): StyleIR;
+/** Debug: print IR summary */
+export declare function debugIR(ir: StyleIR): string;
+export type IRPass = (ir: StyleIR) => StyleIR;
+/**
+ * Apply a transform pass to the IR.
+ * Records the pass in metadata for debugging.
+ */
+export declare function applyPass(ir: StyleIR, pass: IRPass, passName: string): StyleIR;
+/**
+ * Apply multiple passes in sequence.
+ */
+export declare function applyPasses(ir: StyleIR, passes: Array<{
+    name: string;
+    pass: IRPass;
+}>): StyleIR;
+/**
+ * Full pipeline: StyleDefinition → IR → passes → CSS.
+ * Drop-in replacement for existing compile() calls.
+ */
+export declare function compileViaIR(styles: Record<string, StyleDefinition>, passes?: Array<{
+    name: string;
+    pass: IRPass;
+}>, options?: {
+    minify?: boolean;
+    sourceFile?: string;
+}): {
+    css: string;
+    ir: StyleIR;
+};
+export declare const styleIR: {
+    createIR: typeof createIR;
+    parseIR: typeof parseIR;
+    generateCSS: typeof generateCSS;
+    createRule: typeof createRule;
+    createDeclaration: typeof createDeclaration;
+    countNodes: typeof countNodes;
+    findRule: typeof findRule;
+    cloneIR: typeof cloneIR;
+    debugIR: typeof debugIR;
+    applyPass: typeof applyPass;
+    applyPasses: typeof applyPasses;
+    compileViaIR: typeof compileViaIR;
+    resetIdCounter: typeof resetIdCounter;
+};
+export default styleIR;

package/dist/index.d.ts

@@ -40,6 +40,29 @@ export type { Chain } from './compiler/Chain.js';
 export type { AnimationConfig, KeyframeDefinition } from './compiler/animations.js';
 export type { BreakpointsMap, ResponsiveStyle } from './compiler/breakpoints.js';
 export declare const VERSION = "3.0.0";
+export { orchestrator, contrastRatio, checkContrast, auditContrast, createContextualToken, resolveContextual, generateContextualCSS, validateTokenRelationships, } from './compiler/design-orchestrator.js';
+export type { ContrastResult, ContrastReport, ContextualToken, TokenContext } from './compiler/design-orchestrator.js';
+export { scrollTimeline, compileScrollAnimation, compileScrollAnimations, createScrollAnimation, getScrollPresets, SCROLL_PRESETS, } from './compiler/scroll-timeline.js';
+export type { ScrollTimelineConfig, ScrollAnimation, ScrollTimelineResult, KeyframeStep } from './compiler/scroll-timeline.js';
+export { styleIR, createIR, parseIR, generateCSS, createRule, createDeclaration, applyPass, applyPasses, compileViaIR, countNodes, debugIR, resetIdCounter, } from './compiler/style-ir.js';
+export type { StyleIR, IRRule, IRDeclaration, IRPseudoClass, IRAtRule, IRCondition, IRTransformRecord, IRDiagnostic, IRNodeId, SourceLocation, IRPass, } from './compiler/style-ir.js';
+export { PassManager, runDefaultPipeline, DEFAULT_PIPELINE, intentRecoveryPass, unitResolutionPass, validationPass, specificitySortPass, deadEliminationPass, atomicExtractionPass, mediaQueryPackingPass, cssIfTranspilePass, cssCompressionPass, diagnosticsExportPass, } from './compiler/pass-manager.js';
+export type { PassName, PassPriority, PassDefinition, PassResult, PipelineResult } from './compiler/pass-manager.js';
+export { constraintSolver, resolveConstraint, resolveStickyUntil, resolveContainerQuery, parseConstraint, constraintSolverPass, } from './compiler/constraint-solver.js';
+export type { Constraint, ConstraintOperator, ConstraintTarget, ResolvedConstraint } from './compiler/constraint-solver.js';
+export { layoutIntelligence, recognizeLayout, suggestMacro, getLayoutPatterns, layoutIntelligencePass, } from './compiler/layout-intelligence.js';
+export type { LayoutPattern, PatternMatch, PatternReport } from './compiler/layout-intelligence.js';
+export { responsiveInference, analyzeResponsive, generateResponsiveReport, autoFixIssue, autoFixAll, responsiveInferencePass, } from './compiler/responsive-inference.js';
+export type { ResponsiveIssue, ResponsiveReport } from './compiler/responsive-inference.js';
+export { patternLearner, learnPatterns, getExtractionCandidates, patternLearningPass, } from './compiler/pattern-learner.js';
+export type { StyleFingerprint, PatternCluster, LearningReport } from './compiler/pattern-learner.js';
+export { sourceOptimizer, optimizeSource, sourceOptimizerPass, } from './compiler/source-optimizer.js';
+export type { OptimizationReport, DuplicateGroup, DeadRule, SpecificityConflict, AnimationConflict, MediaQueryRedundancy } from './compiler/source-optimizer.js';
+export { semanticTokens, resolveSemantic, getSemanticIntents, getSemanticDescription, semanticTokensPass, } from './compiler/semantic-tokens.js';
+export type { SurfaceIntent, TextIntent, ElevationIntent, StateIntent, SpacingIntent, SemanticMapping, ThemeContext } from './compiler/semantic-tokens.js';
+export { accessibilityEngine, auditAccessibility, checkRule, accessibilityPass, } from './compiler/accessibility-engine.js';
+export type { AccessibilityIssue, AccessibilityReport } from './compiler/accessibility-engine.js';
+export { intentAPI, resolveIntent, getAvailableIntents, getIntentsByCategory, getIntentDescription, intentAPIPass, } from './compiler/intent-api.js';
 import { chain } from './compiler/Chain.js';
 export default chain;
 export type { Properties as CSSProperties } from 'csstype';