@tenphi/tasty 0.0.0-snapshot.db103fd → 0.0.0-snapshot.dc62ea3

package/dist/config-LfIDmVHx.d.ts

@@ -0,0 +1,1363 @@
+import { At as StyleRule, Ct as PropertyDefinition, Dt as RuleInfo, Et as RootRegistry, Ot as SheetInfo, P as StyleHandlerDefinition, St as KeyframesSteps, Tt as RawCSSResult, _t as InjectResult, b as Styles, bt as KeyframesInfo, dt as FunctionDefinition, gt as InjectOptions, h as ConfigTokens, ht as GlobalInjectResult, it as UnitHandler, kt as StyleInjectorConfig, lt as FontFaceDescriptors, mt as GCOptions, n as StyleResult, nt as StyleDetails, ot as CacheMetrics, pt as GCConfig, st as CounterStyleDescriptors, ut as FontFaceInput, v as RecipeStyles, xt as KeyframesResult } from "./index-BmogEzTo.js";
+
+//#region src/prop-handlers.d.ts
+/**
+ * Props middleware for tasty components.
+ *
+ * A prop handler receives a component's props and returns them, changed or not.
+ * That makes it the extension point for props that are *not* style properties:
+ * it can read a custom prop, strip it so it never reaches the DOM, and fold its
+ * meaning into `styles`, `mods`, `tokens`, `variant`, or `as`.
+ *
+ * ```ts
+ * configure({
+ *   propHandlers: {
+ *     glaze: (props) => {
+ *       const { glaze, ...rest } = props;
+ *       if (!glaze) return rest;
+ *       return { ...rest, styles: mergeStyles(glazeStyles(glaze), rest.styles) };
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * Handlers run on every render of every tasty component, so the registry is a
+ * pre-composed chain that is `null` while nothing is registered — the cost when
+ * unused is one property load and one branch.
+ */
+/** Props object handed to a prop handler. Deliberately untyped: handlers see everything. */
+type PropHandlerProps = Record<string, unknown>;
+/**
+ * Props middleware: props in, props out. Returning nothing means "unchanged".
+ *
+ * Must be a **pure function** and must not mutate its input. Style values are
+ * cached by object identity, so mutating a value object in place produces a stale
+ * class name and stale CSS. Return fresh (ideally frozen, ideally memoized)
+ * objects instead.
+ */
+type PropHandler = (props: PropHandlerProps) => PropHandlerProps | void | null;
+/**
+ * How a prop handler is declared. The map key is both its name and, by default,
+ * the prop that triggers it.
+ *
+ * - `fn` — triggered when a prop matching the key is present
+ * - `['glaze', fn]` — triggered by the named prop
+ * - `[['glaze', 'tone'], fn]` — triggered by any of them
+ * - `['*', fn]` — unconditional; runs on every render of every component
+ */
+type PropHandlerDefinition = PropHandler | [string, PropHandler] | [string[], PropHandler];
+//#endregion
+//#region src/injector/sheet-manager.d.ts
+declare class SheetManager {
+  private rootRegistries;
+  /** Strong set of active roots so background GC can iterate them all */
+  private activeRoots;
+  private config;
+  /** Dedicated style elements for raw CSS per root */
+  private rawStyleElements;
+  /** Constructable sheets for raw CSS in adopted mode */
+  private rawConstructableSheets;
+  /** Tracking for raw CSS blocks per root */
+  private rawCSSBlocks;
+  /** Counter for generating unique raw CSS IDs */
+  private rawCSSCounter;
+  constructor(config: StyleInjectorConfig);
+  /**
+   * Resolve the underlying CSSStyleSheet from a SheetInfo,
+   * abstracting away adopted vs style-element modes.
+   */
+  getCSSSheet(sheetInfo: SheetInfo): CSSStyleSheet | null;
+  /**
+   * Record an inserted rule text at its rule index (text mode only).
+   *
+   * `textRules` mirrors the sheet's rule order. `textContent` cannot be edited
+   * rule-by-rule the way CSSOM can, so keeping the texts is what makes
+   * deletion possible at all in this mode.
+   */
+  private trackTextRule;
+  /**
+   * Remove rule indices from a text-mode sheet and rewrite the element's text.
+   * Returns the indices that were actually removed.
+   */
+  private deleteTextRules;
+  /**
+   * Determine the injection mode for a root.
+   * ShadowRoot uses adopted stylesheets when supported; Document uses <style> elements.
+   */
+  private detectInjectionMode;
+  /**
+   * Get or create registry for a root (Document or ShadowRoot)
+   */
+  getRegistry(root: Document | ShadowRoot): RootRegistry;
+  /** Return all roots with active registries (for background GC sweep). */
+  getActiveRoots(): Iterable<Document | ShadowRoot>;
+  /** Check whether any roots have active registries. */
+  hasActiveRoots(): boolean;
+  /** Remove registries for ShadowRoots whose host has been detached from the DOM. */
+  pruneDisconnectedRoots(): void;
+  /**
+   * Create a new stylesheet for the registry.
+   * In adopted mode (ShadowRoot), creates a constructable CSSStyleSheet and
+   * pushes it to adoptedStyleSheets. Otherwise creates a <style> element.
+   */
+  createSheet(registry: RootRegistry, root: Document | ShadowRoot): SheetInfo;
+  /**
+   * Create a style element and append to document
+   */
+  private createStyleElement;
+  /**
+   * Insert CSS rules as a single block
+   */
+  insertRule(registry: RootRegistry, flattenedRules: StyleRule[], className: string, root: Document | ShadowRoot): RuleInfo | null;
+  /**
+   * Insert global CSS rules
+   */
+  insertGlobalRule(registry: RootRegistry, flattenedRules: StyleRule[], globalKey: string, root: Document | ShadowRoot): RuleInfo | null;
+  /**
+   * Delete a global CSS rule by key
+   */
+  deleteGlobalRule(registry: RootRegistry, globalKey: string): void;
+  /**
+   * Adjust rule indices after deletion to account for shifting
+   */
+  private adjustIndicesAfterDeletion;
+  /**
+   * Delete a CSS rule from the sheet
+   */
+  deleteRule(registry: RootRegistry, ruleInfo: RuleInfo): void;
+  /**
+   * Find a sheet with available space or return null
+   */
+  private findAvailableSheet;
+  /**
+   * Find an available rule index in the sheet
+   */
+  findAvailableRuleIndex(sheet: SheetInfo): number;
+  /**
+   * Probe whether the underlying CSS engine supports `@property` at-rules.
+   * Result is cached per registry on `registry.atPropertySupported`.
+   *
+   * The probe inserts and immediately deletes a minimal known-valid rule
+   * (`@property --__tasty_probe__ { syntax: "*"; inherits: true; }`).
+   * Engines that lack `@property` support (jsdom, happy-dom) reject any
+   * `@property` rule including this one, so a probe failure is a reliable
+   * signal that further `@property` rejections are environmental noise and
+   * not user-authored bugs.
+   *
+   * The probe is intentionally a separate operation from the user's failing
+   * insertion: we don't want to leak `--__tasty_probe__` into the sheet, so
+   * on success we delete the probe rule immediately, leaving `ruleCount`
+   * and `cssRules.length` unchanged.
+   */
+  private engineSupportsAtProperty;
+  /**
+   * Delete the given classes: their rules leave the sheets and every registry
+   * entry pointing at them is dropped.
+   *
+   * Deciding *what* is unused belongs to `StyleInjector.gc()`, which owns the
+   * DOM scan and the capacity policy. This only re-checks that each class is
+   * still safe to delete, and reports how many were.
+   *
+   * @returns Number of classes actually deleted.
+   */
+  deleteClasses(registry: RootRegistry, classNames: Iterable<string>): number;
+  /**
+   * Get total number of rules across all sheets
+   */
+  getTotalRuleCount(registry: RootRegistry): number;
+  /**
+   * The CSS of one managed sheet, or `null` when it holds none this can read —
+   * an empty style element, or a sheet the engine refuses to hand over.
+   */
+  private readSheetCSS;
+  /**
+   * Get CSS text from all sheets (for SSR)
+   */
+  getCSSText(registry: RootRegistry): string;
+  /**
+   * Get cache performance metrics
+   */
+  getMetrics(registry: RootRegistry): CacheMetrics | null;
+  /**
+   * Reset cache performance metrics
+   */
+  resetMetrics(registry: RootRegistry): void;
+  /**
+   * Convert keyframes steps to CSS string.
+   * Public so the SSR collector can format keyframes without DOM access.
+   * Returns both the CSS text and a combined declarations string for property type scanning.
+   */
+  stepsToCSS(steps: KeyframesSteps): {
+    css: string;
+    declarations: string;
+  };
+  /**
+   * Insert keyframes rule.
+   * Returns the KeyframesInfo and the raw declarations string for property type scanning.
+   */
+  insertKeyframes(registry: RootRegistry, steps: KeyframesSteps, name: string, root: Document | ShadowRoot): {
+    info: KeyframesInfo;
+    declarations: string;
+  } | null;
+  /**
+   * Delete keyframes rule
+   */
+  deleteKeyframes(registry: RootRegistry, info: KeyframesInfo): void;
+  /**
+   * Clean up resources for a root
+   */
+  cleanup(root: Document | ShadowRoot): void;
+  /**
+   * Check if a root uses adopted injection mode.
+   */
+  private isAdoptedMode;
+  /**
+   * Get or create a constructable CSSStyleSheet for raw CSS in adopted mode.
+   * The raw sheet is prepended to adoptedStyleSheets so it precedes tasty rules.
+   */
+  private getOrCreateRawAdoptedSheet;
+  /**
+   * Get or create a dedicated style element for raw CSS
+   * Raw CSS is kept separate from tasty-managed sheets to avoid index conflicts
+   */
+  private getOrCreateRawStyleElement;
+  /**
+   * Inject raw CSS text directly without parsing
+   * Returns a dispose function to remove the injected CSS
+   */
+  injectRawCSS(css: string, root: Document | ShadowRoot): RawCSSResult;
+  /**
+   * Rebuild the raw CSS constructable sheet from all tracked blocks.
+   */
+  private rebuildRawAdoptedSheet;
+  /**
+   * Remove a raw CSS block by ID
+   */
+  private disposeRawCSS;
+  /**
+   * Get the raw CSS content
+   */
+  /**
+   * The CSS this injector owns in `root`, one entry per sheet, in the order the
+   * engine applies them.
+   *
+   * `getCSSText()` walks the managed sheets only, and raw CSS has its own —
+   * which sits before, after, or *between* them depending on how it got there:
+   * prepended to `adoptedStyleSheets`, or wherever in `<head>` the first raw
+   * injection happened to land, with every managed sheet opened afterwards
+   * following it. Reporting a fixed order would describe the opposite winner
+   * from the live page whenever two rules of equal specificity meet, so the raw
+   * sheet is spliced in at the position the DOM actually gives it.
+   */
+  getOwnedCSSInOrder(registry: RootRegistry, root: Document | ShadowRoot): string[];
+  /**
+   * Top-level rules in the raw sheet.
+   *
+   * Read from the sheet the engine parsed, not from the text: a raw block is
+   * one string but any number of rules, and one rule — `@keyframes`, `@media` —
+   * can contain any number of blocks, so counting braces answers neither
+   * question.
+   */
+  getRawRuleCount(root: Document | ShadowRoot): number;
+  getRawCSSText(root: Document | ShadowRoot): string;
+}
+//#endregion
+//#region src/injector/injector.d.ts
+declare class StyleInjector {
+  private sheetManager;
+  private config;
+  private globalRuleCounter;
+  /** Cancels the scheduled sweep, whichever timer scheduled it. */
+  private cancelPendingGC;
+  private namePrefix;
+  private classRegex;
+  private rscClassRegex;
+  /** @internal — exposed for debug utilities only */
+  get _sheetManager(): SheetManager;
+  /**
+   * Whether sheet writes should be queued instead of applied immediately.
+   *
+   * Only ever true on the client: SSR collects CSS as text and the RSC path
+   * returns it as strings, so neither has a live sheet to batch writes against.
+   *
+   * In the default `true` mode a write is only queued inside an open batch
+   * window — a commit in which `<TastyBatchProvider>` rendered and will
+   * therefore flush in its insertion effect, before any layout effect can
+   * measure. Everything else falls through to a synchronous write, so enabling
+   * the flag cannot make a `useLayoutEffect` read an unstyled element.
+   * `'always'` drops the gate and accepts that trade for wider coverage.
+   */
+  private get batching();
+  /**
+   * Apply a sheet write now, or queue it when batching is on.
+   * Returns the queue handle when deferred, so the caller can cancel it if it
+   * disposes before the flush.
+   */
+  private writeSheet;
+  /**
+   * Insert a global (non-class) rule, honouring batching.
+   *
+   * `onApplied` records the caller's dedupe bookkeeping. When the write is
+   * queued it runs eagerly, so a repeat call before the flush bails out instead
+   * of queueing the same rule twice — the same reasoning as
+   * `insertPropertyRule`'s eager marking. When written synchronously it runs
+   * only on success, preserving the existing retry-on-failure behaviour.
+   */
+  private writeGlobalRule;
+  constructor(config?: StyleInjectorConfig);
+  /**
+   * Generate a deterministic class name from a cache key using content hash.
+   * The same cache key always produces the same class name across environments
+   * with the same `namePrefix`.
+   */
+  private generateClassName;
+  /**
+   * Check if `className` was hydrated from server-rendered styles and,
+   * if so, wire the cacheKey mapping. Returns true on hit.
+   */
+  private tryHydratedHit;
+  /**
+   * Allocate a className for a cacheKey without injecting styles yet.
+   * This allows separating className allocation (render phase) from style injection (insertion phase).
+   */
+  allocateClassName(cacheKey: string, options?: {
+    root?: Document | ShadowRoot;
+  }): {
+    className: string;
+    isNewAllocation: boolean;
+  };
+  /**
+   * Inject styles from StyleResult objects
+   */
+  inject(rules: StyleResult[], options?: InjectOptions): InjectResult;
+  /**
+   * Inject global styles (rules without a generated tasty class selector)
+   * This ensures we don't reserve a tasty class name (t{number}) for global rules,
+   * which could otherwise collide with element-level styles and break lookups.
+   */
+  injectGlobal(rules: StyleResult[], options?: {
+    root?: Document | ShadowRoot;
+  }): GlobalInjectResult;
+  /**
+   * Inject raw CSS text directly without parsing
+   * This is a low-overhead alternative to createGlobalStyle for raw CSS
+   * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking
+   */
+  injectRawCSS(css: string, options?: {
+    root?: Document | ShadowRoot;
+  }): RawCSSResult;
+  /**
+   * Get raw CSS text for SSR
+   */
+  getRawCSSText(options?: {
+    root?: Document | ShadowRoot;
+  }): string;
+  /**
+   * Take a reference on local `@keyframes`, under the deterministic names the
+   * caller resolved.
+   *
+   * One reference per distinct set of steps, shared by every class that ends up
+   * animating it, so a repeat render takes nothing further. Ownership is
+   * assigned by `ownKeyframes()` once the rules exist to be inspected.
+   */
+  holdKeyframes(steps: Record<string, KeyframesSteps>, names: Map<string, string>, options?: {
+    root?: Document | ShadowRoot;
+  }): Map<string, string>;
+  /**
+   * Record that `className` animates these keyframes, so the reference is
+   * released when the last such class is collected.
+   *
+   * Only classes whose rules actually reference the animation should be here:
+   * a class that merely rendered alongside one would otherwise keep the
+   * keyframes alive for as long as it lives.
+   */
+  ownKeyframes(key: string, className: string, options?: {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Pin an already-injected cacheKey and return the handle that releases it.
+   * For callers that skipped the pipeline on a cache hit but still need the
+   * class held. Returns null if the cacheKey is not found.
+   */
+  trackRef(cacheKey: string, options?: {
+    root?: Document | ShadowRoot;
+  }): InjectResult | null;
+  /**
+   * Release one pin on a className. At zero pins the class is not deleted — it
+   * stays cached and collectible, and `gc()` decides when it actually goes.
+   */
+  private unpin;
+  /**
+   * Remove every style that is neither in the DOM nor referenced by an
+   * outstanding `inject()` handle, ignoring the GC capacity threshold.
+   */
+  cleanup(root?: Document | ShadowRoot): void;
+  /**
+   * Get CSS text from all sheets (for SSR)
+   */
+  getCSSText(options?: {
+    root?: Document | ShadowRoot;
+  }): string;
+  /**
+   * Get CSS only for the provided tasty classNames (e.g., ["t0","t3"])
+   */
+  getCSSTextForClasses(classNames: Iterable<string>, options?: {
+    root?: Document | ShadowRoot;
+  }): string;
+  /**
+   * Get cache performance metrics
+   */
+  getMetrics(options?: {
+    root?: Document | ShadowRoot;
+  }): CacheMetrics | null;
+  /**
+   * Reset cache performance metrics
+   */
+  resetMetrics(options?: {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Define a CSS @property custom property.
+   *
+   * Accepts tasty token syntax for the property name:
+   * - `$name` → defines `--name`
+   * - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')
+   * - `--name` → defines `--name` (legacy format)
+   *
+   * Example:
+   * @property --rotation { syntax: "<angle>"; inherits: false; initial-value: 45deg; }
+   *
+   * Note: No caching or dispose — this defines a global property.
+   *
+   * If the same property is registered with different options, a warning is emitted
+   * but the original definition is preserved (CSS @property cannot be redefined).
+   */
+  property(name: string, options?: PropertyDefinition & {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Build and insert a single `@property` rule into the given registry.
+   * No-op if the property was already injected.
+   */
+  private insertPropertyRule;
+  /**
+   * Check whether a given @property name was already injected by this injector.
+   *
+   * Accepts tasty token syntax:
+   * - `$name` → checks `--name`
+   * - `#name` → checks `--name-color`
+   * - `--name` → checks `--name` (legacy format)
+   */
+  isPropertyDefined(name: string, options?: {
+    root?: Document | ShadowRoot;
+  }): boolean;
+  /**
+   * Inject a CSS @font-face rule.
+   *
+   * Permanent and global — no dispose or ref-counting.
+   * Deduplicates by content hash (family + descriptors).
+   */
+  fontFace(family: string, descriptors: FontFaceDescriptors, options?: {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Inject a CSS @counter-style rule.
+   *
+   * Permanent and global — no dispose or ref-counting. Deduplicates by name.
+   * By default a definition overrides a previously injected one of the same
+   * name. Pass `weak: true` for global `configure()` definitions, which must
+   * never clobber an existing rule (so component-local definitions win
+   * regardless of injection order).
+   */
+  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. By default a definition overrides a previously injected one of the
+   * same name. Pass `weak: true` for global `configure()` definitions, which
+   * must never clobber an existing rule (so component-local definitions win
+   * regardless of injection order).
+   */
+  func(name: string, definition: FunctionDefinition, options?: {
+    root?: Document | ShadowRoot;
+    weak?: boolean;
+  }): void;
+  /**
+   * Inject keyframes and return object with toString() and dispose()
+   *
+   * Keyframes are cached by content (steps). If the same content is injected
+   * multiple times with different provided names, the first injected name is reused.
+   *
+   * If the same name is provided with different content (collision), a unique
+   * name is generated to avoid overwriting the existing keyframes.
+   */
+  keyframes(steps: KeyframesSteps, nameOrOptions?: string | {
+    root?: Document | ShadowRoot;
+    name?: string;
+    /**
+     * Give this name its own rule even if another name already carries
+     * the same steps. Without it two names with identical steps share
+     * one rule under whichever name arrived first — fine when the caller
+     * only wants the animation, wrong when the name has to be the one it
+     * asked for.
+     */
+    distinctByName?: boolean;
+  }): KeyframesResult;
+  /**
+   * Dispose keyframes
+   */
+  private disposeKeyframes;
+  /**
+   * Count a render, and schedule a collection pass every `touchInterval` of
+   * them. Nothing else: what a class is worth keeping is decided by the sweep's
+   * own DOM scan, so rendering does not track usage at all.
+   *
+   * @deprecated The class name is ignored — pass anything, or stop calling it.
+   * Collection no longer records per-class usage, and scheduling does not need
+   * to know which class was rendered. A class handed back by `inject()` is
+   * marked wanted there, which is what reuse actually goes through.
+   */
+  touch(_className: string, options?: {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Schedule a GC in idle time. Runs GC on all active roots, and avoids
+   * double-scheduling.
+   *
+   * Idle only. Without `requestIdleCallback` nothing is collected
+   * automatically: running the sweep inline here would put it inside the render
+   * that touched the class, and collection is never urgent enough for that.
+   */
+  private scheduleGC;
+  /**
+   * The one definition of "unused": this injector owns the class's rules, no
+   * element in `root` carries it, and nobody pinned it.
+   *
+   * `gc()` evicts from this set, `getMetrics()` counts it, and `tastyDebug`
+   * reports it — all through here, so the three can never disagree about what
+   * "unused" means. Entries carry their last `touch()` so callers can drop the
+   * oldest first; a class that was never touched sorts as oldest.
+   */
+  /**
+   * Everything the injector holds falls into one of five bands, and only the
+   * last of them is ever deleted:
+   *
+   * 1. rendered — some element carries the class right now
+   * 2. not ours — queued for a batched write, pre-allocated, or server-rendered
+   * 3. hot — nothing carries it, but that was noticed less than `grace` ago
+   * 4. cached — cold, but within `capacity` when ordered by when it went cold
+   * 5. the rest
+   *
+   * This returns bands 4 and 5 together, most recently cold first; `gc()` draws
+   * the capacity line through them. Band 3 is what makes collection safe
+   * without a commit signal: a render can resolve a class and commit it a
+   * little later, and during that gap nothing on the page carries it.
+   */
+  private collectUnused;
+  /**
+   * Class names this injector holds CSS for that nothing renders and nobody
+   * pinned — exactly what `gc({ force: true })` would delete. Unordered.
+   */
+  getUnusedClasses(options?: {
+    root?: Document | ShadowRoot;
+  }): string[];
+  /**
+   * Synchronous garbage collection.
+   *
+   * 1. Quick upper-bound check: skip if the registry is smaller than capacity.
+   * 2. Scans the DOM for live tasty classNames — the DOM, not a ref count, is
+   *    what says a class rendered by a component is still in use.
+   * 3. With `force: true`: deletes every unused class.
+   *    Without `force`: keeps the `capacity` most recently touched and deletes
+   *    the rest, oldest first.
+   *
+   * @returns Number of styles evicted.
+   */
+  gc(options?: GCOptions): number;
+  /**
+   * Destroy all resources for a root
+   */
+  destroy(root?: Document | ShadowRoot): void;
+}
+//#endregion
+//#region src/functions/index.d.ts
+/**
+ * A parse-time function: receives the parsed (comma-separated) argument groups
+ * and returns a CSS value string. This is the JS flavor of the unified
+ * `functions` config (bare-name keys), distinct from declarative `@function`
+ * definitions (`$$`-prefixed keys).
+ */
+type ParseFunction = (groups: StyleDetails[]) => string;
+/**
+ * The unified `functions` map: keys are either bare names (parse functions,
+ * value is a function) or `$$name`/`$name`/`--name` (declarative CSS functions,
+ * value is a {@link FunctionDefinition} object).
+ */
+type FunctionsConfig = Record<string, FunctionDefinition | ParseFunction>;
+//#endregion
+//#region src/utils/color-space.d.ts
+/**
+ * Color handling that survives into the emitted CSS.
+ *
+ * Tasty does not rewrite a color into a particular color space: opacity is
+ * applied with CSS relative color syntax, which reads the channels off whatever
+ * the browser resolves a value to, so a color is emitted exactly as authored.
+ * What is left here is how an alpha gets applied, and the one distinction that
+ * matters — replacing a token's alpha versus composing onto an inherited one.
+ */
+/**
+ * The color space a `#name` token's value used to be rewritten into.
+ *
+ * @deprecated Kept for the `colorSpace` config option, which no longer has any
+ * effect. Colors are emitted as authored and opacity is always applied in
+ * `oklch` through relative color syntax.
+ */
+type ColorSpace = 'rgb' | 'hsl' | 'oklch';
+//#endregion
+//#region src/utils/typography.d.ts
+/**
+ * A typography token value: plain value or a state map for responsive/theme-aware presets.
+ *
+ * @example
+ * // Plain value
+ * fontWeight: '400'
+ * // State map
+ * fontWeight: { '': '400', '@dark': '300' }
+ */
+type TypographyTokenValue = string | number | Record<string, string | number | undefined | null | '@inherit'>;
+/**
+ * Typography preset configuration.
+ * Each preset defines font properties that get expanded into CSS custom properties.
+ * All fields accept plain values or state maps for responsive/theme-aware tokens.
+ *
+ * Use with `generateTypographyTokens()` to create typography tokens for your design system.
+ */
+interface TypographyPreset {
+  fontSize: TypographyTokenValue;
+  lineHeight: TypographyTokenValue;
+  letterSpacing?: TypographyTokenValue;
+  fontWeight: TypographyTokenValue;
+  boldFontWeight?: TypographyTokenValue;
+  iconSize?: TypographyTokenValue;
+  textTransform?: TypographyTokenValue;
+  fontFamily?: TypographyTokenValue;
+  fontStyle?: TypographyTokenValue;
+}
+/**
+ * Generate typography tokens with $ prefix for CSS custom properties.
+ *
+ * Each preset generates the following CSS custom properties:
+ * - `${name}-font-size`
+ * - `${name}-line-height`
+ * - `${name}-letter-spacing`
+ * - `${name}-font-weight`
+ * - `${name}-bold-font-weight` (if defined)
+ * - `${name}-icon-size` (if defined)
+ * - `${name}-text-transform` (if defined)
+ * - `${name}-font-family` (if defined)
+ * - `${name}-font-style` (if defined)
+ *
+ * @param presets - Typography presets object
+ * @returns ConfigTokens object with $ prefixed keys
+ *
+ * @example
+ * const customTokens = generateTypographyTokens({
+ *   myHeading: { fontSize: '24px', lineHeight: '32px', fontWeight: '700' },
+ *   body: { fontSize: '16px', lineHeight: '24px', fontWeight: '400' },
+ * });
+ */
+declare function generateTypographyTokens(presets: Record<string, TypographyPreset>): ConfigTokens;
+//#endregion
+//#region src/plugins/types.d.ts
+/**
+ * A tasty plugin that extends the style system with custom functions, units, states, or handlers.
+ */
+interface TastyPlugin {
+  /** Unique name for the plugin (used for debugging and conflict detection) */
+  name: string;
+  /**
+   * Custom functions (unified map). Bare keys map to parse functions
+   * `(groups) => string`; `$$name` keys map to declarative CSS `@function`
+   * definitions. See {@link FunctionsConfig}.
+   */
+  functions?: FunctionsConfig;
+  /** Custom units that transform numeric values (e.g., `2x` → `calc(2 * var(--gap))`) */
+  units?: Record<string, string | UnitHandler>;
+  /** Custom state aliases (e.g., `'@mobile': '@media(w < 768px)'`) */
+  states?: Record<string, string>;
+  /**
+   * Custom style handlers that transform style properties into CSS declarations.
+   * Handlers replace built-in handlers for the same style name.
+   * @example
+   * ```ts
+   * handlers: {
+   *   // Simple handler - lookup style inferred from key
+   *   fill: ({ fill }) => fill ? { 'background-color': fill } : undefined,
+   *   // Multi-property handler
+   *   spacing: [['gap', 'padding'], ({ gap, padding }) => ({ ... })],
+   * }
+   * ```
+   */
+  handlers?: Record<string, StyleHandlerDefinition>;
+  /**
+   * Props middleware for every tasty component — props in, props out. The
+   * extension point for props that are not style properties: read a custom prop,
+   * strip it so it never reaches the DOM, and fold its meaning into `styles`,
+   * `mods`, `tokens`, `variant`, or `as`.
+   *
+   * Must be pure and must not mutate its input.
+   * See {@link TastyConfig.propHandlers}.
+   * @example
+   * ```ts
+   * propHandlers: {
+   *   glaze: (props) => {
+   *     const { glaze, ...rest } = props;
+   *     if (!glaze) return rest;
+   *     return { ...rest, styles: mergeStyles(glazeStyles(glaze), rest.styles) };
+   *   },
+   * }
+   * ```
+   */
+  propHandlers?: Record<string, PropHandlerDefinition>;
+  /**
+   * Style properties exposed as top-level props on every tasty component, in
+   * addition to the built-in base styles.
+   * See {@link TastyConfig.baseStyleProps}.
+   */
+  baseStyleProps?: readonly string[];
+  /**
+   * Design tokens injected as CSS custom properties on `:root`.
+   * Values are parsed through the Tasty DSL. Supports state maps.
+   * - `$name` → `--name` CSS custom property
+   * - `#name` → `--name-color`
+   */
+  tokens?: ConfigTokens;
+  /** Predefined tokens replaced during style parsing (`$name` or `#name`) */
+  replaceTokens?: Record<`$${string}` | `#${string}`, string | number>;
+  /**
+   * Predefined style recipes -- named style bundles that can be applied via `recipe` style property.
+   * Recipe values are flat tasty styles (no sub-element keys).
+   * @example
+   * ```ts
+   * recipes: {
+   *   card: { padding: '4x', fill: '#surface', radius: '1r', border: true },
+   *   elevated: { shadow: '2x 2x 4x #shadow' },
+   * }
+   * ```
+   */
+  recipes?: Record<string, RecipeStyles>;
+  /**
+   * Typography presets — shorthand for `generateTypographyTokens()`.
+   * Generated tokens are merged under explicit `tokens` (tokens win on conflict).
+   */
+  presets?: Record<string, TypographyPreset>;
+  /**
+   * Global Tasty styles keyed by CSS selector.
+   * Supports the full Tasty style syntax.
+   */
+  globalStyles?: Record<string, Styles>;
+  /**
+   * Global CSS `@property` definitions. A plugin whose handler or prop handler
+   * emits a custom property usually wants one, so the property animates and
+   * inherits correctly instead of being treated as an untyped string.
+   * See {@link TastyConfig.properties}.
+   */
+  properties?: Record<string, PropertyDefinition>;
+  /** Global keyframes, injected only when referenced. See {@link TastyConfig.keyframes}. */
+  keyframes?: Record<string, KeyframesSteps>;
+  /** Global `@font-face` definitions. See {@link TastyConfig.fontFaces}. */
+  fontFaces?: Record<string, FontFaceInput>;
+  /** Global `@counter-style` definitions. See {@link TastyConfig.counterStyles}. */
+  counterStyles?: Record<string, CounterStyleDescriptors>;
+}
+/**
+ * A factory function that creates a TastyPlugin.
+ * Can optionally accept configuration options.
+ *
+ * @example
+ * ```ts
+ * // Plugin without options
+ * const okhslPlugin: TastyPluginFactory = () => ({
+ *   name: 'okhsl',
+ *   functions: { okhsl: okhslFunction },
+ * });
+ *
+ * // Plugin with options
+ * const debugPlugin: TastyPluginFactory<{ verbose: boolean }> = (options) => ({
+ *   name: 'debug',
+ *   functions: { debug: createDebugFunc(options.verbose) },
+ * });
+ * ```
+ */
+type TastyPluginFactory<TOptions = void> = TOptions extends void ? () => TastyPlugin : (options: TOptions) => TastyPlugin;
+//#endregion
+//#region src/config.d.ts
+/**
+ * Configuration options for the Tasty style system
+ */
+interface TastyConfig {
+  /** CSP nonce for style elements */
+  nonce?: string;
+  /** Maximum rules per stylesheet (default: 8192) */
+  maxRulesPerSheet?: number;
+  /** Force text injection mode, auto-detected in test environments (default: auto) */
+  forceTextInjection?: boolean;
+  /** Enable development mode features: performance metrics and debug info (default: auto) */
+  devMode?: boolean;
+  /**
+   * Global predefined states for advanced state mapping.
+   * These are state aliases that can be used in any component.
+   * Example: { '@mobile': '@media(w < 920px)', '@dark': '@root(theme=dark)' }
+   */
+  states?: Record<string, string>;
+  /**
+   * Parser LRU cache size (default: 1000).
+   * Larger values improve performance for apps with many unique style values.
+   */
+  parserCacheSize?: number;
+  /**
+   * Custom units for the style parser (merged with built-in units).
+   * Units transform numeric values like `2x` → `calc(2 * var(--gap))`.
+   * @example { em: 'em', vw: 'vw', custom: (n) => `${n * 10}px` }
+   */
+  units?: Record<string, string | UnitHandler>;
+  /**
+   * Custom functions (merged with existing). A single map holds both flavors,
+   * discriminated by value type:
+   *
+   * - **Bare key + function value** — a parse-time function that processes the
+   *   parsed argument groups and returns a CSS value. Called as `name(...)`.
+   * - **`$$name` key + object value** — a declarative CSS `@function`
+   *   definition. Called as `$$name(...)` (→ native `--name(...)`).
+   *
+   * A key whose prefix does not match its value type (object under a bare key,
+   * or function under a `$$` key) is ignored with a dev warning.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   functions: {
+   *     double: (groups) => `calc(2 * ${groups[0].output})`, // parse function
+   *     $$negative: { args: ['$value'], result: '(-1 * $value)' }, // CSS function
+   *   },
+   * });
+   * ```
+   */
+  functions?: FunctionsConfig;
+  /**
+   * @deprecated No longer has any effect; will be removed in the next major.
+   * Setting it warns in development.
+   *
+   * A `#name` token's value used to be rewritten into this color space so an
+   * opacity suffix had numeric channels to write an alpha into. Opacity now uses
+   * relative color syntax — `oklch(from var(--name-color) l c h / .5)` — which
+   * has the browser read the channels, so a color is emitted exactly as
+   * authored and there is nothing left for the setting to decide.
+   *
+   * To address a token's channels yourself, write relative color syntax against
+   * the token: `oklch(from var(--brand-color) calc(l * 1.2) c h)`. It works on
+   * every `<color>`, including the ones no conversion could evaluate.
+   */
+  colorSpace?: ColorSpace;
+  /**
+   * Automatically infer and register CSS @property declarations
+   * from custom property values found in styles, keyframes, and global config.
+   * Covers all types: \<color\>, \<number\>, \<length\>, \<angle\>, \<percentage\>, \<time\>.
+   * When false, only explicitly declared @property are registered.
+   * @default true
+   */
+  autoPropertyTypes?: boolean;
+  /**
+   * Defer stylesheet writes and apply them in one batch instead of performing
+   * one `insertRule()` per component during render.
+   *
+   * Each `insertRule()` on a live sheet invalidates style for that sheet's
+   * scope. When components inject during React's render phase while other
+   * components read layout in the same pass, the two interleave and the browser
+   * is forced to recalculate style between every injection. Batching collapses
+   * that into one invalidation per flush.
+   *
+   * - `false` (default) — inject synchronously, one write per component.
+   * - `true` — batch, but only inside a *batch window*: a commit in which
+   *   `<TastyBatchProvider>` rendered and will therefore flush in its
+   *   `useInsertionEffect`, before any `useLayoutEffect` runs. Any injection
+   *   outside a window — a deep update the provider did not re-render for, an
+   *   injection from a layout effect, an event handler, an async callback — is
+   *   written straight through. Enabling this can never make a layout effect
+   *   measure an unstyled element. Requires `<TastyBatchProvider>`; without it
+   *   nothing is batched (and dev mode says so once).
+   * - `'always'` — batch every injection, flushing on a microtask when no
+   *   window is open. Wins on more commits, but a `useLayoutEffect` that
+   *   measures a freshly mounted element can read its unstyled box, because
+   *   microtasks run after the layout phase. Paint is unaffected: microtasks
+   *   always drain before the browser paints.
+   *
+   * No effect during SSR or RSC: styles are collected as text there, the
+   * runtime injector never runs, and the provider is inert without a
+   * `document`. No effect on zero-runtime `tastyStatic` styles either — those
+   * are extracted at build time and never reach the injector.
+   *
+   * @default false
+   * @example
+   * ```tsx
+   * configure({ batchInjection: true });
+   *
+   * <TastyBatchProvider>
+   *   <App />
+   * </TastyBatchProvider>
+   * ```
+   */
+  batchInjection?: boolean | 'always';
+  /**
+   * Garbage collection configuration for unused styles.
+   * GC is triggered by touch count: every `touchInterval` touches, the
+   * oldest unused styles are evicted when their count exceeds `capacity`.
+   * @example
+   * ```ts
+   * configure({
+   *   gc: { touchInterval: 1000, capacity: 1000 },
+   * });
+   * ```
+   */
+  gc?: GCConfig;
+  /**
+   * Prefix prepended to every generated identifier (class names,
+   * keyframe names, counter-style names). The hash is appended verbatim,
+   * so include any separator inside the prefix itself (e.g. `'myapp-'`).
+   *
+   * Discriminator letters are inserted between the prefix and the hash
+   * for non-class names so the three kinds stay visually distinct:
+   * - class:         `${namePrefix}${hash}`        — e.g. `t1a2b3`
+   * - keyframe:      `${namePrefix}k${hash}`       — e.g. `tk1a2b3`
+   * - counter-style: `${namePrefix}c${hash}`       — e.g. `tc1a2b3`
+   *
+   * The runtime, SSR, and RSC paths must agree on this value or
+   * hydration will mismatch. The zero-runtime build path defaults to
+   * `'ts'` (overridable via the same option) so its classes can't
+   * collide with runtime classes when both are loaded on the same page.
+   *
+   * Must match `^[a-zA-Z_][a-zA-Z0-9_-]{0,31}$`. Locked once styles
+   * have been generated.
+   *
+   * @default 't'
+   */
+  namePrefix?: string;
+  /**
+   * Plugins that extend tasty with custom functions, units, or states.
+   * Plugins are processed in order, with later plugins overriding earlier ones.
+   * @example
+   * ```ts
+   * import { okhslPlugin } from '@tenphi/tasty';
+   *
+   * configure({
+   *   plugins: [okhslPlugin()],
+   * });
+   * ```
+   */
+  plugins?: TastyPlugin[];
+  /**
+   * Global keyframes definitions that can be referenced by animation names in styles.
+   * Keys are animation names, values are keyframes step definitions.
+   * Keyframes are only injected when actually used in styles.
+   * @example
+   * ```ts
+   * configure({
+   *   keyframes: {
+   *     fadeIn: { from: { opacity: 0 }, to: { opacity: 1 } },
+   *     pulse: { '0%, 100%': { transform: 'scale(1)' }, '50%': { transform: 'scale(1.05)' } },
+   *   },
+   * });
+   * ```
+   */
+  keyframes?: Record<string, KeyframesSteps>;
+  /**
+   * Global CSS @property definitions for custom properties.
+   * Keys use tasty token syntax ($name for properties, #name for colors).
+   *
+   * Tasty ships with `DEFAULT_PROPERTIES` (e.g. `$gap`, `$radius`, `#white`,
+   * `#black`, `#clear`, `#border`, etc.) that are always included.
+   * Properties you specify here are merged on top, so you can override any
+   * default by using the same key.
+   *
+   * For color tokens (#name), `syntax: '<color>'` is auto-set and
+   * `initialValue` defaults to `'transparent'` if not specified.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   properties: {
+   *     '$rotation': { syntax: '<angle>', initialValue: '0deg' },
+   *     '$scale': { syntax: '<number>', inherits: false, initialValue: 1 },
+   *     '#accent': { initialValue: 'purple' }, // syntax: '<color>' auto-set
+   *     // Override a default property:
+   *     '$gap': { syntax: '<length>', inherits: true, initialValue: '8px' },
+   *   },
+   * });
+   *
+   * // Now use in styles - properties are registered when component renders:
+   * const Spinner = tasty({
+   *   styles: {
+   *     transform: 'rotate($rotation)',
+   *     transition: '$$rotation 0.3s', // outputs: --rotation 0.3s
+   *   },
+   * });
+   * ```
+   */
+  properties?: Record<string, PropertyDefinition>;
+  /**
+   * Global @font-face definitions.
+   * Keys are font-family names, values are descriptors or arrays of descriptors
+   * (for multiple weights/styles of the same family).
+   * Injected eagerly when styles are first generated.
+   * @example
+   * ```ts
+   * configure({
+   *   fontFaces: {
+   *     'Brand Sans': [
+   *       { src: 'url("/fonts/brand-regular.woff2") format("woff2")', fontWeight: 400, fontDisplay: 'swap' },
+   *       { src: 'url("/fonts/brand-bold.woff2") format("woff2")', fontWeight: 700, fontDisplay: 'swap' },
+   *     ],
+   *     Icons: { src: 'url("/fonts/icons.woff2") format("woff2")', fontDisplay: 'block' },
+   *   },
+   * });
+   * ```
+   */
+  fontFaces?: Record<string, FontFaceInput>;
+  /**
+   * Global @counter-style definitions.
+   * Keys are counter-style names, values are descriptor objects.
+   * Injected eagerly when styles are first generated.
+   * @example
+   * ```ts
+   * configure({
+   *   counterStyles: {
+   *     thumbs: { system: 'cyclic', symbols: '"👍"', suffix: '" "' },
+   *   },
+   * });
+   * ```
+   */
+  counterStyles?: Record<string, CounterStyleDescriptors>;
+  /**
+   * Opt-in polyfills for not-yet-baseline CSS features. Each key toggles a
+   * feature polyfill; all default to `false`.
+   *
+   * - `functions` — polyfill CSS `@function` by inlining every `$$name(...)`
+   *   call into plain CSS (calc/var/color-mix) at parse time instead of
+   *   emitting the native `@function` at-rule. Enables `@function` usage in
+   *   browsers that don't support it yet (Firefox/Safari). Note this is the
+   *   `functions` *feature toggle*, distinct from the top-level `functions`
+   *   definitions map.
+   *
+   * @example
+   * ```ts
+   * configure({ polyfills: { functions: true } });
+   * ```
+   */
+  polyfills?: {
+    functions?: boolean;
+  };
+  /**
+   * Custom style handlers that transform style properties into CSS declarations.
+   * Handlers replace built-in handlers for the same style name.
+   * @example
+   * ```ts
+   * import { styleHandlers } from '@tenphi/tasty';
+   *
+   * configure({
+   *   handlers: {
+   *     // Override fill with custom behavior
+   *     fill: ({ fill }) => {
+   *       if (fill?.startsWith('gradient:')) {
+   *         return { background: fill.slice(9) };
+   *       }
+   *       return styleHandlers.fill({ fill });
+   *     },
+   *     // Add new custom style
+   *     elevation: ({ elevation }) => {
+   *       const level = parseInt(elevation) || 1;
+   *       return {
+   *         'box-shadow': `0 ${level * 2}px ${level * 4}px rgba(0,0,0,0.1)`,
+   *         'z-index': String(level * 100),
+   *       };
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  handlers?: Record<string, StyleHandlerDefinition>;
+  /**
+   * Props middleware for every tasty component. A prop handler receives the
+   * component's props and returns them, changed or not — the extension point for
+   * props that are not style properties.
+   *
+   * The map key is the handler's name and, by default, the prop that triggers it.
+   * Use `['*', fn]` for an unconditional handler, or `[['a', 'b'], fn]` to trigger
+   * on any of several props.
+   *
+   * Handlers must be pure and must not mutate their input: style values are cached
+   * by object identity, so mutating one in place yields stale CSS. Memoize the
+   * styles you build per input value.
+   *
+   * Not applicable to zero-runtime mode — `tastyStatic()` takes styles objects, not
+   * props, so there is nothing for middleware to run on. Components rendered
+   * through `tasty()` are unaffected and keep the runtime injector.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   propHandlers: {
+   *     glaze: (props) => {
+   *       const { glaze, ...rest } = props;
+   *       if (!glaze) return rest;
+   *       return { ...rest, styles: mergeStyles(glazeStyles(glaze), rest.styles) };
+   *     },
+   *   },
+   * });
+   *
+   * <Element glaze="purple" />
+   * ```
+   */
+  propHandlers?: Record<string, PropHandlerDefinition>;
+  /**
+   * Style properties exposed as top-level props on **every** tasty component, in
+   * addition to the built-in base styles, without each component listing them in
+   * `styleProps`.
+   *
+   * Augment `TastyBaseStylePropNames` to type them. Each name costs one property
+   * check per render of every component, so keep the list short; the effect is
+   * app-global and cannot be scoped to a subtree.
+   *
+   * @example
+   * ```ts
+   * configure({ baseStyleProps: ['radius', 'shadow'] });
+   *
+   * <Card radius="1r" shadow />
+   * ```
+   */
+  baseStyleProps?: readonly string[];
+  /**
+   * Design tokens injected as CSS custom properties on `:root`.
+   * Values are parsed through the Tasty DSL. Supports state maps
+   * for responsive/theme-aware tokens.
+   *
+   * - `$name` keys become `--name` CSS custom properties
+   * - `#name` keys become `--name-color` properties
+   *
+   * Tokens are injected once when the first style is rendered.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   tokens: {
+   *     '$gap': '4px',
+   *     '#primary': {
+   *       '': '#purple',
+   *       '@dark': '#light-purple',
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  tokens?: ConfigTokens;
+  /**
+   * Predefined tokens that are replaced during style parsing (parse-time substitution).
+   * Use `$name` for custom properties and `#name` for color tokens.
+   * Values are substituted inline before CSS generation, unlike `tokens` which
+   * inject CSS custom properties on `:root`.
+   *
+   * For color tokens (#name), boolean `true` is converted to `transparent`.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   replaceTokens: {
+   *     $spacing: '2x',
+   *     '#accent': '#purple',
+   *     '#overlay': true, // → transparent
+   *   },
+   * });
+   *
+   * // Now use in styles - tokens are replaced at parse time:
+   * const Card = tasty({
+   *   styles: {
+   *     padding: '$spacing',  // → calc(2 * var(--gap))
+   *     fill: '#accent',      // → var(--purple-color)
+   *   },
+   * });
+   * ```
+   */
+  replaceTokens?: Record<`$${string}`, string | number | boolean> & Record<`#${string}`, string | number | boolean>;
+  /**
+   * Predefined style recipes -- named style bundles that can be applied via `recipe` style property.
+   * Recipe values are flat tasty styles (no sub-element keys). They may contain base styles,
+   * tokens (`$name`/`#name` definitions), local states, `@keyframes`, and `@property`.
+   *
+   * Components reference recipes via: `recipe: 'name1 name2'` in their styles.
+   * Use `/` to separate base recipes from post recipes: `recipe: 'base1 base2 / post1'`.
+   * Use `none` to skip base recipes: `recipe: 'none / post1'`.
+   * Resolution order: `base_recipes → component styles → post_recipes`.
+   *
+   * Recipes cannot reference other recipes.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   recipes: {
+   *     card: { padding: '4x', fill: '#surface', radius: '1r', border: true },
+   *     elevated: { shadow: '2x 2x 4x #shadow' },
+   *   },
+   * });
+   *
+   * // Usage in styles:
+   * const Card = tasty({
+   *   styles: {
+   *     recipe: 'card elevated',
+   *     color: '#text', // Overrides recipe values
+   *   },
+   * });
+   * ```
+   */
+  recipes?: Record<string, RecipeStyles>;
+  /**
+   * Typography presets — shorthand for `generateTypographyTokens()`.
+   * Accepts the same input and internally generates typography tokens
+   * that are merged into `tokens`. Explicit `tokens` override preset-generated ones.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   presets: {
+   *     h1: { fontSize: '32px', lineHeight: '1.2', fontWeight: '700' },
+   *     t2: { fontSize: '16px', lineHeight: '1.5', fontWeight: '400' },
+   *   },
+   *   tokens: {
+   *     // Overrides the preset-generated $t2-font-weight
+   *     '$t2-font-weight': { '': '400', '@dark': '300' },
+   *   },
+   * });
+   * ```
+   */
+  presets?: Record<string, TypographyPreset>;
+  /**
+   * Global Tasty styles keyed by CSS selector.
+   * Each entry applies the full Tasty style syntax (style properties,
+   * tokens, state maps, selector-based sub-styling) to the given selector.
+   * Injected alongside `:root` tokens when the first style is rendered.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   globalStyles: {
+   *     body: { fill: '#surface', color: '#text', preset: 't2', margin: 0 },
+   *     html: { overflow: 'hidden' },
+   *   },
+   * });
+   * ```
+   */
+  globalStyles?: Record<string, Styles>;
+}
+declare const GLOBAL_INJECTOR_KEY = "__TASTY_GLOBAL_INJECTOR__";
+declare global {
+  interface Window {
+    [GLOBAL_INJECTOR_KEY]?: StyleInjector;
+  }
+  var __TASTY_GLOBAL_INJECTOR__: StyleInjector | undefined;
+}
+/**
+ * Detect if we're running in a test environment
+ */
+declare function isTestEnvironment(): boolean;
+/**
+ * Check if styles have been generated (configuration is locked)
+ */
+declare function hasStylesGenerated(): boolean;
+/**
+ * Check if any global keyframes are configured.
+ * Uses a pre-computed flag to avoid Object.keys() allocation on every call.
+ */
+declare function hasGlobalKeyframes(): boolean;
+/**
+ * Get global keyframes configuration.
+ * Returns null if no keyframes configured (fast path for zero-overhead).
+ */
+declare function getGlobalKeyframes(): Record<string, KeyframesSteps> | null;
+/**
+ * Get global font-face configuration.
+ * Returns null if no font faces configured.
+ * Reads from globalThis first for cross-module SSR support.
+ */
+declare function getGlobalFontFaces(): Record<string, FontFaceInput> | null;
+/**
+ * Get global counter-style configuration.
+ * Returns null if no counter styles configured.
+ * Reads from globalThis first for cross-module SSR support.
+ */
+declare function getGlobalCounterStyles(): Record<string, CounterStyleDescriptors> | null;
+/**
+ * Get global @function configuration.
+ * Returns null if no functions configured.
+ * Reads from globalThis first for cross-module SSR support.
+ */
+declare function getGlobalFunctions(): Record<string, FunctionDefinition> | null;
+/**
+ * Check if any global recipes are configured.
+ * Fast path: returns false if no recipes were ever set.
+ */
+declare function hasGlobalRecipes(): boolean;
+/**
+ * Get global recipes configuration.
+ * Returns null if no recipes configured (fast path for zero-overhead).
+ */
+declare function getGlobalRecipes(): Record<string, RecipeStyles> | null;
+/**
+ * Check if configuration is locked (styles have been generated)
+ */
+declare function isConfigLocked(): boolean;
+/**
+ * Configure the Tasty style system.
+ *
+ * Must be called BEFORE any styles are generated (before first render that uses tasty).
+ * After styles are generated, configuration is locked and calls to configure() will
+ * emit a warning and be ignored.
+ *
+ * @example
+ * ```ts
+ * import { configure } from '@tenphi/tasty';
+ *
+ * // Configure before app renders
+ * configure({
+ *   nonce: 'abc123',
+ *   states: {
+ *     '@mobile': '@media(w < 768px)',
+ *     '@dark': '@root(theme=dark)',
+ *   },
+ * });
+ * ```
+ */
+declare function configure(config?: Partial<TastyConfig>): void;
+/**
+ * Get the current configuration.
+ * If not configured, returns default configuration.
+ */
+declare function getConfig(): TastyConfig;
+/**
+ * Get the configured prefix used for every generated identifier
+ * (class names, keyframe names, counter-style names).
+ *
+ * Falls back to the default prefix (`'t'`) when `configure()` has not
+ * been called yet — this matches the auto-configuration behavior used
+ * by the rest of the system.
+ */
+declare function getNamePrefix(): string;
+/**
+ * Reset configuration (for testing only).
+ * Clears the global injector and allows reconfiguration.
+ */
+declare function resetConfig(): void;
+//#endregion
+export { ParseFunction as C, PropHandlerDefinition as D, PropHandler as E, PropHandlerProps as O, FunctionsConfig as S, SheetManager as T, TastyPluginFactory as _, getGlobalFontFaces as a, generateTypographyTokens as b, getGlobalRecipes as c, hasGlobalRecipes as d, hasStylesGenerated as f, TastyPlugin as g, resetConfig as h, getGlobalCounterStyles as i, getNamePrefix as l, isTestEnvironment as m, configure as n, getGlobalFunctions as o, isConfigLocked as p, getConfig as r, getGlobalKeyframes as s, TastyConfig as t, hasGlobalKeyframes as u, TypographyPreset as v, StyleInjector as w, ColorSpace as x, TypographyTokenValue as y };
+//# sourceMappingURL=config-LfIDmVHx.d.ts.map