@tenphi/tasty 2.11.1 → 3.0.0

package/dist/{index-BYtnj_gA.d.ts → index-BAAbdfRs.d.ts}

@@ -1,6 +1,6 @@
-import { Dt as StyleInjectorConfig, I as StyleValue, L as StyleValueStateMap, b as Styles, bt as KeyframesResult, ct as CacheMetrics, dt as FontFaceDescriptors, ft as FontFaceInput, gt as InjectResult, ht as GlobalInjectResult, it as StyleDetails, lt as CounterStyleDescriptors, mt as GCOptions, n as StyleResult, st as CSSProperties$1, x as StylesInterface, xt as KeyframesSteps } from "./index-B9ih23uv.js";
-import { g as TastyPluginFactory, x as StyleInjector } from "./config-BtK9fUaz.js";
-import { t as ServerStyleCollector } from "./collector-DYA5AOwr.js";
+import { _ as TastyPluginFactory, w as StyleInjector } from "./config-D2INrjr_.js";
+import { B as StyleValueStateMap, Ct as PropertyOptions, D as CSSMap, I as StyleHandlerResult, M as ResolvedStyleValue, Ot as StyleInjectorConfig, R as StylePropValue, at as CSSProperties$1, b as Styles, bt as KeyframesResult, dt as FunctionDefinition, gt as InjectResult, ht as GlobalInjectResult, j as RawStyleHandler, lt as FontFaceDescriptors, mt as GCOptions, n as StyleResult, nt as StyleDetails, ot as CacheMetrics, st as CounterStyleDescriptors, ut as FontFaceInput, x as StylesInterface, xt as KeyframesSteps, z as StyleValue } from "./index-l_NdJSUS.js";
+import { t as ServerStyleCollector } from "./collector-BPzZezAG.js";
 import { AllHTMLAttributes, CSSProperties, ComponentType, ElementType, ForwardRefExoticComponent, JSX, PropsWithoutRef, RefAttributes } from "react";
 
 //#region src/utils/name-prefix.d.ts
@@ -44,9 +44,6 @@ declare const OUTER_STYLES: readonly ["gridArea", "order", "gridColumn", "gridRo
 declare const INNER_STYLES: readonly ["display", "font", "preset", "hide", "whiteSpace", "opacity", "transition", "color", "fill", "fade", "image", "padding", "paddingInline", "paddingBlock", "overflow", "scrollbar", "textAlign", "flow", "place", "placeItems", "placeContent", "alignItems", "alignContent", "justifyItems", "justifyContent", "align", "justify", "gap", "columnGap", "rowGap", "gridColumns", "gridRows", "gridTemplate", "gridAreas"];
 //#endregion
 //#region src/types.d.ts
-interface GlobalStyledProps {
-  breakpoints?: number[];
-}
 /**
  * Extensible interface for theme names.
  * Augment this interface to register project-specific theme names for autocomplete.
@@ -64,6 +61,42 @@ interface GlobalStyledProps {
 interface TastyThemeNames {}
 type ThemeNameKey = Extract<keyof TastyThemeNames, string>;
 type ThemeName = [ThemeNameKey] extends [never] ? string : ThemeNameKey;
+/**
+ * Extensible interface for custom props added via `configure({ propHandlers })`.
+ * Augment it to type those props on every tasty component.
+ *
+ * @example
+ * ```typescript
+ * declare module '@tenphi/tasty' {
+ *   interface TastyCustomProps {
+ *     glaze: 'soft' | 'strong' | { tone: string; intensity?: number };
+ *   }
+ * }
+ * ```
+ */
+interface TastyCustomProps {}
+/**
+ * Extensible interface for style names promoted via
+ * `configure({ baseStyleProps })`. Set each name to `true`; the prop is then typed
+ * exactly like the style it names.
+ *
+ * @example
+ * ```typescript
+ * declare module '@tenphi/tasty' {
+ *   interface TastyBaseStylePropNames {
+ *     radius: true;
+ *     shadow: true;
+ *   }
+ * }
+ * ```
+ */
+interface TastyBaseStylePropNames {}
+/**
+ * Props contributed by `configure({ baseStyleProps })`, each typed like the style
+ * it names. Intersecting with `keyof StylesInterface` makes a name that isn't a
+ * real style inert rather than `never`-typed.
+ */
+type ExtraBaseStyleProps = { [key in keyof TastyBaseStylePropNames & keyof StylesInterface]?: StylePropValue<StylesInterface[key]> };
 /** Allowed mod value types */
 type ModValue = boolean | string | number | undefined | null;
 /**
@@ -101,20 +134,14 @@ interface BasePropsWithoutChildren<K extends TagName = TagName> extends Pick<All
   element?: `${Caps}${string}`;
   /** The style map */
   styles?: Styles;
-  /** The list of responsive points in pixels */
-  breakpoints?: number[];
-  /** Whether the element has the block layout outside */
-  block?: boolean;
-  /** Whether the element has the inline layout outside */
-  inline?: boolean;
   /** The list of element modifiers **/
   mods?: Mods;
   /** Whether the element is hidden (`hidden` attribute is set) */
   isHidden?: boolean;
   /** Whether the element is disabled (`disabled` attribute is set) */
   isDisabled?: boolean;
-  /** Plain css for the element */
-  css?: string;
+  /** Whether the element is checked (`checked` attribute is set) */
+  isChecked?: boolean;
   /** The CSS style map */
   style?: CSSProperties$1 | (CSSProperties$1 & Record<string, string | number | null | undefined>);
   /** User-defined theme for the element. Mapped to `data-theme` attribute. Augment `TastyThemeNames` to register project-specific themes for autocomplete. */
@@ -142,7 +169,6 @@ interface ShortGridStyles {
   rows?: Styles['gridRows'];
   areas?: Styles['gridAreas'];
 }
-type Props = Record<string, any>;
 type TagName = keyof HTMLElementTagNameMap;
 /**
  * Configuration type for tasty.config.ts files.
@@ -187,7 +213,7 @@ interface TastyExtensionConfig {
    * Set to `false` to disable function validation (overrides parent).
    * @example ['clamp', 'double']
    */
-  funcs?: false | string[];
+  functions?: false | string[];
   /**
    * State alias names for autocomplete.
    * Must start with @ prefix.
@@ -244,9 +270,10 @@ type TokenPropsMap = Readonly<Record<string, TokenPropKey>>;
 type TokenPropsInput = TokenPropsList | TokenPropsMap;
 /** Resolve a `tokenProps` definition to the component prop types it adds. */
 type ResolveTokenProps<TP extends TokenPropsInput> = TP extends readonly (infer K)[] ? Partial<Record<K & string, TokenValue>> : TP extends Record<string, TokenPropKey> ? Partial<Record<keyof TP & string, TokenValue>> : {};
+type AnyProps = Record<string, any>;
 type PropsWithStyles = {
   styles?: Styles;
-} & Omit<Props, 'styles'>;
+} & Omit<Record<string, any>, 'styles'>;
 type VariantMap = Record<string, Styles>;
 interface WithVariant<V extends VariantMap> {
   variant?: keyof V;
@@ -303,7 +330,7 @@ type TastyBaseProps<K extends StyleList, V extends VariantMap, E extends Element
   tokens?: Tokens; /** Sub-element definitions for compound components */
   elements?: E;
 } & Pick<BaseProps, 'qa' | 'qaVal'> & WithVariant<V>;
-type TastyProps<K extends StyleList, V extends VariantMap, E extends ElementsDefinition = Record<string, never>, DefaultProps = Props, M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = TastyBaseProps<K, V, E, M, TP> & {
+type TastyProps<K extends StyleList, V extends VariantMap, E extends ElementsDefinition = Record<string, never>, DefaultProps = AnyProps, M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = TastyBaseProps<K, V, E, M, TP> & {
   /** The tag name of the element or a React component. */as?: string | ComponentType<any>;
 } & Partial<Omit<DefaultProps, 'as' | 'styles' | 'styleProps' | 'modProps' | 'tokenProps' | 'tokens'>>;
 /**
@@ -319,18 +346,18 @@ type ResolveAsProps<AsType extends ElementType> = AsType extends keyof JSX.Intri
  * element type from the `as` prop — both for intrinsic tags and for React
  * components (so the wrapped component's prop API is preserved).
  *
- * Note: Uses a separate index signature with `unknown` instead of inheriting
- * from Props (which has `any`) to ensure strict type checking for styles.
+ * Note: Uses a separate index signature with `unknown` instead of an `any`
+ * record to ensure strict type checking for styles.
  */
 type TastyElementOptions<K extends StyleList, V extends VariantMap, E extends ElementsDefinition = Record<string, never>, AsType extends ElementType = 'div', M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = TastyBaseProps<K, V, E, M, TP> & {
   /** The tag name of the element or a React component. */as?: AsType;
 } & Record<string, unknown>;
-type AllBasePropsWithMods<K extends StyleList, M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = AllBaseProps & { [key in K[number]]?: StyleValue<StylesInterface[key]> | StyleValueStateMap<StylesInterface[key]> } & BaseStyleProps & ResolveModProps<M> & ResolveTokenProps<TP>;
+type AllBasePropsWithMods<K extends StyleList, M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = AllBaseProps & { [key in K[number]]?: StyleValue<StylesInterface[key]> | StyleValueStateMap<StylesInterface[key]> } & BaseStyleProps & ExtraBaseStyleProps & Partial<TastyCustomProps> & ResolveModProps<M> & ResolveTokenProps<TP>;
 /**
  * Keys from BasePropsWithoutChildren that should be omitted from HTML attributes.
  * This excludes event handlers so they can be properly typed from JSX.IntrinsicElements.
  */
-type TastySpecificKeys = 'as' | 'qa' | 'qaVal' | 'element' | 'styles' | 'breakpoints' | 'block' | 'inline' | 'mods' | 'isHidden' | 'isDisabled' | 'css' | 'style' | 'theme' | 'tokens' | 'ref' | 'color';
+type TastySpecificKeys = 'as' | 'qa' | 'qaVal' | 'element' | 'styles' | 'mods' | 'isHidden' | 'isDisabled' | 'isChecked' | 'style' | 'theme' | 'tokens' | 'ref' | 'color';
 /** Extract prop key names from a ModPropsInput (array elements or object keys). */
 type ModPropsKeys<M extends ModPropsInput> = M extends readonly (infer K)[] ? K & string : keyof M & string;
 /** Extract prop key names from a TokenPropsInput (array elements or object keys). */
@@ -351,7 +378,7 @@ type TokenPropsKeys<TP extends TokenPropsInput> = TP extends readonly (infer K)[
  * baseline is preserved so generic HTML attributes still work even when `as`
  * is a component type with a narrower prop API.
  */
-type TastyElementProps<K extends StyleList, V extends VariantMap, AsType extends ElementType = 'div', M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = Omit<AllBasePropsWithMods<K, M, TP>, Exclude<keyof ResolveAsProps<AsType>, TastySpecificKeys | K[number] | ModPropsKeys<M> | TokenPropsKeys<TP>>> & WithVariant<V> & Omit<Omit<AllHTMLAttributes<HTMLElement>, keyof ResolveAsProps<AsType>> & ResolveAsProps<AsType>, TastySpecificKeys | K[number] | ModPropsKeys<M> | TokenPropsKeys<TP>>;
+type TastyElementProps<K extends StyleList, V extends VariantMap, AsType extends ElementType = 'div', M extends ModPropsInput = readonly never[], TP extends TokenPropsInput = readonly never[]> = Omit<AllBasePropsWithMods<K, M, TP>, Exclude<keyof ResolveAsProps<AsType>, TastySpecificKeys | keyof TastyCustomProps | keyof ExtraBaseStyleProps | K[number] | ModPropsKeys<M> | TokenPropsKeys<TP>>> & WithVariant<V> & Omit<Omit<AllHTMLAttributes<HTMLElement>, keyof ResolveAsProps<AsType>> & ResolveAsProps<AsType>, TastySpecificKeys | keyof TastyCustomProps | keyof ExtraBaseStyleProps | K[number] | ModPropsKeys<M> | TokenPropsKeys<TP>>;
 type TastyComponentPropsWithDefaults<Props extends PropsWithStyles, DefaultProps extends Partial<Props>> = keyof DefaultProps extends never ? Props : { [key in Extract<keyof Props, keyof DefaultProps>]?: Props[key] } & { [key in keyof Omit<Props, keyof DefaultProps>]: Props[key] };
 /**
  * The component type returned by the `tasty(options)` element-factory overload.
@@ -372,11 +399,6 @@ declare function tasty<Props extends PropsWithStyles, DefaultProps extends Parti
 declare const Element$1: TastyPolymorphicComponent<"div", StyleList, VariantMap, readonly never[], readonly never[]> & SubElementComponents<Record<string, never>>;
 //#endregion
 //#region src/hooks/useStyles.d.ts
-/**
- * Tasty styles object to generate CSS classes for.
- * Can be undefined or empty object for no styles.
- */
-type UseStylesOptions = Styles | undefined;
 interface UseStylesResult {
   /**
    * Generated className(s) to apply to the element.
@@ -405,7 +427,7 @@ interface UseStylesResult {
  * }
  * ```
  */
-declare function useStyles(styles: UseStylesOptions, options?: {
+declare function useStyles(styles: Styles | undefined, options?: {
   root?: Document | ShadowRoot;
 }): UseStylesResult;
 //#endregion
@@ -434,6 +456,10 @@ interface UseGlobalStylesOptions {
  * Use the `id` option for update tracking when styles change over the
  * component lifecycle.
  *
+ * Update tracking is per-slot and per-root: a slot (`id`, or the selector when
+ * no `id` is given) holds exactly one injection per `root`. Changing the styles
+ * replaces it; rendering styles that produce no CSS clears it.
+ *
  * @param selector - CSS selector to apply styles to (e.g., '.my-class', ':root', 'body')
  * @param styles - Tasty styles object
  * @param options - Optional settings including `id` for update tracking
@@ -456,9 +482,8 @@ declare function useGlobalStyles(selector: string, styles?: Styles, options?: Us
 //#region src/hooks/useRawCSS.d.ts
 interface UseRawCSSOptions {
   /**
-   * Shadow root or document to inject into.
-   * Note: `root` is not part of the update-tracking comparison — changing
-   * only the root for the same id/content will not re-inject.
+   * Shadow root or document to inject into. Update tracking is per-root: the
+   * same id in two roots holds a separate injection in each.
    */
   root?: Document | ShadowRoot;
   /**
@@ -484,6 +509,11 @@ interface UseKeyframesOptions {
  *
  * Works in all environments: client, SSR with collector, and React Server Components.
  *
+ * Passing `name` claims a slot owned by that one call site (like `useRawCSS`'s
+ * `id`): when its steps change, the previous injection is disposed and the name
+ * is reused, so the rules don't accumulate. Anonymous keyframes are permanent
+ * and shared by content.
+ *
  * @example Basic usage - steps object is the dependency
  * ```tsx
  * function MyComponent() {
@@ -528,28 +558,11 @@ declare function useKeyframes(steps: KeyframesSteps, options?: UseKeyframesOptio
 declare function useKeyframes(factory: () => KeyframesSteps, deps: readonly unknown[], options?: UseKeyframesOptions): string;
 //#endregion
 //#region src/hooks/useProperty.d.ts
-interface UsePropertyOptions {
-  /**
-   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>').
-   * For color tokens (#name), this is auto-set to '<color>' and cannot be overridden.
-   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax
-   */
-  syntax?: string;
-  /**
-   * Whether the property inherits from parent elements
-   * @default true
-   */
-  inherits?: boolean;
-  /**
-   * Initial value for the property.
-   * For color tokens (#name), this defaults to 'transparent' if not specified.
-   */
-  initialValue?: string | number;
-  /**
-   * Shadow root or document to inject into
-   */
-  root?: Document | ShadowRoot;
-}
+/**
+ * Options for {@link useProperty}. Extends the shared {@link PropertyOptions}
+ * (which is `PropertyDefinition` plus an optional injection `root`).
+ */
+type UsePropertyOptions = PropertyOptions;
 /**
  * Register a CSS @property custom property.
  * This enables advanced features like animating custom properties.
@@ -679,6 +692,42 @@ interface UseCounterStyleOptions {
  */
 declare function useCounterStyle(descriptors: CounterStyleDescriptors, options?: UseCounterStyleOptions): string;
 //#endregion
+//#region src/hooks/useFunction.d.ts
+interface UseFunctionOptions {
+  /** Shadow root or document to inject into. */
+  root?: Document | ShadowRoot;
+}
+/**
+ * Register a CSS @function (custom function).
+ *
+ * @function rules are global and persistent once defined. The hook ensures the
+ * function is only registered once per root (deduplicated by function name).
+ *
+ * Accepts tasty token syntax for the function name:
+ * - `$$name` → defines `--name` (matches the call site `$$name(...)`)
+ * - `$name` / `--name` → also accepted
+ *
+ * Works in all environments: client, SSR with collector, and React Server Components.
+ *
+ * @param name - The function name token (`$$name`, `$name`, or `--name`)
+ * @param definition - Function definition (args, returns, result, local vars)
+ *
+ * Call the function through the Tasty DSL, not a raw `style` prop: an inline
+ * `style` value reaches the browser unparsed, so the `$$name(...)` sugar is never
+ * expanded and `polyfills.functions` cannot rewrite it either.
+ *
+ * @example
+ * ```tsx
+ * const Box = tasty({ styles: { marginTop: '$$negative(10px)' } });
+ *
+ * function Layout() {
+ *   useFunction('$$negative', { args: ['$value'], result: '(-1 * $value)' });
+ *   return <Box />;
+ * }
+ * ```
+ */
+declare function useFunction(name: string, definition: FunctionDefinition, options?: UseFunctionOptions): void;
+//#endregion
 //#region src/utils/get-display-name.d.ts
 declare function getDisplayName<T>(Component: ElementType<T>, fallbackName?: string): string;
 //#endregion
@@ -692,7 +741,7 @@ declare module './utils/css-types' {
  * The okhsl function handler for tasty parser.
  * Receives parsed style groups and returns an RGB color string.
  */
-declare const okhslFunc: (groups: StyleDetails[]) => string;
+declare const okhslFunction: (groups: StyleDetails[]) => string;
 /**
  * OKHSL Plugin for Tasty.
  *
@@ -722,7 +771,7 @@ declare const okhslPlugin: TastyPluginFactory;
  * The okhst function handler for tasty parser.
  * Receives parsed style groups and returns an RGB color string.
  */
-declare const okhstFunc: (groups: StyleDetails[]) => string;
+declare const okhstFunction: (groups: StyleDetails[]) => string;
 /**
  * OKHST Plugin for Tasty.
  *
@@ -747,47 +796,69 @@ declare const okhstFunc: (groups: StyleDetails[]) => string;
  */
 declare const okhstPlugin: TastyPluginFactory;
 //#endregion
-//#region src/chunks/definitions.d.ts
+//#region src/plugins/color-func.d.ts
 /**
- * Style chunk definitions for CSS chunking optimization.
- *
- * Styles are grouped into chunks based on:
- * 1. Handler dependencies - styles that share a handler MUST be in the same chunk
- * 2. Logical grouping - related styles grouped for better cache reuse
+ * Creates a color function handler for the tasty parser.
  *
- * See STYLE_CHUNKING_SPEC.md for detailed rationale.
+ * A color function is a custom `functions` entry that converts its arguments
+ * to an `rgb(...)` string (an already-supported color), so it needs no special
+ * core integration — registering it as a parse function is enough.
  *
- * ============================================================================
- * ⚠️  CRITICAL ARCHITECTURAL CONSTRAINT: NO CROSS-CHUNK HANDLER DEPENDENCIES
- * ============================================================================
+ * @param name The name of the color function (e.g., 'okhsl', 'okhst')
+ * @param convert Converts the parsed first three channel values (after angle/
+ *   percent normalization) to sRGB `[r, g, b]` in the 0-1 range
+ * @param label Optional diagnostic label shown in dev warnings when the wrong
+ *   number of arguments is supplied (e.g., 'H S L'). Has no effect on parsing
+ *   or output.
+ */
+declare function createColorFunc(name: string, convert: (h: number, c2: number, c3: number) => [number, number, number], label?: string): (groups: StyleDetails[]) => string;
+//#endregion
+//#region src/utils/function-color.d.ts
+/**
+ * Resolve a `name(...)` value produced by a registered custom parse function
+ * into its concrete color output.
  *
- * Style handlers declare their dependencies via `__lookupStyles` array.
- * This creates a dependency graph where handlers read multiple style props.
+ * A color function is just a `functions` entry whose output is an already
+ * supported color (`rgb`, `hsl`, `#…`, `oklch`, …). This helper delegates the
+ * value to the global parser (which already runs the registered parse function)
+ * and returns the result only when it looks like a color. Returns `null` when
+ * `str` is not a registered custom function or its output is not a color.
  *
- * **ALL styles in a handler's `__lookupStyles` MUST be in the SAME chunk.**
+ * This is the generic replacement for the previously hardcoded okhsl/okhst
+ * conversion branches scattered across `strToRgb`, `resolveToRgbaValues`, and
+ * the `#token.alpha` injection path.
+ */
+declare function resolveFunctionColor(str: string): string | null;
+//#endregion
+//#region src/chunks/style-chunk-map.d.ts
+/**
+ * Chunk names, the built-in chunk style lists, and the style→chunk lookup.
  *
- * Why this matters:
- * 1. Each chunk computes a cache key from ONLY its own style values
- * 2. If a handler reads a style from another chunk, that value isn't in the cache key
- * 3. Changing the cross-chunk style won't invalidate this chunk's cache
- * 4. Result: stale CSS output or incorrect cache hits
+ * This is a **leaf module with no imports**. It exists separately from
+ * `definitions.ts` for two reasons:
  *
- * Example of a violation:
- * ```
- * // flowStyle.__lookupStyles = ['display', 'flow']
- * // If 'display' is in DISPLAY chunk and 'flow' is in LAYOUT chunk:
- * // - User sets { display: 'grid', flow: 'column' }
- * // - LAYOUT chunk caches CSS with flow=column, display=grid
- * // - User changes to { display: 'flex', flow: 'column' }
- * // - LAYOUT chunk cache key unchanged (only has 'flow')
- * // - Returns stale CSS computed with display=grid!
- * ```
+ * 1. The style handler registry (`styles/predefined.ts`) needs to assign chunk
+ *    membership for custom handlers. Reaching for `definitions.ts` would create an
+ *    import cycle (`definitions` -> `pipeline` -> `styles` -> `predefined`).
+ * 2. `STYLE_TO_CHUNK` is populated as a side effect of module load, so it must be
+ *    populated by the module that *owns* it. Otherwise an importer that only pulls
+ *    in this module would see an empty map and misclassify every style as `misc`.
  *
- * Before adding/moving styles, verify:
- * 1. Find all handlers that use this style (grep for the style name in __lookupStyles)
- * 2. Ensure ALL styles from each handler's __lookupStyles are in the same chunk
- * ============================================================================
+ * `definitions.ts` re-exports everything here, so existing import paths and the
+ * public API surface are unchanged.
  */
+declare const CHUNK_NAMES: {
+  /** Special chunk for styles that cannot be split */readonly COMBINED: "combined";
+  readonly SUBCOMPONENTS: "subcomponents";
+  readonly APPEARANCE: "appearance";
+  readonly FONT: "font";
+  readonly DIMENSION: "dimension";
+  readonly DISPLAY: "display";
+  readonly LAYOUT: "layout";
+  readonly POSITION: "position";
+  readonly MISC: "misc";
+};
+type ChunkName = (typeof CHUNK_NAMES)[keyof typeof CHUNK_NAMES];
 /**
  * Appearance chunk - visual styling with independent handlers
  *
@@ -841,24 +912,15 @@ declare const LAYOUT_CHUNK_STYLES: readonly ["placeItems", "placeContent", "alig
  */
 /** @public */
 declare const POSITION_CHUNK_STYLES: readonly ["position", "inset", "insetBlock", "insetInline", "top", "right", "bottom", "left", "zIndex", "gridArea", "gridColumn", "gridRow", "order", "placeSelf", "alignSelf", "justifySelf", "transform", "transition", "animation"];
-declare const CHUNK_NAMES: {
-  /** Special chunk for styles that cannot be split */readonly COMBINED: "combined";
-  readonly SUBCOMPONENTS: "subcomponents";
-  readonly APPEARANCE: "appearance";
-  readonly FONT: "font";
-  readonly DIMENSION: "dimension";
-  readonly DISPLAY: "display";
-  readonly LAYOUT: "layout";
-  readonly POSITION: "position";
-  readonly MISC: "misc";
-};
-type ChunkName = (typeof CHUNK_NAMES)[keyof typeof CHUNK_NAMES];
 /**
- * Pre-computed map for O(1) style-to-chunk lookup.
- * Built once at module load time.
+ * Map for O(1) style-to-chunk lookup. Seeded with the built-in lists above and
+ * extended by {@link assignStyleChunk} when a custom handler declares style names
+ * the built-in lists don't know.
  */
 declare const STYLE_TO_CHUNK: Map<string, ChunkName>;
-interface ChunkInfo$1 {
+//#endregion
+//#region src/chunks/definitions.d.ts
+interface ChunkInfo {
   /** Name of the chunk */
   name: ChunkName | string;
   /** Style keys belonging to this chunk */
@@ -1223,7 +1285,7 @@ declare function presetStyle({
   fontStyle,
   fontFamily,
   font
-}: PresetStyleProps): Styles | null;
+}: PresetStyleProps): CSSMap | null;
 declare namespace presetStyle {
   var __lookupStyles: string[];
 }
@@ -1370,6 +1432,36 @@ declare const styleHandlers: {
   readonly width: typeof widthStyle;
 };
 //#endregion
+//#region src/styles/define-handler.d.ts
+/**
+ * Declare a multi-dependency style handler with its dependency names inferred
+ * into the handler's parameter type.
+ *
+ * Without it, the multi-dependency tuple form needs a hand-written parameter
+ * annotation that can silently drift from the dependency list:
+ *
+ * ```ts
+ * // Annotation and dependency list are maintained separately.
+ * handlers: {
+ *   spacing: [['gap', 'padding'], ({ gap, padding }: { gap?: string; padding?: string }) => …],
+ * }
+ *
+ * // Both come from the same array; a typo in the destructure is a type error.
+ * handlers: {
+ *   spacing: defineHandler(['gap', 'padding'], ({ gap, padding }) => …),
+ * }
+ * ```
+ *
+ * Values arrive **state-resolved but unparsed** — the raw authored DSL string
+ * (`'2x'`, `'#purple.5'`), so call `parseStyle()` / `parseColor()` as needed. The
+ * result is a kebab-case CSS declaration map (or an array of them); the reserved
+ * `$` key applies the declarations to a nested selector.
+ *
+ * All names must belong to the same chunk. Names the built-in chunk lists don't
+ * know are pulled into their handler's chunk automatically at registration.
+ */
+declare function defineHandler<const TDeps extends readonly string[]>(deps: TDeps, handler: (props: Partial<Record<TDeps[number], ResolvedStyleValue>>) => StyleHandlerResult): [readonly string[], RawStyleHandler];
+//#endregion
 //#region src/compute-styles.d.ts
 interface ComputeStylesResult {
   className: string;
@@ -1482,26 +1574,6 @@ declare function keyframes(steps: KeyframesSteps, nameOrOptions?: string | {
   root?: Document | ShadowRoot;
   name?: string;
 }): KeyframesResult;
-interface PropertyOptions {
-  /**
-   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>')
-   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax
-   */
-  syntax?: string;
-  /**
-   * Whether the property inherits from parent elements
-   * @default true
-   */
-  inherits?: boolean;
-  /**
-   * Initial value for the property
-   */
-  initialValue?: string | number;
-  /**
-   * Shadow root or document to inject into
-   */
-  root?: Document | ShadowRoot;
-}
 /**
  * Define a CSS @property custom property.
  * This enables advanced features like animating custom properties.
@@ -1528,7 +1600,7 @@ interface PropertyOptions {
  * });
  * ```
  */
-declare function property$1(name: string, options?: PropertyOptions): void;
+declare function property(name: string, options?: PropertyOptions): void;
 /**
  * Check if a CSS @property has already been defined
  *
@@ -1550,23 +1622,44 @@ declare function fontFace(family: string, descriptors: FontFaceDescriptors, opti
 /**
  * Inject a CSS @counter-style rule.
  *
- * Permanent and global — no dispose or ref-counting.
- * Deduplicates by name (first definition wins).
+ * Permanent and global — no dispose or ref-counting. Deduplicates by name and
+ * overrides an existing rule by default. Pass `weak: true` for global
+ * `configure()` definitions, which never clobber an existing rule.
  */
 declare function counterStyle(name: string, descriptors: CounterStyleDescriptors, options?: {
   root?: Document | ShadowRoot;
+  weak?: boolean;
+}): void;
+/**
+ * Inject a CSS @function rule (custom function).
+ *
+ * Permanent and global — no dispose or ref-counting. Deduplicates by function
+ * name and overrides an existing rule by default. Pass `weak: true` for global
+ * `configure()` definitions, which never clobber an existing rule.
+ *
+ * @param name - The function name (`$$name`, `$name`, or `--name`)
+ * @param definition - Function definition (args, returns, result, local vars)
+ *
+ * @example
+ * ```ts
+ * func('$$negative', { args: ['$value'], result: '(-1 * $value)' });
+ * ```
+ */
+declare function func(name: string, definition: FunctionDefinition, options?: {
+  root?: Document | ShadowRoot;
+  weak?: boolean;
 }): void;
 /**
  * Get CSS text from all sheets (for SSR)
  */
-declare function getCssText(options?: {
+declare function getCSSText(options?: {
   root?: Document | ShadowRoot;
 }): string;
 /**
  * Collect only CSS used by a rendered subtree (like jest-styled-components).
  * Pass the container returned by render(...).
  */
-declare function getCssTextForNode(node: ParentNode | Element | DocumentFragment, options?: {
+declare function getCSSTextForNode(node: ParentNode | Element | DocumentFragment, options?: {
   root?: Document | ShadowRoot;
 }): string;
 /**
@@ -1589,10 +1682,6 @@ declare function touch(className: string, options?: {
  * @returns Number of styles evicted.
  */
 declare function gc(options?: GCOptions): number;
-/**
- * Check if we're currently running in a test environment
- */
-declare function getIsTestEnvironment(): boolean;
 /**
  * Get the global injector instance for debugging
  */
@@ -1664,20 +1753,6 @@ declare const dotize: {
  */
 declare function resolveRecipes(styles: Styles): Styles;
 //#endregion
-//#region src/utils/warnings.d.ts
-declare function warn(...args: unknown[]): void;
-declare function deprecationWarning(condition: unknown, {
-  property,
-  name,
-  betterAlternative,
-  reason
-}: {
-  property: string;
-  name: string;
-  betterAlternative: (() => string) | string;
-  reason?: (() => string) | string;
-}): void;
-//#endregion
 //#region src/utils/process-tokens.d.ts
 /**
  * Process tokens object into inline style properties.
@@ -1701,19 +1776,19 @@ interface DebugOptions {
   /** Suppress console logging and return data only (default: false) */
   raw?: boolean;
 }
-interface CssOptions extends DebugOptions {
+interface CSSOptions extends DebugOptions {
   prettify?: boolean;
   /** Read from stored source CSS (dev-mode only) instead of live CSSOM */
   source?: boolean;
 }
-interface ChunkInfo {
+interface DebugChunkInfo {
   className: string;
   chunkName: string | null;
 }
 interface InspectResult {
   element?: Element | null;
   classes: string[];
-  chunks: ChunkInfo[];
+  chunks: DebugChunkInfo[];
   css: string;
   size: number;
   rules: number;
@@ -1762,7 +1837,7 @@ interface Summary {
   chunkBreakdown: ChunkBreakdown;
 }
 declare const tastyDebug: {
-  css(target: CSSTarget, opts?: CssOptions): string;
+  css(target: CSSTarget, opts?: CSSOptions): string;
   inspect(target: string | Element, opts?: DebugOptions): InspectResult;
   summary(opts?: DebugOptions): Summary;
   chunks(opts?: DebugOptions): ChunkBreakdown;
@@ -1774,5 +1849,5 @@ declare const tastyDebug: {
   install(): void;
 };
 //#endregion
-export { UsePropertyOptions as $, BLOCK_OUTER_STYLES as $t, chunkSheetRegistry as A, BlockInnerStyleProps as At, DISPLAY_CHUNK_STYLES as B, Mods as Bt, injectRawCSS as C, VariantMap as Ct, property$1 as D, BaseProps as Dt, keyframes as E, AllBaseProps as Et, APPEARANCE_CHUNK_STYLES as F, DimensionStyleProps as Ft, categorizeStyleKeys as G, TagName as Gt, LAYOUT_CHUNK_STYLES as H, PositionStyleProps as Ht, CHUNK_NAMES as I, FlowStyleProps as It, okhslFunc as J, TextStyleProps as Jt, okhstFunc as K, TastyExtensionConfig as Kt, ChunkInfo$1 as L, GlobalStyledProps as Lt, ComputeStylesResult as M, BlockStyleProps as Mt, computeStyles as N, ColorStyleProps as Nt, touch as O, BasePropsWithoutChildren as Ot, styleHandlers as P, ContainerStyleProps as Pt, useFontFace as Q, BLOCK_INNER_STYLES as Qt, ChunkName as R, InnerStyleProps as Rt, injectGlobal as S, TokenPropsInput as St, isPropertyDefined as T, tasty as Tt, POSITION_CHUNK_STYLES as U, Props as Ut, FONT_CHUNK_STYLES as V, OuterStyleProps as Vt, STYLE_TO_CHUNK as W, ShortGridStyles as Wt, getDisplayName as X, Tokens as Xt, okhslPlugin as Y, TokenValue as Yt, useCounterStyle as Z, BASE_STYLES as Zt, getCssText as _, SubElementProps as _t, resolveRecipes as a, INNER_STYLES as an, UseStylesResult as at, getRawCSSText as b, TastyPolymorphicComponent as bt, color$1 as c, TEXT_STYLES as cn, Element$1 as ct, cleanup as d, ModPropsInput as dt, BLOCK_STYLES as en, useProperty as et, counterStyle as f, ResolveAsProps as ft, gc as g, SubElementDefinition as gt, fontFace as h, ResolveTokenProps as ht, warn as i, FLOW_STYLES as in, UseStylesOptions as it, ComputeStylesOptions as j, BlockOuterStyleProps as jt, ChunkSheetRegistry as k, BaseStyleProps as kt, filterBaseProps as l, DEFAULT_NAME_PREFIX as ln, ElementsDefinition as lt, destroy as m, ResolveModProps as mt, processTokens as n, CONTAINER_STYLES as nn, useRawCSS as nt, dotize as o, OUTER_STYLES as on, useStyles as ot, createInjector as p, ResolveModPropDef as pt, okhstPlugin as q, TastyThemeNames as qt, deprecationWarning as r, DIMENSION_STYLES as rn, useGlobalStyles as rt, _modAttrs as s, POSITION_STYLES as sn, AllBasePropsWithMods as st, tastyDebug as t, COLOR_STYLES as tn, useKeyframes as tt, PropertyOptions as u, DEFAULT_ZERO_NAME_PREFIX as un, ModPropDef as ut, getCssTextForNode as v, TastyElementOptions as vt, injector as w, WithVariant as wt, inject as x, TastyProps as xt, getIsTestEnvironment as y, TastyElementProps as yt, DIMENSION_CHUNK_STYLES as z, ModValue as zt };
-//# sourceMappingURL=index-BYtnj_gA.d.ts.map
+export { okhstFunction as $, TagName as $t, keyframes as A, TastyProps as At, ChunkInfo as B, BlockOuterStyleProps as Bt, getCSSTextForNode as C, ResolveTokenProps as Ct, injectRawCSS as D, TastyElementOptions as Dt, injectGlobal as E, TastyComponentPropsWithDefaults as Et, ComputeStylesOptions as F, AllBaseProps as Ft, DIMENSION_CHUNK_STYLES as G, ExtraBaseStyleProps as Gt, APPEARANCE_CHUNK_STYLES as H, ColorStyleProps as Ht, ComputeStylesResult as I, BaseProps as It, LAYOUT_CHUNK_STYLES as J, ModValue as Jt, DISPLAY_CHUNK_STYLES as K, FlowStyleProps as Kt, computeStyles as L, BasePropsWithoutChildren as Lt, touch as M, VariantMap as Mt, ChunkSheetRegistry as N, WithVariant as Nt, injector as O, TastyElementProps as Ot, chunkSheetRegistry as P, tasty as Pt, createColorFunc as Q, ShortGridStyles as Qt, defineHandler as R, BaseStyleProps as Rt, getCSSText as S, ResolveModProps as St, inject as T, SubElementProps as Tt, CHUNK_NAMES as U, ContainerStyleProps as Ut, categorizeStyleKeys as V, BlockStyleProps as Vt, ChunkName as W, DimensionStyleProps as Wt, STYLE_TO_CHUNK as X, OuterStyleProps as Xt, POSITION_CHUNK_STYLES as Y, Mods as Yt, resolveFunctionColor as Z, PositionStyleProps as Zt, createInjector as _, POSITION_STYLES as _n, ElementsDefinition as _t, DebugOptions as a, TokenValue as an, useFunction as at, func as b, DEFAULT_ZERO_NAME_PREFIX as bn, ResolveAsProps as bt, tastyDebug as c, BLOCK_INNER_STYLES as cn, UsePropertyOptions as ct, dotize as d, COLOR_STYLES as dn, useRawCSS as dt, TastyBaseStylePropNames as en, okhstPlugin as et, _modAttrs as f, CONTAINER_STYLES as fn, useGlobalStyles as ft, counterStyle as g, OUTER_STYLES as gn, Element$1 as gt, cleanup as h, INNER_STYLES as hn, AllBasePropsWithMods as ht, DebugChunkInfo as i, TextStyleProps as in, UseFunctionOptions as it, property as j, TokenPropsInput as jt, isPropertyDefined as k, TastyPolymorphicComponent as kt, processTokens as l, BLOCK_OUTER_STYLES as ln, useProperty as lt, filterBaseProps as m, FLOW_STYLES as mn, useStyles as mt, CacheStatus as n, TastyExtensionConfig as nn, okhslPlugin as nt, InspectResult as o, Tokens as on, useCounterStyle as ot, color$1 as p, DIMENSION_STYLES as pn, UseStylesResult as pt, FONT_CHUNK_STYLES as q, InnerStyleProps as qt, ChunkBreakdown as r, TastyThemeNames as rn, getDisplayName as rt, Summary as s, BASE_STYLES as sn, useFontFace as st, CSSOptions as t, TastyCustomProps as tn, okhslFunction as tt, resolveRecipes as u, BLOCK_STYLES as un, useKeyframes as ut, destroy as v, TEXT_STYLES as vn, ModPropDef as vt, getRawCSSText as w, SubElementDefinition as wt, gc as x, ResolveModPropDef as xt, fontFace as y, DEFAULT_NAME_PREFIX as yn, ModPropsInput as yt, styleHandlers as z, BlockInnerStyleProps as zt };
+//# sourceMappingURL=index-BAAbdfRs.d.ts.map