@sugarcube-org/core 0.0.1-alpha.9 → 0.1.0-alpha.18

package/dist/index.d.ts

@@ -1,20 +1,30 @@
 import { z } from 'zod';
 
-/**
- * Directional variants for utility properties
- */
+declare const DEFAULT_CONFIG: {
+    readonly output: {
+        readonly cssRoot: "src/styles";
+        readonly components: "src/components/ui";
+        readonly themeAttribute: "data-theme";
+    };
+    readonly transforms: {
+        readonly fluid: {
+            readonly min: 320;
+            readonly max: 1200;
+        };
+        readonly colorFallbackStrategy: "native";
+    };
+};
+
 type DirectionalVariant = "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all";
-/**
- * Properties-first utility configuration
- * This is the approach where users configure utilities by CSS property
- * Made it separate in case we want other types of configs later
- */
 type PropertyUtilityConfig = {
+    /** Token path pattern (e.g., "space.*", "color.primary.*"). */
     source: string;
+    /** Directional variants for spacing properties. */
     directions?: DirectionalVariant | DirectionalVariant[];
+    /** Custom prefix for generated classes. */
     prefix?: string;
+    /** Strip duplicate prefix (e.g., "text-text-quiet" → "text-quiet"). */
     stripDuplicates?: boolean;
-    collection?: string;
 };
 
 type ColorFallbackStrategy = "native" | "polyfill";
@@ -22,754 +32,539 @@ type FluidConfig = {
     min: number;
     max: number;
 };
-/**
- * Theme configuration can be either:
- * - Simple: string[] of file paths
- * - Nested: { source: string[], modes?: Record<string, string[]> }
- */
-type ThemeConfig = string[] | {
-    source: string[];
-    /** Mode variations within this theme */
-    modes?: Record<string, string[]>;
-};
-type TokenCollection = {
-    source: string[];
-    /** Mode variations (light/dark) - generates [data-mode="..."] selectors */
-    modes?: Record<string, string[]>;
-    /** Theme variations (color schemes) - generates [data-theme="..."] selectors */
-    themes?: Record<string, ThemeConfig>;
-};
-/**
- * Multiple named collections of tokens.
- * Each key is a collection name (e.g., "base", "ui", "marketing").
- */
-type TokenCollections = Record<string, TokenCollection>;
-type UserTransformsConfig = {
-    fluid?: FluidConfig;
-    colorFallbackStrategy?: ColorFallbackStrategy;
-};
-/**
- * Configuration for transforms applied to tokens during processing (internal config)
- */
 type TransformsConfig = {
     fluid: FluidConfig;
     colorFallbackStrategy: ColorFallbackStrategy;
 };
-/**
- * Configuration for output directories (user config - optional fields)
- */
-type UserOutputConfig = {
-    css?: string;
-    components?: string;
-    separate?: boolean;
-    /** Attribute name for mode selectors (default: "data-mode") */
-    modeAttribute?: string;
-    /** Attribute name for theme selectors (default: "data-theme") */
-    themeAttribute?: string;
-};
-/**
- * Configuration for output directories (internal config - required fields)
- */
 type OutputConfig = {
-    css: string;
+    cssRoot: string;
+    variables?: string;
+    utilities?: string;
+    cube?: string;
     components?: string;
-    separate: boolean;
-    /** Attribute name for mode selectors */
-    modeAttribute: string;
-    /** Attribute name for theme selectors */
     themeAttribute: string;
+    defaultContext?: string;
 };
-/**
- * Utilities configuration
- * This is the approach where users configure utilities by CSS property
- * Can be a single configuration or an array of configurations
- */
 type UtilitiesConfig = Record<string, PropertyUtilityConfig | PropertyUtilityConfig[]>;
-interface UserConfig {
-    tokens?: TokenCollection | TokenCollections;
-    transforms?: UserTransformsConfig;
-    output?: UserOutputConfig;
+/**
+ * Configuration for sugarcube.
+ * This is the shape of your config file (sugarcube.config.ts).
+ *
+ * @example
+ * // sugarcube.config.ts
+ * import { defineConfig } from "@sugarcube-org/vite";
+ *
+ * export default defineConfig({
+ *   resolver: "./tokens.resolver.json",
+ *   output: { cssRoot: "src/styles" }
+ * });
+ */
+interface SugarcubeConfig {
+    /**
+     * Path to the DTCG resolver document (.resolver.json).
+     * The resolver defines token sources, sets, and modifiers.
+     */
+    resolver?: string;
+    /**
+     * Token transformation options.
+     */
+    transforms?: {
+        /**
+         * Viewport range for fluid typography calculations.
+         * Tokens with $type: "fluidDimension" will scale between min and max viewport widths.
+         */
+        fluid?: FluidConfig;
+        /**
+         * How to handle colors that can't be represented in sRGB.
+         * - "native": Use CSS color functions directly (modern browsers only)
+         * - "polyfill": Generate fallback values for older browsers
+         */
+        colorFallbackStrategy?: ColorFallbackStrategy;
+    };
+    /**
+     * Output configuration.
+     */
+    output?: {
+        /**
+         * Base directory path where CSS files will be written.
+         * This is the primary output location for generated styles.
+         */
+        cssRoot?: string;
+        /**
+         * Directory path where token variable CSS files will be written.
+         * @default "{cssRoot}/global"
+         */
+        variables?: string;
+        /**
+         * Directory path where utility class CSS files will be written.
+         * @default "{cssRoot}/utilities"
+         */
+        utilities?: string;
+        /**
+         * Directory path where CUBE CSS files will be written.
+         * @default "{cssRoot}"
+         */
+        cube?: string;
+        /** Directory path where component files will be written. */
+        components?: string;
+        /**
+         * HTML attribute used for theme selectors.
+         * @default "data-theme"
+         */
+        themeAttribute?: string;
+        /**
+         * Which context should use the :root selector.
+         * Other contexts will use [themeAttribute="contextName"] selectors.
+         * @default The resolver's default context
+         */
+        defaultContext?: string;
+    };
+    /**
+     * CSS utility class generation configuration.
+     * Maps CSS property names to token sources and options.
+     *
+     * @example
+     * utilities: {
+     *   "background-color": { source: "color.background.*" },
+     *   "padding": { source: "space.*", directions: ["x", "y", "all"] }
+     * }
+     */
     utilities?: UtilitiesConfig;
 }
 /**
- * Internal configuration type - what code uses (complete, required fields)
+ * Normalized configuration with all defaults applied.
+ * Used internally after processing SugarcubeConfig.
  */
 interface InternalConfig {
-    tokens?: TokenCollection | TokenCollections;
+    resolver?: string;
     transforms: TransformsConfig;
     output: OutputConfig;
     utilities?: UtilitiesConfig;
 }
 
 /**
- * Base error type that all other error types extend from.
- * Used as the foundation for all error types in the system.
- * Provides a consistent structure for error messages across the codebase.
+ * Result of loading a sugarcube configuration file.
+ * Contains the validated, normalized configuration and its source path.
  */
-type BaseError = {
-    /** A human-readable error message describing what went wrong */
-    message: string;
+type LoadedConfig = {
+    /** The validated and normalized configuration with defaults applied. */
+    config: InternalConfig;
+    /** The absolute path to the config file that was loaded. */
+    configPath: string;
 };
-
 /**
- * A token value that can either be a raw value or a reference.
- * This is the base type for all token values in the W3C Design Token Format.
- * @template T - The type of token (e.g., "color", "dimension", etc.)
+ * Checks if a sugarcube configuration file exists.
+ *
+ * @param basePath - Base path without extension (default: "sugarcube.config")
+ * @returns True if a .ts or .js config file exists
  */
-type TokenValue<T extends TokenType> = RawTokenValue<T> | Reference<T>;
+declare function configFileExists(basePath?: string): boolean;
 /**
- * The actual value of a token without references.
- * This represents the concrete value that will be used in the final output.
- * @template T - The type of token (e.g., "color", "dimension", etc.)
+ * Loads and validates a sugarcube configuration file.
+ * Returns the user-facing config without internal defaults applied.
+ *
+ * @param configPath - Optional path to config file. If omitted, searches for sugarcube.config.ts/js
+ * @returns The validated config and its resolved path
+ * @throws Error if config file not found or invalid
  */
-type RawTokenValue<T extends TokenType> = T extends SimpleTokenType ? SimpleTokenValue<T> : T extends CompositeTokenType ? CompositeTokenValue<T> : never;
+declare function loadSugarcubeConfig(configPath?: string): Promise<{
+    config: SugarcubeConfig;
+    configPath: string;
+}>;
+/**
+ * Loads, validates, and normalizes a sugarcube configuration file.
+ * Returns a complete internal config with all defaults applied.
+ *
+ * @param configPath - Optional path to config file. If omitted, searches for sugarcube.config.ts/js
+ * @returns The normalized config with defaults and its resolved path
+ * @throws Error if config file not found or invalid
+ */
+declare function loadInternalConfig(configPath?: string): Promise<LoadedConfig>;
+
+/**
+ * Validates a user configuration object against the schema and fills in defaults.
+ *
+ * @param config - The user configuration object to validate
+ * @returns The validated configuration with defaults filled in
+ * @throws Error if the configuration is invalid
+ *
+ * @example
+ * const config = { resolver: "./tokens.resolver.json" };
+ * const validatedConfig = validateConfig(config);
+ */
+declare function validateConfig(config: Partial<SugarcubeConfig>): InternalConfig;
+
 /**
- * A reference to another token, with optional type checking.
- * References are strings that point to other tokens in the token tree.
- * The phantom type parameter ensures type safety when resolving references.
- * @template T - The type of token being referenced
+ * Fills in default values for any omitted fields in a user configuration.
+ *
+ * This function takes a user config (with optional fields) and
+ * returns a complete internal config (with all required fields filled in).
+ *
+ * @param userConfig - The user configuration with optional fields
+ * @returns A complete configuration with all defaults filled in
+ *
+ * @example
+ * const userConfig = {
+ *   resolver: "./tokens.resolver.json"
+ * };
+ * const completeConfig = fillDefaults(userConfig);
+ * // completeConfig.output.cssRoot === "src/styles"
  */
+declare function fillDefaults(userConfig: SugarcubeConfig): InternalConfig;
+
+type BaseError = {
+    message: string;
+};
+
+type TokenValue<T extends TokenType> = RawTokenValue<T> | Reference<T>;
+type RawTokenValue<T extends TokenType> = T extends SimpleTokenType ? SimpleTokenValue<T> : T extends CompositeTokenType ? CompositeTokenValue<T> : never;
+/** Reference to another token. String format: "{path.to.token}". */
 type Reference<T extends TokenType = TokenType> = string & {
-    /** Phantom type for type safety during reference resolution */
     __tokenType?: T;
 };
-/**
- * Metadata that can be attached to any node in the token tree.
- * This includes descriptions and custom extensions as defined in the W3C spec.
- */
 type NodeMetadata = {
-    /** Optional description of the token or group */
     $description?: string;
-    /** Optional custom extensions as defined in the W3C spec */
     $extensions?: {
         [key: string]: unknown;
     };
 };
-/**
- * A single token with its value and metadata.
- * This is the basic building block of the token system.
- */
 type Token = NodeMetadata & {
-    /** The value of the token, which can be a raw value or a reference */
     $value: TokenValue<TokenType>;
-    /** Optional type specification, can be inherited from parent groups */
     $type?: TokenType;
 };
-/**
- * A group of tokens that can be nested.
- * The type allows for:
- * - Regular token properties (non-$ prefixed) which must be Token | TokenGroup
- * - Metadata properties from NodeMetadata (like $description, $extensions)
- * - $type property for type inheritance as specified in the W3C spec
- * - undefined to support optional metadata properties
- */
 type TokenGroup = NodeMetadata & {
-    /** Optional type specification for the group, can be inherited by child tokens */
     $type?: TokenType;
-    /** Dynamic properties that can be either tokens, token groups, or undefined */
     [key: string]: Token | TokenGroup | TokenType | undefined;
 };
-/**
- * All possible token types, either simple or composite.
- * This is the union of all supported token types in the system.
- */
 type TokenType = SimpleTokenType | CompositeTokenType;
-/**
- * Token types that contain a single value.
- * These are the basic building blocks of the token system.
- */
 type SimpleTokenType = "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "number";
-/**
- * Values for simple token types.
- * Maps each simple token type to its corresponding value type.
- * @template T - The type of token (e.g., "color", "dimension", etc.)
- */
 type SimpleTokenValue<T extends SimpleTokenType = SimpleTokenType> = T extends "color" ? Color : T extends "dimension" ? Dimension : T extends "fluidDimension" ? FluidDimension : T extends "duration" ? Duration : T extends "cubicBezier" ? CubicBezier : T extends "fontFamily" ? FontFamily : T extends "fontWeight" ? FontWeight : T extends "number" ? number : never;
-/**
- * Token types that contain multiple values or are structurally complex.
- * These types combine multiple simple types to create more complex tokens.
- */
 type CompositeTokenType = AlwaysDecomposedType | "border" | "shadow" | "gradient" | "transition" | StructuralCompositeType;
-/**
- * Token types that must always be broken down into their constituent parts.
- * These types are never used directly in CSS output.
- */
+/** Types that decompose into multiple CSS properties (e.g., typography → font-family, font-size, etc.). */
 type AlwaysDecomposedType = "typography";
-/**
- * Token types that define structural patterns.
- * These types are used to define reusable patterns in the token system.
- */
 type StructuralCompositeType = "strokeStyle";
-/**
- * Values for composite token types.
- * Maps each composite token type to its corresponding value type.
- * @template T - The type of token (e.g., "typography", "border", etc.)
- */
 type CompositeTokenValue<T extends CompositeTokenType = CompositeTokenType> = T extends "typography" ? Typography : T extends "border" ? Border : T extends "shadow" ? Shadow : T extends "gradient" ? Gradient : T extends "transition" ? Transition : T extends "strokeStyle" ? StrokeStyle : never;
-/**
- * A color value in any valid CSS color format.
- * This can be either:
- * - A string that is valid in CSS color contexts (legacy format)
- * - A W3C color object with colorSpace, components, and optional alpha/hex
- */
+/** CSS color string or W3C color object with colorSpace. */
 type Color = string | {
-    /** The color space - supports "oklch" and "display-p3" */
     colorSpace: "oklch" | "display-p3";
-    /** Array of 3 numbers representing the color components */
     components: [number, number, number];
-    /** Optional alpha value between 0 and 1 (defaults to 1 if omitted) */
     alpha?: number;
-    /** Optional hex fallback value for compatibility */
     hex?: string;
 };
-/**
- * A dimensional value with a numeric value and unit.
- * Used for measurements like width, height, spacing, etc.
- */
 type Dimension = {
-    /** The numeric value of the dimension */
     value: number;
-    /** The unit of measurement (px or rem) */
     unit: "px" | "rem";
 };
-/**
- * A fluid dimension that scales between min and max values.
- * Used for responsive design tokens that need to scale with viewport size.
- */
+/** Responsive dimension that scales between viewport sizes. */
 type FluidDimension = {
-    /** The minimum value at the smallest viewport size */
     min: Dimension;
-    /** The maximum value at the largest viewport size */
     max: Dimension;
 };
-/**
- * A duration value with a numeric value and time unit.
- * Used for animations, transitions, and other time-based values.
- */
 type Duration = {
-    /** The numeric value of the duration */
     value: number;
-    /** The unit of time (milliseconds or seconds) */
     unit: "ms" | "s";
 };
-/**
- * A cubic bezier curve defined by four control points.
- * Used for defining custom easing functions in animations and transitions.
- * The four numbers represent the x,y coordinates of the two control points.
- */
+/** Bezier curve control points: [x1, y1, x2, y2]. */
 type CubicBezier = [number, number, number, number];
-/**
- * A font family name or list of fallback fonts.
- * Can be a single font name or an array of fonts in order of preference.
- */
 type FontFamily = string | string[];
-/**
- * A font weight value as either a number or semantic string.
- * Numbers range from 100-900, strings are semantic names for common weights.
- */
 type FontWeight = number | FontWeightString;
-/**
- * Semantic font weight names.
- * These are standardized names for common font weights.
- */
 type FontWeightString = "thin" | "hairline" | "extra-light" | "ultra-light" | "light" | "normal" | "regular" | "book" | "medium" | "semi-bold" | "demi-bold" | "bold" | "extra-bold" | "ultra-bold" | "black" | "heavy" | "extra-black" | "ultra-black";
-/**
- * Line cap style for strokes.
- * Defines how the end of a stroke should be rendered.
- */
 type LineCap = "round" | "butt" | "square";
-/**
- * Typography token combining font properties.
- * This is a composite type that combines multiple font-related properties.
- */
 type Typography = {
-    /** The font family to use */
     fontFamily: TokenValue<"fontFamily">;
-    /** The size of the font */
     fontSize: TokenValue<"dimension">;
-    /** Optional font weight */
     fontWeight?: TokenValue<"fontWeight">;
-    /** Optional letter spacing */
     letterSpacing?: TokenValue<"dimension">;
-    /** Optional line height as a multiplier */
     lineHeight?: TokenValue<"number">;
 };
-/**
- * Transition token defining animation properties.
- * Used to define how properties should animate between states.
- */
 type Transition = {
-    /** How long the transition should take */
     duration: TokenValue<"duration">;
-    /** Optional delay before the transition starts */
     delay?: TokenValue<"duration">;
-    /** The easing function to use for the transition */
     timingFunction: TokenValue<"cubicBezier">;
 };
-/**
- * Predefined stroke style keywords.
- * These are the standard stroke styles available in CSS.
- */
 type StrokeStyleKeyword = "solid" | "dashed" | "dotted" | "double" | "groove" | "ridge" | "outset" | "inset";
-/**
- * Custom stroke style definition.
- * Used when the predefined stroke styles are not sufficient.
- */
 type StrokeStyleCustom = {
-    /** Array of dimensions defining the dash pattern */
     dashArray: Array<TokenValue<"dimension">>;
-    /** How the ends of the stroke should be rendered */
     lineCap: LineCap;
 };
-/**
- * A stroke style can be either a predefined keyword or a custom definition.
- * This allows for both simple and complex stroke styles.
- */
 type StrokeStyle = StrokeStyleKeyword | StrokeStyleCustom;
-/**
- * Border token combining color, width, and style.
- * This is a composite type that defines a complete border.
- */
 type Border = {
-    /** The color of the border */
     color: TokenValue<"color">;
-    /** The width of the border */
     width: TokenValue<"dimension">;
-    /** The style of the border, either a stroke style or a reference to one */
     style: StrokeStyle | Reference<"strokeStyle">;
 };
-/**
- * A single shadow definition.
- * This is the basic building block for shadow tokens.
- */
 type ShadowObject = {
-    /** The color of the shadow */
     color: TokenValue<"color">;
-    /** Horizontal offset of the shadow */
     offsetX: TokenValue<"dimension">;
-    /** Vertical offset of the shadow */
     offsetY: TokenValue<"dimension">;
-    /** How much the shadow should blur */
     blur: TokenValue<"dimension">;
-    /** How much the shadow should spread */
     spread: TokenValue<"dimension">;
-    /** Whether the shadow should be inset */
     inset?: boolean;
 };
-/**
- * A shadow can be either a single shadow or multiple shadows.
- * Multiple shadows are rendered in order, with later shadows appearing on top.
- */
 type Shadow = ShadowObject | ShadowObject[];
-/**
- * A single stop in a gradient.
- * Defines the color and position of a point in the gradient.
- */
 type GradientStop = {
-    /** The color at this point in the gradient */
     color: TokenValue<"color">;
-    /** The position of this point in the gradient (0-1) */
     position: number | Reference<"number">;
 };
-/**
- * A gradient is defined by a series of stops.
- * The stops define how the gradient transitions between colors.
- */
 type Gradient = GradientStop[];
 
 /**
- * Source information for a token, tracking its collection, theme, and mode.
- * This metadata helps with error reporting and token organization.
+ * Source information for a token, tracking where it came from.
+ * Used for error reporting and context-aware processing.
  */
 type TokenSource = {
-    /** The collection this token belongs to (e.g., "base", "ui", "marketing") */
-    collection: string;
-    /** Optional theme name for color scheme variations (e.g., "ocean", "sunset") */
-    theme?: string;
-    /** Optional mode name for light/dark variations (e.g., "dark", "light") */
-    mode?: string;
-    /** The path to the source file containing this token */
+    /**
+     * The context name for modifier variations (e.g., "dark", "light").
+     * Aligns with DTCG Resolver Module 2025.10 terminology.
+     */
+    context?: string;
+    /** The file path where this token was defined. */
     sourcePath: string;
 };
 /**
- * A complete token tree with collection, theme, and mode information.
- * This represents a single token file's contents with its metadata.
+ * A loaded token file with its contents and source metadata.
+ * Represents a single token file after loading but before processing.
  */
 type TokenTree = {
-    /** The collection this token tree belongs to (e.g., "base", "ui", "marketing") */
-    collection: string;
-    /** Optional theme name for color scheme variations (e.g., "ocean", "sunset") */
-    theme?: string;
-    /** Optional mode name for light/dark variations (e.g., "dark", "light") */
-    mode?: string;
-    /** The actual token data following the W3C design tokens format */
+    /**
+     * The context name for modifier variations (e.g., "dark", "compact").
+     * Undefined for base/default tokens.
+     */
+    context?: string;
+    /** The token data following the W3C Design Tokens format. */
     tokens: TokenGroup;
-    /** The path to the source file containing these tokens */
+    /** The file path where these tokens were loaded from. */
     sourcePath: string;
 };
 
+type FlattenError = BaseError & {
+    path: string;
+    source: TokenSource;
+};
+
+/**
+ * A generated CSS file with its output path and content.
+ */
+type CSSFile = {
+    /** The file path where the CSS will be written. */
+    path: string;
+    /** The generated CSS content. */
+    css: string;
+};
+/**
+ * Array of generated CSS files from the pipeline.
+ * Each file contains a path and the CSS content to write.
+ */
+type CSSFileOutput = CSSFile[];
+
+/** In-memory token data keyed by file path. */
+type TokenMemoryData = Record<string, {
+    context?: string;
+    content: string;
+}>;
+type LoadError = BaseError & {
+    file: string;
+};
+
 /**
- * A resolved token with its final value.
- * Contains both the original token data and its resolved value after reference resolution.
- * @template T - The type of token (e.g., "color", "dimension", etc.)
+ * A token with all references resolved to their final values.
+ * Contains both the original value (which may include references)
+ * and the fully resolved value.
  */
 type ResolvedToken<T extends TokenType = TokenType> = NodeMetadata & {
-    /** The type of the token */
+    /** The token type (e.g., "color", "dimension"). */
     $type: T;
-    /** The original value of the token, which may contain references */
+    /** The original value, which may contain references like "{color.primary}". */
     $value: RawTokenValue<T>;
-    /** The path to this token in the token tree */
+    /** The dot-separated path to this token (e.g., "color.primary"). */
     $path: string;
-    /** Information about where this token was loaded from */
+    /** Source information about where this token was defined. */
     $source: TokenSource;
-    /** The original path before any resolution */
+    /** The original path before any processing. */
     $originalPath: string;
-    /** The final resolved value after all references are resolved */
+    /** The final value after all references have been resolved. */
     $resolvedValue: RawTokenValue<T>;
 };
 /**
- * A map of resolved tokens by their lookup path.
- * Used to store the final resolved state of all tokens in a collection.
- * Keys are token paths, values are either resolved tokens or node metadata.
+ * A collection of resolved tokens keyed by their lookup path.
+ * Includes both tokens and group metadata nodes.
  */
 type ResolvedTokens = {
-    /** Token path as key, resolved token or metadata as value */
     [lookupKey: string]: ResolvedToken | NodeMetadata;
 };
-/**
- * Type of resolution error that occurred.
- * - "circular": A circular reference was detected
- * - "missing": A referenced token could not be found
- * - "type-mismatch": A referenced token's type doesn't match the expected type
- */
 type ResolutionErrorType = "circular" | "missing" | "type-mismatch";
-/**
- * An error that occurred during token resolution.
- * Extends the base error type with resolution-specific information.
- */
 type ResolutionError = BaseError & {
-    /** The type of resolution error that occurred */
     type: ResolutionErrorType;
-    /** The path to the token that failed resolution */
     path: string;
-    /** Source information about where the token was loaded from */
+    source: TokenSource;
+};
+
+type ValidationError = BaseError & {
+    path: string;
     source: TokenSource;
 };
 
 /**
- * A token that has been converted to CSS properties.
- * Extends ResolvedToken with CSS-specific properties.
- * @template T The type of token
+ * Metadata about a modifier (e.g., theme, density) for CSS generation.
+ * Used to build attribute selectors like [data-theme="dark"].
  */
-type ConvertedToken<T extends TokenType = TokenType> = ResolvedToken<T> & {
-    /** The CSS properties generated from the token */
-    $cssProperties: CSSProperties<T>;
+type ModifierMeta = {
+    /** The modifier name (e.g., "theme", "density"). */
+    name: string;
+    /** The HTML attribute name (e.g., "data-theme", "data-density"). */
+    attribute: string;
+    /** The default context that uses :root selector. */
+    defaultContext: string;
+    /** Available non-default context names. */
+    contexts: string[];
 };
 /**
- * A collection of converted tokens.
- * Maps token paths to their converted values or metadata nodes.
+ * Result of running the token processing pipeline.
+ * Contains generated CSS output, processed tokens, and any errors encountered.
  */
-type ConvertedTokens = {
-    [lookupKey: string]: ConvertedToken | NodeMetadata;
+type PipelineResult = {
+    /** The generated CSS files ready to be written to disk. */
+    output: CSSFileOutput;
+    /** The loaded and processed token trees. */
+    trees: TokenTree[];
+    /** Modifier metadata for CSS selector generation. */
+    modifiers?: ModifierMeta[];
+    /** Any errors that occurred during pipeline execution. */
+    errors: PipelineErrors;
 };
 /**
- * A collection of converted tokens organized by mode (light/dark).
- * Each mode contains its own set of converted tokens.
+ * Errors organized by the pipeline stage where they occurred.
  */
-type ConvertedModeTokenSet = {
-    /** The default mode's tokens (typically light) */
-    default: ConvertedTokens;
-    /** Additional mode-specific tokens (e.g., dark) */
-    [mode: string]: ConvertedTokens;
+type PipelineErrors = {
+    /** Errors from loading token files. */
+    load: LoadError[];
+    /** Errors from flattening token trees. */
+    flatten: FlattenError[];
+    /** Errors from validating token values. */
+    validation: ValidationError[];
+    /** Errors from resolving token references. */
+    resolution: ResolutionError[];
 };
 /**
- * A collection of converted tokens organized by theme (color scheme).
- * Each theme contains modes (light/dark variations).
+ * Defines the source of tokens for the pipeline.
+ *
+ * @example
+ * // Load from a DTCG resolver document
+ * const source: TokenPipelineSource = {
+ *   type: "resolver",
+ *   resolverPath: "./tokens.resolver.json",
+ *   config: internalConfig
+ * };
+ *
+ * @example
+ * // Load from in-memory data (for testing)
+ * const source: TokenPipelineSource = {
+ *   type: "memory",
+ *   data: { "tokens.json": { content: '{"color": {...}}' } },
+ *   config: internalConfig
+ * };
  */
-type ConvertedThemeTokenSet = {
-    /** The default theme's modes */
-    default: ConvertedModeTokenSet;
-    /** Additional theme-specific modes (e.g., ocean, sunset) */
-    [theme: string]: ConvertedModeTokenSet;
+type TokenPipelineSource = {
+    type: "resolver";
+    /** Path to the DTCG resolver document (.resolver.json). */
+    resolverPath: string;
+    /** Pipeline configuration. */
+    config: InternalConfig;
+} | {
+    type: "memory";
+    /** In-memory token data keyed by file path. */
+    data: TokenMemoryData;
+    /** Pipeline configuration. */
+    config: InternalConfig;
 };
+
 /**
- * A collection of converted tokens organized by collection, theme, and mode.
- * Structure: collection → theme → mode → tokens
+ * Result of loading and resolving tokens.
  */
-type NormalizedConvertedTokens = {
-    [collection: string]: ConvertedThemeTokenSet;
+type LoadAndResolveResult = {
+    /** The loaded token trees */
+    trees: TokenTree[];
+    /** Resolved tokens after reference resolution */
+    resolved: ResolvedTokens;
+    /** Modifier metadata for CSS selector generation */
+    modifiers: ModifierMeta[];
+    /** Any errors that occurred */
+    errors: PipelineResult["errors"];
 };
 /**
- * CSS property types for different token types.
- * Maps token types to their corresponding CSS property structures.
- * @template T The type of token
+ * Core token processing pipeline that handles loading, validation, and resolution.
+ *
+ * This pipeline:
+ * 1. Loads token trees from resolver document or memory
+ * 2. Flattens trees into a single structure
+ * 3. Validates tokens for correctness
+ * 4. Resolves all token references
+ *
+ * For resolver sources, loads ALL contexts (not just default) and returns
+ * modifier metadata needed for CSS selector generation.
+ *
+ * @param source - The source of tokens to process (resolver or memory)
+ * @returns Processed tokens with modifier metadata and any errors
+ *
+ * @example
+ * const result = await loadAndResolveTokens({
+ *   type: "resolver",
+ *   resolverPath: "tokens.resolver.json",
+ *   config
+ * });
+ * // result.trees - all token trees (base + modifier contexts)
+ * // result.modifiers - metadata for CSS selectors
  */
-type CSSProperties<T extends TokenType> = T extends SimpleTokenType ? SimpleCSSProperties : T extends AlwaysDecomposedType ? AlwaysDecomposedProperties : T extends "border" ? CSSBorderProperties : T extends "shadow" ? CSSShadowProperties : T extends "gradient" ? CSSGradientProperties : T extends "transition" ? CSSTransitionProperties : T extends StructuralCompositeType ? SimpleCSSProperties : never;
+declare function loadAndResolveTokens(source: TokenPipelineSource): Promise<LoadAndResolveResult>;
+
+type ConvertedToken<T extends TokenType = TokenType> = ResolvedToken<T> & {
+    $cssProperties: CSSProperties<T>;
+};
+type ConvertedTokens = {
+    [lookupKey: string]: ConvertedToken | NodeMetadata;
+};
 /**
- * Simple CSS properties with a single value.
- * Used for tokens that map to a single CSS property.
+ * Tokens that have been converted to CSS properties, organized by context.
+ * Each context (e.g., "default", "dark") maps to its converted tokens.
  */
+type NormalizedConvertedTokens = {
+    [context: string]: ConvertedTokens;
+};
+type CSSProperties<T extends TokenType> = T extends SimpleTokenType ? SimpleCSSProperties : T extends AlwaysDecomposedType ? AlwaysDecomposedProperties : T extends "border" ? CSSBorderProperties : T extends "shadow" ? CSSShadowProperties : T extends "gradient" ? CSSGradientProperties : T extends "transition" ? CSSTransitionProperties : T extends StructuralCompositeType ? SimpleCSSProperties : never;
 type SimpleCSSProperties = {
-    /** The CSS value */
     value: string | number;
-    /** Optional feature queries for responsive values */
+    /** Feature queries for progressive enhancement (e.g., P3 colors). */
     featureValues?: Array<{
         query: string;
         value: string;
     }>;
 };
-/**
- * CSS properties that are always broken down into multiple properties.
- * Currently only used for typography tokens.
- */
 type AlwaysDecomposedProperties = CSSTypographyProperties;
-/**
- * CSS properties specific to typography tokens.
- * Maps typography tokens to their corresponding CSS properties.
- */
 type CSSTypographyProperties = {
-    /** The font family to use */
     "font-family": string;
-    /** The font size */
     "font-size": string;
-    /** The font weight */
     "font-weight"?: number | string;
-    /** The letter spacing */
     "letter-spacing"?: string;
-    /** The line height */
     "line-height"?: number | string;
 };
-/**
- * CSS properties for specific token types.
- * These types represent tokens that map to single CSS properties.
- */
-/**
- * CSS properties for border tokens.
- */
 type CSSBorderProperties = {
-    /** The border value */
     value: string;
 };
-/**
- * CSS properties for shadow tokens.
- */
 type CSSShadowProperties = {
-    /** The shadow value */
     value: string;
 };
-/**
- * CSS properties for gradient tokens.
- */
 type CSSGradientProperties = {
-    /** The gradient value */
     value: string;
 };
-/**
- * CSS properties for transition tokens.
- */
 type CSSTransitionProperties = {
-    /** The transition value */
     value: string;
 };
 
-/**
- * Represents a single CSS file output with its path and content
- */
-type CSSFile = {
-    /** The path where the CSS file will be written */
-    path: string;
-    /** The CSS content to write to the file */
-    css: string;
-    /** The collection name (e.g., "default", "base", "ui", "marketing") */
-    collection: string;
-};
-/**
- * Represents multiple CSS file outputs from generateSeparateFiles or generateSingleFile
- */
-type CSSFileOutput = CSSFile[];
-
-declare function generateCSSVariables(convertedTokens: NormalizedConvertedTokens, config: InternalConfig): Promise<CSSFileOutput>;
-
-/**
- * An error that occurred during token flattening.
- * Extends the base error type with flattening-specific information.
- */
-type FlattenError = BaseError & {
-    /** The path to the token that failed flattening */
-    path: string;
-    /** Source information about where the token was loaded from */
-    source: TokenSource;
-};
-
-/**
- * Result of loading a Sugarcube configuration file
- */
-type LoadedConfig = {
-    /** The validated configuration */
-    config: InternalConfig;
-    /** The path to the config file that was loaded */
-    configPath: string;
-};
-/**
- * Data structure for loading tokens from memory.
- * Maps file paths to their token content and metadata.
- * Used for programmatic token loading.
- */
-type TokenMemoryData = Record<string, {
-    /** The collection name this token belongs to */
-    collection: string;
-    /** Optional theme name for color scheme variations */
-    theme?: string;
-    /** Optional mode name for light/dark variations */
-    mode?: string;
-    /** The raw token content as a string */
-    content: string;
-}>;
-/**
- * An error that occurred during token loading.
- * Extends the base error type with file-specific information.
- */
-type LoadError = BaseError & {
-    /** The file path where the error occurred */
-    file: string;
-};
-
-/**
- * An error that occurred during token validation.
- * Extends the base error type with token-specific information.
- */
-type ValidationError = BaseError & {
-    /** The path to the token that failed validation */
-    path: string;
-    /** Source information about where the token was loaded from */
-    source: TokenSource;
-};
-
-/**
- * Result of running any pipeline.
- * Contains the generated output, token trees, and any errors.
- */
-type PipelineResult = {
-    /** The generated output (e.g. CSS files) */
-    output: CSSFileOutput;
-    /** The loaded token trees */
-    trees: TokenTree[];
-    /** Any errors that occurred during pipeline execution */
-    errors: PipelineErrors;
-};
-/**
- * Common error types that can occur during pipeline execution.
- * Organizes errors by the pipeline stage where they occurred.
- */
-type PipelineErrors = {
-    /** Errors that occurred during token loading */
-    load: LoadError[];
-    /** Errors that occurred during token flattening */
-    flatten: FlattenError[];
-    /** Errors that occurred during token validation */
-    validation: ValidationError[];
-    /** Errors that occurred during token resolution */
-    resolution: ResolutionError[];
-};
-/**
- * Defines how tokens should be loaded and processed.
- * Either from files using a config, or from memory with token data.
- */
-type TokenPipelineSource = {
-    type: "files";
-    config: InternalConfig;
-} | {
-    type: "memory";
-    data: Record<string, {
-        collection: string;
-        content: string;
-    }>;
-    config: InternalConfig;
-};
-/**
- * Options for loading tokens in the pipeline.
- * Specifies whether to load tokens from files or memory.
- */
-type TokenLoader = {
-    type: "files";
-    paths: InternalConfig;
-} | {
-    type: "memory";
-    data: TokenMemoryData;
-};
-
-/**
- * Core token processing pipeline that handles loading, validation, and resolution of tokens.
- * This is the foundation for all other token processing operations.
- *
- * This pipeline:
- * 1. Loads token trees from config or memory
- * 2. Flattens trees into a single structure
- * 3. Validates tokens for correctness
- * 4. Resolves all token references
- *
- * Each stage can produce errors which are collected and returned in the result.
- *
- * @param source - The source of tokens to process, either from memory or config
- * @returns An object containing the processed trees, resolved tokens, and any errors
- *
- * @example
- * const result = await loadAndResolveTokens({ type: "config", config });
- * if (result.errors.validation.length > 0) {
- *   console.error("Validation failed:", result.errors.validation);
- * }
- */
-declare function loadAndResolveTokens(source: TokenPipelineSource): Promise<{
-    trees: TokenTree[];
-    resolved: ResolvedTokens;
-    errors: PipelineResult["errors"];
-}>;
-
-type NamedUtilityValue = {
-    kind: "named";
-    value: string;
-    fraction: string | null;
-};
-type ArbitraryUtilityValue = {
-    kind: "arbitrary";
-    value: string;
-};
-type UtilityValue = NamedUtilityValue | ArbitraryUtilityValue;
-type StaticVariant = {
-    kind: "static";
-    root: string;
-};
-type FunctionalVariant = {
-    kind: "functional";
-    root: string;
-    value: UtilityValue;
-};
-type Variant = StaticVariant | FunctionalVariant;
-type StaticCandidate = {
-    kind: "static";
-    root: string;
-    variants: Variant[];
-    raw: string;
-};
-type FunctionalCandidate = {
-    kind: "functional";
-    root: string;
-    value: UtilityValue | null;
-    variants: Variant[];
-    raw: string;
-};
-type Candidate = StaticCandidate | FunctionalCandidate;
-interface StaticUtilityPattern {
-    properties: string[];
-    validator: (candidate: Candidate) => boolean;
-    generator: (candidate: Candidate) => string;
-}
-
 /**
  * Processes and converts token trees into CSS-ready format.
  * This pipeline:
  * 1. Processes trees with resolved tokens to create a unified structure
- * 2. Normalizes tokens into a collection-theme organization
+ * 2. Normalizes tokens into a context-based organization
  * 3. Converts tokens to their CSS representations with properties
  *
  *
@@ -781,12 +576,67 @@ interface StaticUtilityPattern {
  *
  * @example
  * const convertedTokens = await processAndConvertTokens(trees, resolved, config);
- * // convertedTokens = { collection: { theme: { "token.path": { $cssProperties: {...} } } } }
+ * // convertedTokens = { "default": { "token.path": { $cssProperties: {...} } }, "dark": {...} }
  */
 declare function processAndConvertTokens(trees: TokenTree[], resolved: ResolvedTokens, config: InternalConfig, validationErrors?: ValidationError[]): Promise<NormalizedConvertedTokens>;
 
-declare function generateIndex(stylesDir: string, config: InternalConfig): Promise<string>;
-declare function shouldRegenerateIndex(stylesDir: string, config: InternalConfig): Promise<boolean>;
+/**
+ * Generate CSS variable files from converted tokens.
+ *
+ * @param convertedTokens - The normalized and converted tokens
+ * @param config - The configuration object
+ * @param modifiers - Optional modifier metadata for generating per-modifier attribute selectors
+ * @returns Array of CSS file outputs
+ */
+declare function generateCSSVariables(convertedTokens: NormalizedConvertedTokens, config: InternalConfig, modifiers?: ModifierMeta[]): Promise<CSSFileOutput>;
+
+type CSSObject = Record<string, string | number | undefined>;
+/**
+ * Clears the token matching cache.
+ * Call this when tokens change (e.g., on hot reload in dev mode).
+ */
+declare function clearMatchCache(): void;
+/**
+ * Converts a utilities configuration into UnoCSS dynamic rules.
+ *
+ * @param utilitiesConfig - The utilities configuration from sugarcube.config
+ * @param tokens - The converted tokens to generate rules for
+ * @returns Array of UnoCSS dynamic rules [pattern, handler]
+ */
+declare function convertConfigToUnoRules(utilitiesConfig: UtilitiesConfig, tokens: NormalizedConvertedTokens): Array<[RegExp, (m: RegExpMatchArray) => CSSObject]>;
+
+/**
+ * Performance monitor for tracking memory usage and watcher events.
+ * Only active when SUGARCUBE_PERF=true environment variable is set.
+ */
+declare class PerfMonitor implements Disposable {
+    #private;
+    private defaultFlush;
+    constructor(defaultFlush?: (message: string) => undefined);
+    log(message: string, data?: Record<string, unknown>): void;
+    trackWatcherEvent(file: string, moduleGraphSize: number): void;
+    logWatcherSetup(pattern: string, dir: string): void;
+    logModuleGraphStats(modules: number, urls: number, context: string): void;
+    startMemoryMonitor(): void;
+    stopMemoryMonitor(): void;
+    [Symbol.dispose](): void;
+}
+
+/**
+ * Instrumentation for tracking function call counts and execution times.
+ * Only active when DEBUG=true environment variable is set.
+ * Inspired by Tailwind CSS instrumentation.
+ */
+declare class Instrumentation implements Disposable {
+    #private;
+    private defaultFlush;
+    constructor(defaultFlush?: (message: string) => undefined);
+    hit(label: string): void;
+    start(label: string): void;
+    end(label: string): void;
+    report(flush?: (message: string) => undefined): void;
+    [Symbol.dispose](): void;
+}
 
 /**
  * Writes CSS files to disk, creating directories as needed.
@@ -828,293 +678,8 @@ declare function writeCSSVariablesToDisk(output: CSSFileOutput): Promise<CSSFile
  */
 declare function writeCSSUtilitiesToDisk(output: CSSFileOutput): Promise<CSSFileOutput>;
 
-declare function findConfigFile(basePath?: string): string | null;
-declare function configFileExists(basePath?: string): boolean;
-declare function loadTSConfig(configPath: string): Promise<unknown>;
-declare function loadUserConfig(configPath?: string): Promise<{
-    config: UserConfig;
-    configPath: string;
-}>;
-declare function loadInternalConfig(configPath?: string): Promise<LoadedConfig>;
-
-/**
- * Validates a user configuration object against the user schema.
- *
- * @param config - The user configuration object to validate
- * @returns The validated user configuration
- * @throws Error if the configuration is invalid
- */
-declare function validateUserConfig(config: Partial<UserConfig>): UserConfig;
-/**
- * Validates an internal configuration object against the internal schema and checks for duplicate filenames.
- *
- * @param config - The internal configuration object to validate
- * @returns The validated internal configuration
- * @throws Error if the configuration is invalid or contains duplicate filenames
- */
-declare function validateInternalConfig(config: InternalConfig): InternalConfig;
-/**
- * Validates a user configuration object against the schema and fills in defaults.
- *
- * This function:
- * 1. Validates the configuration structure using the user schema
- * 2. Fills in default values
- * 3. Validates the complete configuration using the internal schema
- * 4. Checks for duplicate filenames across collections
- * 5. Returns the validated configuration with defaults filled in
- *
- * @param config - The user configuration object to validate
- * @returns The validated configuration with defaults filled in
- * @throws Error if the configuration is invalid or contains duplicate filenames
- *
- * @example
- * const config = {
- *   tokens: {
- *     source: ["tokens.json"]
- *   }
- * };
- * const validatedConfig = validateConfig(config);
- * // validatedConfig.output.css === "src/styles" (default filled in)
- */
-declare function validateConfig(config: Partial<UserConfig>): InternalConfig;
-/**
- * Parses and validates a JSON configuration string.
- *
- * This function:
- * 1. Parses the JSON string into a configuration object
- * 2. Validates and normalizes the configuration using validateConfig
- * 3. Returns the validated and normalized configuration
- *
- * @param configString - The JSON configuration string to parse and validate
- * @returns The validated and normalized configuration
- * @throws Error if the JSON is invalid or the configuration is invalid
- *
- * @example
- * const configString = `{
- *   "tokens": {
- *     "source": ["tokens.json"]
- *   }
- * }`;
- * const config = parseAndValidateConfig(configString);
- * // config.output.css === "src/styles" (default filled in)
- */
-declare function parseAndValidateConfig(configString: string): InternalConfig;
-
-/**
- * Fills in default values for any omitted fields in a user configuration.
- *
- * This function takes a user config (with optional fields) and
- * returns a complete internal config (with all required fields filled in).
- *
- * @param userConfig - The user configuration with optional fields
- * @returns A complete configuration with all defaults filled in
- *
- * @example
- * const userConfig = {
- *   tokens: { source: ["tokens/*.json"] }
- * };
- * const completeConfig = fillDefaults(userConfig);
- * // completeConfig.output.css === "src/styles"
- * // completeConfig.output.components === "src/ui/components"
- * // completeConfig.output.separate === false
- */
-declare function fillDefaults(userConfig: UserConfig): InternalConfig;
-
-interface CSSImport {
-    path: string;
-    layer: string;
-    relativePath: string;
-}
-declare function discoverAllFiles(stylesDir: string, config: InternalConfig): Promise<CSSImport[]>;
-
-declare function generateIndexContent(files: CSSImport[]): string;
-
-declare class Instrumentation implements Disposable {
-    #private;
-    private defaultFlush;
-    constructor(defaultFlush?: (message: string) => undefined);
-    hit(label: string): void;
-    start(label: string): void;
-    end(label: string): void;
-    report(flush?: (message: string) => undefined): void;
-    [Symbol.dispose](): void;
-}
-
-type CSSObject = Record<string, string | number | undefined>;
-declare function convertConfigToUnoRules(utilitiesConfig: UtilitiesConfig, tokens: NormalizedConvertedTokens): Array<[RegExp, (m: RegExpMatchArray) => CSSObject]>;
-
-declare const SUGARCUBE_FILE = "_sugarcube.css";
-declare const GLOBAL_DIR = "global";
-declare const UTILITIES_DIR = "utilities";
-declare const VARIABLES_FILE_SUFFIX = ".variables.gen.css";
-declare const DEFAULT_VARIABLES_FILENAME = "tokens";
-declare const DEFAULT_UTILITIES_FILENAME = "utilities.gen.css";
-declare const DEFAULT_STYLES_PATH = "src/styles";
-declare const DEFAULT_DESIGN_TOKENS_PATH = "src/design-tokens";
-declare const SUGARCUBE_CONFIG_FILE = "sugarcube.config.ts";
-
-declare const DEFAULT_CONFIG: {
-    readonly output: {
-        readonly css: "src/styles";
-        readonly components: "src/components/ui";
-        readonly separate: false;
-        readonly modeAttribute: "data-mode";
-        readonly themeAttribute: "data-theme";
-    };
-    readonly transforms: {
-        readonly fluid: {
-            readonly min: 320;
-            readonly max: 1200;
-        };
-        readonly colorFallbackStrategy: "native";
-    };
-};
-
-declare const DEFAULT_COLLECTION = "default";
-declare const DEFAULT_THEME = "default";
-declare const DEFAULT_MODE = "default";
-
-declare const ErrorMessages: {
-    readonly LOAD: {
-        readonly NO_FILES_FOUND: (pattern: string) => string;
-        readonly INVALID_JSON: (path: string, message: string) => string;
-        readonly GLOB_ERROR: (pattern: string, error: string) => string;
-    };
-    readonly FLATTEN: {
-        readonly INVALID_TOKEN_NAME: (name: string) => string;
-        readonly MISSING_DOLLAR_PREFIX: (path: string) => string;
-        readonly INVALID_TOKEN_NESTING: (path: string) => string;
-        readonly COMPOSITE_TOKEN_MISSING_TYPE: (path: string) => string;
-        readonly CONFLICT_TOKEN_VS_GROUP: (path: string) => string;
-        readonly CONFLICT_INCOMPATIBLE_TYPES: (expected: string, received: string, path: string) => string;
-    };
-    readonly METADATA: {
-        readonly COLLECTION_ERROR: (message: string) => string;
-        readonly INVALID_EXTENSIONS: (path: string) => string;
-        readonly INVALID_DESCRIPTION: (path: string) => string;
-    };
-    readonly VALIDATE: {
-        readonly MISSING_TYPE: (path: string) => string;
-        readonly UNKNOWN_TOKEN_TYPE: (type: string, path: string) => string;
-        readonly INVALID_COLOR: (value: unknown, path: string) => string;
-        readonly INVALID_DIMENSION: (value: unknown, path: string) => string;
-        readonly INVALID_DIMENSION_UNIT: (unit: unknown, path: string) => string;
-        readonly INVALID_FONT_FAMILY: (value: unknown, path: string) => string;
-        readonly INVALID_FONT_WEIGHT: (value: unknown, path: string) => string;
-        readonly INVALID_DURATION: (value: unknown, path: string) => string;
-        readonly INVALID_DURATION_UNIT: (unit: unknown, path: string) => string;
-        readonly INVALID_CUBIC_BEZIER: (value: unknown, path: string) => string;
-        readonly INVALID_STROKE_STYLE: (value: unknown, path: string) => string;
-        readonly INVALID_STROKE_LINE_CAP: (value: unknown, path: string) => string;
-        readonly INVALID_BORDER: (value: unknown, path: string) => string;
-        readonly INVALID_SHADOW: (value: unknown, path: string) => string;
-        readonly INVALID_SHADOW_INSET: (value: unknown, path: string) => string;
-        readonly INVALID_TRANSITION: (value: unknown, path: string) => string;
-        readonly INVALID_GRADIENT: (value: unknown, path: string) => string;
-        readonly INVALID_GRADIENT_STOP_POSITION: (value: unknown, path: string) => string;
-        readonly INVALID_TYPOGRAPHY: (value: unknown, path: string) => string;
-        readonly MISSING_REQUIRED_PROPERTY: (prop: string, path: string) => string;
-        readonly INVALID_NUMBER: (value: unknown, path: string) => string;
-        readonly INVALID_ARRAY: (value: unknown, path: string) => string;
-        readonly MISSING_FLUID_CONFIG: (path: string) => string;
-        readonly INVALID_FLUID_DIMENSION: (value: unknown, path: string) => string;
-        readonly INVALID_VIEWPORT_CONFIG: (value: unknown, path: string) => string;
-        readonly MISMATCHED_UNITS: (unit1: unknown, unit2: unknown, path: string) => string;
-        readonly INVALID_FLUID_VALUE_RANGE: (path: string) => string;
-        readonly INVALID_TOKEN_TYPE: (expected: string, received: string, path: string) => string;
-        readonly INVALID_TYPE: (expected: string, value: unknown, path: string) => string;
-        readonly INVALID_ENUM_VALUE: (enumValues: unknown[], value: unknown, path: string) => string;
-    };
-    readonly RESOLVE: {
-        readonly CIRCULAR_REFERENCE: (path: string, ref: string) => string;
-        readonly REFERENCE_NOT_FOUND: (ref: string, path: string) => string;
-        readonly TYPE_MISMATCH: (path: string) => string;
-    };
-    readonly GENERATE: {
-        readonly INVALID_CSS_VALUE: (key: string, value: unknown) => string;
-        readonly INVALID_VARIABLE_NAME: (path: string, name: string) => string;
-    };
-    readonly CONFIG: {
-        readonly INVALID_JSON: (error: string) => string;
-        readonly INVALID_CONFIG: (path: string, message: string) => string;
-        readonly DUPLICATE_FILENAMES: (collection: string, filename: string, paths: string[]) => string;
-        readonly FILE_NOT_FOUND: (path: string) => string;
-    };
-    readonly UTILITIES: {
-        readonly RESERVED_PREFIX: (prefix: string, tokenType: string) => string;
-        readonly DUPLICATE_CLASS_NAME: (className: string, paths: string[]) => string;
-        readonly INVALID_PROPERTY_MAPPING: (tokenType: string) => string;
-        readonly DUPLICATE_PREFIX: (prefix: string, tokenType: string) => string;
-        readonly INVALID_COLLECTION: (property: string, collection: string, availableCollections: string[]) => string;
-        readonly TOKEN_PATH_CONFLICT: (tokenPath: string, collections: string) => string;
-        readonly MISSING_SOURCE: (property: string) => string;
-        readonly INVALID_SOURCE_PATTERN: (property: string, source: string) => string;
-        readonly INVALID_DIRECTIONS: (property: string) => string;
-        readonly INVALID_CONFIG_OBJECT: "utilitiesConfig must be an object";
-        readonly INVALID_TOKENS_OBJECT: "tokens must be an object";
-    };
-};
-
 declare const userConfigSchema: z.ZodObject<{
-    tokens: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodObject<{
-        source: z.ZodArray<z.ZodString, "many">;
-        /** Mode variations (light/dark) - generates [data-mode="..."] selectors */
-        modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        /** Theme variations (color schemes) - generates [data-theme="..."] selectors */
-        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
-            source: z.ZodArray<z.ZodString, "many">;
-            modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        }, "strip", z.ZodTypeAny, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }>]>>>;
-    }, "strip", z.ZodTypeAny, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }>>, z.ZodObject<{
-        source: z.ZodArray<z.ZodString, "many">;
-        /** Mode variations (light/dark) - generates [data-mode="..."] selectors */
-        modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        /** Theme variations (color schemes) - generates [data-theme="..."] selectors */
-        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
-            source: z.ZodArray<z.ZodString, "many">;
-            modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        }, "strip", z.ZodTypeAny, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }>]>>>;
-    }, "strip", z.ZodTypeAny, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }>]>>;
+    resolver: z.ZodOptional<z.ZodString>;
     transforms: z.ZodOptional<z.ZodObject<{
         fluid: z.ZodOptional<z.ZodObject<{
             min: z.ZodNumber;
@@ -1141,22 +706,28 @@ declare const userConfigSchema: z.ZodObject<{
         colorFallbackStrategy?: "native" | "polyfill" | undefined;
     }>>;
     output: z.ZodOptional<z.ZodObject<{
-        css: z.ZodOptional<z.ZodString>;
+        cssRoot: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodString>;
+        utilities: z.ZodOptional<z.ZodString>;
+        cube: z.ZodOptional<z.ZodString>;
         components: z.ZodOptional<z.ZodString>;
-        separate: z.ZodOptional<z.ZodBoolean>;
-        modeAttribute: z.ZodOptional<z.ZodString>;
         themeAttribute: z.ZodOptional<z.ZodString>;
+        defaultContext: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        css?: string | undefined;
+        defaultContext?: string | undefined;
         components?: string | undefined;
-        separate?: boolean | undefined;
-        modeAttribute?: string | undefined;
+        cssRoot?: string | undefined;
+        variables?: string | undefined;
+        utilities?: string | undefined;
+        cube?: string | undefined;
         themeAttribute?: string | undefined;
     }, {
-        css?: string | undefined;
+        defaultContext?: string | undefined;
         components?: string | undefined;
-        separate?: boolean | undefined;
-        modeAttribute?: string | undefined;
+        cssRoot?: string | undefined;
+        variables?: string | undefined;
+        utilities?: string | undefined;
+        cube?: string | undefined;
         themeAttribute?: string | undefined;
     }>>;
     utilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
@@ -1164,54 +735,34 @@ declare const userConfigSchema: z.ZodObject<{
         directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, "many">]>>;
         prefix: z.ZodOptional<z.ZodString>;
         stripDuplicates: z.ZodOptional<z.ZodBoolean>;
-        collection: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     }, {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     }>, z.ZodArray<z.ZodObject<{
         source: z.ZodString;
         directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, "many">]>>;
         prefix: z.ZodOptional<z.ZodString>;
         stripDuplicates: z.ZodOptional<z.ZodBoolean>;
-        collection: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     }, {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     }>, "many">]>>>;
 }, "strip", z.ZodTypeAny, {
-    tokens?: {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    } | Record<string, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }> | undefined;
+    resolver?: string | undefined;
     transforms?: {
         fluid?: {
             min: number;
@@ -1219,42 +770,28 @@ declare const userConfigSchema: z.ZodObject<{
         } | undefined;
         colorFallbackStrategy?: "native" | "polyfill" | undefined;
     } | undefined;
-    output?: {
-        css?: string | undefined;
-        components?: string | undefined;
-        separate?: boolean | undefined;
-        modeAttribute?: string | undefined;
-        themeAttribute?: string | undefined;
-    } | undefined;
     utilities?: Record<string, {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     } | {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     }[]> | undefined;
+    output?: {
+        defaultContext?: string | undefined;
+        components?: string | undefined;
+        cssRoot?: string | undefined;
+        variables?: string | undefined;
+        utilities?: string | undefined;
+        cube?: string | undefined;
+        themeAttribute?: string | undefined;
+    } | undefined;
 }, {
-    tokens?: {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    } | Record<string, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }> | undefined;
+    resolver?: string | undefined;
     transforms?: {
         fluid?: {
             min: number;
@@ -1262,276 +799,26 @@ declare const userConfigSchema: z.ZodObject<{
         } | undefined;
         colorFallbackStrategy?: "native" | "polyfill" | undefined;
     } | undefined;
-    output?: {
-        css?: string | undefined;
-        components?: string | undefined;
-        separate?: boolean | undefined;
-        modeAttribute?: string | undefined;
-        themeAttribute?: string | undefined;
-    } | undefined;
     utilities?: Record<string, {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     } | {
         source: string;
         directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
         prefix?: string | undefined;
         stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    }[]> | undefined;
-}>;
-declare const internalConfigSchema: z.ZodObject<{
-    tokens: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodObject<{
-        source: z.ZodArray<z.ZodString, "many">;
-        /** Mode variations (light/dark) - generates [data-mode="..."] selectors */
-        modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        /** Theme variations (color schemes) - generates [data-theme="..."] selectors */
-        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
-            source: z.ZodArray<z.ZodString, "many">;
-            modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        }, "strip", z.ZodTypeAny, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }>]>>>;
-    }, "strip", z.ZodTypeAny, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }>>, z.ZodObject<{
-        source: z.ZodArray<z.ZodString, "many">;
-        /** Mode variations (light/dark) - generates [data-mode="..."] selectors */
-        modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        /** Theme variations (color schemes) - generates [data-theme="..."] selectors */
-        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
-            source: z.ZodArray<z.ZodString, "many">;
-            modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-        }, "strip", z.ZodTypeAny, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }, {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }>]>>>;
-    }, "strip", z.ZodTypeAny, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }>]>>;
-    transforms: z.ZodObject<{
-        fluid: z.ZodObject<{
-            min: z.ZodNumber;
-            max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            min: number;
-            max: number;
-        }, {
-            min: number;
-            max: number;
-        }>;
-        colorFallbackStrategy: z.ZodEnum<["native", "polyfill"]>;
-    }, "strip", z.ZodTypeAny, {
-        fluid: {
-            min: number;
-            max: number;
-        };
-        colorFallbackStrategy: "native" | "polyfill";
-    }, {
-        fluid: {
-            min: number;
-            max: number;
-        };
-        colorFallbackStrategy: "native" | "polyfill";
-    }>;
-    output: z.ZodObject<{
-        css: z.ZodString;
-        components: z.ZodString;
-        separate: z.ZodBoolean;
-        modeAttribute: z.ZodString;
-        themeAttribute: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        components: string;
-        css: string;
-        separate: boolean;
-        modeAttribute: string;
-        themeAttribute: string;
-    }, {
-        components: string;
-        css: string;
-        separate: boolean;
-        modeAttribute: string;
-        themeAttribute: string;
-    }>;
-    utilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        source: z.ZodString;
-        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, "many">]>>;
-        prefix: z.ZodOptional<z.ZodString>;
-        stripDuplicates: z.ZodOptional<z.ZodBoolean>;
-        collection: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    }, {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    }>, z.ZodArray<z.ZodObject<{
-        source: z.ZodString;
-        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full", "all"]>, "many">]>>;
-        prefix: z.ZodOptional<z.ZodString>;
-        stripDuplicates: z.ZodOptional<z.ZodBoolean>;
-        collection: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    }, {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    }>, "many">]>>>;
-}, "strip", z.ZodTypeAny, {
-    output: {
-        components: string;
-        css: string;
-        separate: boolean;
-        modeAttribute: string;
-        themeAttribute: string;
-    };
-    transforms: {
-        fluid: {
-            min: number;
-            max: number;
-        };
-        colorFallbackStrategy: "native" | "polyfill";
-    };
-    tokens?: {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    } | Record<string, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }> | undefined;
-    utilities?: Record<string, {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    } | {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    }[]> | undefined;
-}, {
-    output: {
-        components: string;
-        css: string;
-        separate: boolean;
-        modeAttribute: string;
-        themeAttribute: string;
-    };
-    transforms: {
-        fluid: {
-            min: number;
-            max: number;
-        };
-        colorFallbackStrategy: "native" | "polyfill";
-    };
-    tokens?: {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    } | Record<string, {
-        source: string[];
-        modes?: Record<string, string[]> | undefined;
-        themes?: Record<string, string[] | {
-            source: string[];
-            modes?: Record<string, string[]> | undefined;
-        }> | undefined;
-    }> | undefined;
-    utilities?: Record<string, {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
-    } | {
-        source: string;
-        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full" | "all")[] | undefined;
-        prefix?: string | undefined;
-        stripDuplicates?: boolean | undefined;
-        collection?: string | undefined;
     }[]> | undefined;
+    output?: {
+        defaultContext?: string | undefined;
+        components?: string | undefined;
+        cssRoot?: string | undefined;
+        variables?: string | undefined;
+        utilities?: string | undefined;
+        cube?: string | undefined;
+        themeAttribute?: string | undefined;
+    } | undefined;
 }>;
 
-/**
- * Type guards for configuration objects.
- * Functions to check the structure and type of configuration data.
- */
-/**
- * Type guard to check if tokens is a single collection.
- *
- * @param tokens - The tokens configuration to check
- * @returns True if tokens is a single collection, false if it's multiple collections
- *
- * @example
- * if (isSingleCollection(config.tokens)) {
- *   // config.tokens is TokenCollection
- * } else {
- *   // config.tokens is TokenCollections
- * }
- */
-declare function isSingleCollection(tokens: TokenCollection | TokenCollections): tokens is TokenCollection;
-
-declare function isResolvedToken(token: unknown): token is ResolvedToken;
-declare function isResolvedTokenOfType<T extends TokenType>(token: unknown, type: T): token is ResolvedToken<T>;
-
-export { type ArbitraryUtilityValue, type CSSFileOutput, type Candidate, DEFAULT_COLLECTION, DEFAULT_CONFIG, DEFAULT_DESIGN_TOKENS_PATH, DEFAULT_MODE, DEFAULT_STYLES_PATH, DEFAULT_THEME, DEFAULT_UTILITIES_FILENAME, DEFAULT_VARIABLES_FILENAME, ErrorMessages, type FunctionalCandidate, type FunctionalVariant, GLOBAL_DIR, Instrumentation, type InternalConfig, type LoadedConfig, type NamedUtilityValue, type NormalizedConvertedTokens, type OutputConfig, type PipelineResult, type ResolvedToken, type ResolvedTokens, SUGARCUBE_CONFIG_FILE, SUGARCUBE_FILE, type StaticCandidate, type StaticUtilityPattern, type StaticVariant, type ThemeConfig, type TokenCollection, type TokenCollections, type TokenLoader, type TokenPipelineSource, type TokenTree, UTILITIES_DIR, type UserConfig, type UserOutputConfig, type UtilitiesConfig, type UtilityValue, VARIABLES_FILE_SUFFIX, type Variant, configFileExists, convertConfigToUnoRules, discoverAllFiles, fillDefaults, findConfigFile, generateCSSVariables, generateIndex, generateIndexContent, internalConfigSchema, isResolvedToken, isResolvedTokenOfType, isSingleCollection, loadAndResolveTokens, loadInternalConfig, loadTSConfig, loadUserConfig, parseAndValidateConfig, processAndConvertTokens, shouldRegenerateIndex, userConfigSchema, validateConfig, validateInternalConfig, validateUserConfig, writeCSSUtilitiesToDisk, writeCSSVariablesToDisk };
+export { type CSSFileOutput, DEFAULT_CONFIG, Instrumentation, type InternalConfig, type ModifierMeta, type NormalizedConvertedTokens, PerfMonitor, type ResolvedTokens, type SugarcubeConfig, type TokenPipelineSource, type TokenTree, clearMatchCache, configFileExists, convertConfigToUnoRules, fillDefaults, generateCSSVariables, loadAndResolveTokens, loadInternalConfig, loadSugarcubeConfig, processAndConvertTokens, userConfigSchema, validateConfig, writeCSSUtilitiesToDisk, writeCSSVariablesToDisk };