@tenphi/tasty 3.4.0 → 3.5.0

package/docs/migration-v3.md

@@ -21,30 +21,30 @@ Most of the work is mechanical renames — see the [search-and-replace cheat she
 
 ## At a glance
 
-| v2.11 | v3.0 | Find it with |
-|---|---|---|
-| `'@properties': { … }` | `'@property': { … }` | `rg "'@properties'"` |
-| `'@fontFace': { … }` | `'@font-face': { … }` | `rg "'@fontFace'"` |
-| `'@counterStyle': { … }` | `'@counter-style': { … }` | `rg "'@counterStyle'"` |
-| `padding: '2x 4x top right'` | `padding: '2x top, 4x right'` | dev-mode console warning |
-| `fade: '3x 1x top bottom'` | `fade: '3x top, 1x bottom'` | dev-mode console warning |
-| `configure({ funcs })` | `configure({ functions })` | `rg "funcs"` |
-| `configure({ fontFace })` | `configure({ fontFaces })` | `rg "fontFace:"` |
-| `configure({ counterStyle })` | `configure({ counterStyles })` | `rg "counterStyle:"` |
-| `getCssText()` | `getCSSText()` | `rg "getCssText"` |
-| `getCssTextForNode()` | `getCSSTextForNode()` | `rg "getCssTextForNode"` |
-| `getCssTextForClasses()` | `getCSSTextForClasses()` | `rg "getCssTextForClasses"` |
-| `getGlobalFontFace()` | `getGlobalFontFaces()` | `rg "getGlobalFontFace\b"` |
-| `getGlobalCounterStyle()` | `getGlobalCounterStyles()` | `rg "getGlobalCounterStyle\b"` |
-| `getGlobalFunction()` | `getGlobalFunctions()` | `rg "getGlobalFunction\b"` |
-| `okhslFunc` / `okhstFunc` | `okhslFunction` / `okhstFunction` | `rg "okhs[lt]Func\b"` |
-| `CssOptions` | `CSSOptions` | `rg "CssOptions"` |
-| `ParserOptions.funcs` | `ParserOptions.functions` | `rg "funcs:"` |
-| `StyleParser#setFuncs()` | `StyleParser#setFunctions()` | `rg "setFuncs"` |
-| `ChunkInfo` (from `tastyDebug`) | `DebugChunkInfo` | `rg "ChunkInfo"` |
-| `@tenphi/tasty/next` | `@tenphi/tasty/zero/next` | `rg "tasty/next"` |
-| `getIsTestEnvironment()` | `isTestEnvironment()` | `rg "getIsTestEnvironment"` |
-| `hydrateTastyCache()` | `hydrateTastyClasses()` | `rg "hydrateTastyCache"` |
+| v2.11                           | v3.0                              | Find it with                   |
+| ------------------------------- | --------------------------------- | ------------------------------ |
+| `'@properties': { … }`          | `'@property': { … }`              | `rg "'@properties'"`           |
+| `'@fontFace': { … }`            | `'@font-face': { … }`             | `rg "'@fontFace'"`             |
+| `'@counterStyle': { … }`        | `'@counter-style': { … }`         | `rg "'@counterStyle'"`         |
+| `padding: '2x 4x top right'`    | `padding: '2x top, 4x right'`     | dev-mode console warning       |
+| `fade: '3x 1x top bottom'`      | `fade: '3x top, 1x bottom'`       | dev-mode console warning       |
+| `configure({ funcs })`          | `configure({ functions })`        | `rg "funcs"`                   |
+| `configure({ fontFace })`       | `configure({ fontFaces })`        | `rg "fontFace:"`               |
+| `configure({ counterStyle })`   | `configure({ counterStyles })`    | `rg "counterStyle:"`           |
+| `getCssText()`                  | `getCSSText()`                    | `rg "getCssText"`              |
+| `getCssTextForNode()`           | `getCSSTextForNode()`             | `rg "getCssTextForNode"`       |
+| `getCssTextForClasses()`        | `getCSSTextForClasses()`          | `rg "getCssTextForClasses"`    |
+| `getGlobalFontFace()`           | `getGlobalFontFaces()`            | `rg "getGlobalFontFace\b"`     |
+| `getGlobalCounterStyle()`       | `getGlobalCounterStyles()`        | `rg "getGlobalCounterStyle\b"` |
+| `getGlobalFunction()`           | `getGlobalFunctions()`            | `rg "getGlobalFunction\b"`     |
+| `okhslFunc` / `okhstFunc`       | `okhslFunction` / `okhstFunction` | `rg "okhs[lt]Func\b"`          |
+| `CssOptions`                    | `CSSOptions`                      | `rg "CssOptions"`              |
+| `ParserOptions.funcs`           | `ParserOptions.functions`         | `rg "funcs:"`                  |
+| `StyleParser#setFuncs()`        | `StyleParser#setFunctions()`      | `rg "setFuncs"`                |
+| `ChunkInfo` (from `tastyDebug`) | `DebugChunkInfo`                  | `rg "ChunkInfo"`               |
+| `@tenphi/tasty/next`            | `@tenphi/tasty/zero/next`         | `rg "tasty/next"`              |
+| `getIsTestEnvironment()`        | `isTestEnvironment()`             | `rg "getIsTestEnvironment"`    |
+| `hydrateTastyCache()`           | `hydrateTastyClasses()`           | `rg "hydrateTastyCache"`       |
 
 ---
 
@@ -73,7 +73,7 @@ At-rule keys now match the real CSS at-rule names Tasty already emits, so they a
 
 **This is the one change that can alter rendered CSS without a rename.** A style group that names direction modifiers now takes a **single** value, applied to every direction it names.
 
-The old form looked positional but never was: the parser buckets values and modifiers into separate arrays per comma group, so `'2x 4x top right'`, `'2x top 4x right'`, and `'top 2x right 4x'` were all the same input, and the pairing was decided by the order the *modifiers* happened to appear in. `'1x 2x right top'` and `'1x 2x top right'` produced different CSS, and `'1x 2x top top'` silently assigned `top` twice.
+The old form looked positional but never was: the parser buckets values and modifiers into separate arrays per comma group, so `'2x 4x top right'`, `'2x top 4x right'`, and `'top 2x right 4x'` were all the same input, and the pairing was decided by the order the _modifiers_ happened to appear in. `'1x 2x right top'` and `'1x 2x top right'` produced different CSS, and `'1x 2x top top'` silently assigned `top` twice.
 
 Per-side values now come from comma-separated groups:
 
@@ -155,25 +155,25 @@ A key whose prefix doesn't match its value type is ignored with a development wa
 
 ## 5. Removed exports
 
-| Removed | Use instead |
-|---|---|
-| `getIsTestEnvironment()` | `isTestEnvironment()` |
-| `hydrateTastyCache()` | `hydrateTastyClasses()` |
-| `customFunc()` | `configure({ functions })` |
-| `getGlobalFuncs()` | `getGlobalFunctions()` for `@function` definitions; the parse-function registry is internal |
-| `resetGlobalFuncs()` | `resetConfig()` |
-| `setGlobalPredefinedTokens()` | `configure({ replaceTokens })` |
-| `resetGlobalPredefinedTokens()` | `resetConfig()` |
-| `setMiddlewareTransferCache()` / `getMiddlewareTransferCache()` | internal; no replacement needed |
-| `clearWriterCache()` | internal test utility |
-| `DEFAULT_PLUGINS` | nothing — it was never consumed, and passing it to `configure({ plugins })` was a no-op. The default `okhsl`/`okhst` functions are registered automatically. |
-| `registerDefaultFunctions()` | internal bootstrap helper |
-| `warn()` / `deprecationWarning()` | internal helpers with no callers |
-| `Bucket` enum | parser-internal |
-| `Props` type | inline `Record<string, any>` |
-| `UseStylesOptions` | `useStyles()` takes `Styles \| undefined` directly |
-| `GlobalStyledProps` | its only member was the already-dead `breakpoints` prop |
-| duplicate `PropertyOptions` | the single `PropertyOptions` from `injector/types` |
+| Removed                                                         | Use instead                                                                                                                                                  |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getIsTestEnvironment()`                                        | `isTestEnvironment()`                                                                                                                                        |
+| `hydrateTastyCache()`                                           | `hydrateTastyClasses()`                                                                                                                                      |
+| `customFunc()`                                                  | `configure({ functions })`                                                                                                                                   |
+| `getGlobalFuncs()`                                              | `getGlobalFunctions()` for `@function` definitions; the parse-function registry is internal                                                                  |
+| `resetGlobalFuncs()`                                            | `resetConfig()`                                                                                                                                              |
+| `setGlobalPredefinedTokens()`                                   | `configure({ replaceTokens })`                                                                                                                               |
+| `resetGlobalPredefinedTokens()`                                 | `resetConfig()`                                                                                                                                              |
+| `setMiddlewareTransferCache()` / `getMiddlewareTransferCache()` | internal; no replacement needed                                                                                                                              |
+| `clearWriterCache()`                                            | internal test utility                                                                                                                                        |
+| `DEFAULT_PLUGINS`                                               | nothing — it was never consumed, and passing it to `configure({ plugins })` was a no-op. The default `okhsl`/`okhst` functions are registered automatically. |
+| `registerDefaultFunctions()`                                    | internal bootstrap helper                                                                                                                                    |
+| `warn()` / `deprecationWarning()`                               | internal helpers with no callers                                                                                                                             |
+| `Bucket` enum                                                   | parser-internal                                                                                                                                              |
+| `Props` type                                                    | inline `Record<string, any>`                                                                                                                                 |
+| `UseStylesOptions`                                              | `useStyles()` takes `Styles \| undefined` directly                                                                                                           |
+| `GlobalStyledProps`                                             | its only member was the already-dead `breakpoints` prop                                                                                                      |
+| duplicate `PropertyOptions`                                     | the single `PropertyOptions` from `injector/types`                                                                                                           |
 
 `getGlobalFuncs()` deserves a note: it returned the **live mutable internal registry**, and writing to it bypassed the parser's cache invalidation, so the write silently never took effect. If you were mutating it, move to `configure({ functions })`.
 
@@ -192,13 +192,13 @@ A key whose prefix doesn't match its value type is ignored with a development wa
 + import { withTasty } from '@tenphi/tasty/zero/next';
 ```
 
-The zero-runtime Next.js wrapper already lived under the `zero` namespace internally; the top-level `/next` path collided confusingly with `@tenphi/tasty/ssr/next`, which is a different integration.
+The build-time extraction Next.js wrapper already lived under the `zero` namespace internally; the top-level `/next` path collided confusingly with `@tenphi/tasty/ssr/next`, which is a different integration.
 
 ---
 
 ## 8. Behavior changes that are not renames
 
-**Repeated `configure()` calls now merge.** `recipes`, `keyframes`, `properties`, `fontFaces`, `counterStyles`, and CSS `@function` definitions used to replace wholesale, so a design-system `configure()` followed by an application `configure()` silently dropped the design system's values. All of them now merge, with the later call winning on a key conflict — matching `tokens` and `globalStyles`, which already merged. If you were relying on a second call to *clear* a collection, use `resetConfig()`.
+**Repeated `configure()` calls now merge.** `recipes`, `keyframes`, `properties`, `fontFaces`, `counterStyles`, and CSS `@function` definitions used to replace wholesale, so a design-system `configure()` followed by an application `configure()` silently dropped the design system's values. All of them now merge, with the later call winning on a key conflict — matching `tokens` and `globalStyles`, which already merged. If you were relying on a second call to _clear_ a collection, use `resetConfig()`.
 
 `configure({ polyfills })` is now correctly rejected after the first render, like every sibling option, and shallow-merges so an unrelated later call cannot switch a polyfill off.
 
@@ -208,7 +208,7 @@ The zero-runtime Next.js wrapper already lived under the `zero` namespace intern
 
 **Replacing a built-in style handler now warns.** Built-in handlers are shared across style names, so `configure({ handlers: { fill } })` also takes over `image` and the whole `background-*` family, and `configure({ handlers: { display } })` takes down `flow`, `gap`, `hide`, `overflow`, `whiteSpace`, and `textOverflow`. This was always true; what's new is that a development-mode warning now names exactly what was displaced. If you see it, either declare the whole group and delegate the rest to `styleHandlers.*`, or pick a narrower name. See [Plugins](plugins.md#custom-style-handlers).
 
-**Multi-dependency custom handlers are fixed.** A handler whose dependencies mixed known and unknown style names was invoked once per chunk with only *part* of its dependencies, and could emit stale CSS. Unknown names now join their handler's chunk, so it is invoked once with all of them. No built-in style moved, so no existing class name changes.
+**Multi-dependency custom handlers are fixed.** A handler whose dependencies mixed known and unknown style names was invoked once per chunk with only _part_ of its dependencies, and could emit stale CSS. Unknown names now join their handler's chunk, so it is invoked once with all of them. No built-in style moved, so no existing class name changes.
 
 **`isChecked` added to the root prop types.** It already worked at runtime; it was just missing from `BaseProps` / `AllBaseProps`.
 
@@ -220,7 +220,7 @@ The zero-runtime Next.js wrapper already lived under the `zero` namespace intern
 
 Nothing here is required to upgrade.
 
-- **CSS `@function` support** — reusable, parameterized functions via the `'@function'` styles key, the `useFunction` style function, or `configure({ functions })`. Works across client, SSR/RSC, and zero-runtime. `configure({ polyfills: { functions: true } })` inlines every call into plain CSS for browsers that don't ship the at-rule yet. See [Style DSL](dsl.md#functions-function).
+- **CSS `@function` support** — reusable, parameterized functions via the `'@function'` styles key, the `useFunction` style function, or `configure({ functions })`. Works across client rendering, SSR/RSC, and build-time extraction. `configure({ polyfills: { functions: true } })` inlines every call into plain CSS for browsers that don't ship the at-rule yet. See [Style DSL](dsl.md#functions-function).
 - **Custom color plugins with no core special-casing** — `okhsl`/`okhst` are now ordinary one-line plugins, and a third-party color space can achieve identical integration. New `createColorFunc` and `resolveFunctionColor` helpers.
 - **`configure({ propHandlers })`** — props middleware for every component: props in, props out. The extension point for props that aren't style values.
 - **`configure({ baseStyleProps })`** — expose style properties as props on every component without listing them in each `styleProps`.
@@ -279,7 +279,7 @@ Worth stating explicitly, because it's easy to assume otherwise:
 
 - **At-rule styles-object keys are CSS-spec-faithful, not JS-conventional.** `@keyframes`, `@property`, `@font-face`, `@counter-style`, `@function`, `@starting` — kebab-case, matching what Tasty emits.
 - **The `func()` injector method stays abbreviated.** `function` is a reserved word.
-- `injector.fontFace()` and `injector.counterStyle()` keep their singular names — only the *config keys* and *getters* were pluralized.
+- `injector.fontFace()` and `injector.counterStyle()` keep their singular names — only the _config keys_ and _getters_ were pluralized.
 - `useFontFace` and `useCounterStyle` are unchanged.
 - `configure({ properties })` and `autoPropertyTypes` are unchanged; only the styles-object `@property` key was renamed.
 - **The deprecated style aliases are retained deliberately.** `backgroundColor`, `background`, `backgroundImage`, `flex`, `grid`, and `flexDirection` still carry `@deprecated` tags and still work. They are the guardrail that discourages their use in projects that have not enabled `@tenphi/eslint-plugin-tasty` yet — read the tags as guidance, not as a removal notice.

package/docs/plugins.md

@@ -43,23 +43,23 @@ configure({ plugins: [spacingPlugin()] });
 
 ## Choosing an extension point
 
-| You want to add | Use | Runs | Zero-runtime |
-|---|---|---|---|
-| New value syntax — `okhsl(…)`, `double(2x)` | `functions` (bare key) | parse time, per value | ✅ |
-| A reusable CSS `@function` | `functions` (`$$name` key) | injected once, globally | ✅ |
-| A new unit — `2gu` | `units` | parse time, per value | ✅ |
-| A new state alias — `@mobile` | `states` | state-key parse | ✅ |
-| A style property → **CSS declarations** | `handlers` | pipeline, per state snapshot | ✅ |
-| A style property on every component | `baseStyleProps` | prop harvest | ✅ (styles only) |
-| A **component prop** → anything | `propHandlers` | render, per component | ❌ (no props to run on) |
-| A named bundle of styles | `recipes` | before chunking | ✅ |
-| Typography scale tokens | `presets` | inject time | ✅ |
-| `:root` variables | `tokens`, `replaceTokens` | inject time | ✅ |
-| Global selector styles | `globalStyles` | inject time | ✅ |
+| You want to add                             | Use                        | Runs                         | Build-time extraction   |
+| ------------------------------------------- | -------------------------- | ---------------------------- | ----------------------- |
+| New value syntax — `okhsl(…)`, `double(2x)` | `functions` (bare key)     | parse time, per value        | ✅                      |
+| A reusable CSS `@function`                  | `functions` (`$$name` key) | injected once, globally      | ✅                      |
+| A new unit — `2gu`                          | `units`                    | parse time, per value        | ✅                      |
+| A new state alias — `@mobile`               | `states`                   | state-key parse              | ✅                      |
+| A style property → **CSS declarations**     | `handlers`                 | pipeline, per state snapshot | ✅                      |
+| A style property on every component         | `baseStyleProps`           | prop harvest                 | ✅ (styles only)        |
+| A **component prop** → anything             | `propHandlers`             | render, per component        | ❌ (no props to run on) |
+| A named bundle of styles                    | `recipes`                  | before chunking              | ✅                      |
+| Typography scale tokens                     | `presets`                  | inject time                  | ✅                      |
+| `:root` variables                           | `tokens`, `replaceTokens`  | inject time                  | ✅                      |
+| Global selector styles                      | `globalStyles`             | inject time                  | ✅                      |
 
 Two distinctions do most of the work:
 
-- **`handlers` vs `propHandlers`.** A handler turns a *style property* into CSS declarations and knows nothing about components. A prop handler turns a *component prop* into other props — including `styles`, which then flow through the normal handlers. Reach for `propHandlers` when the input isn't a style value (an options object, a domain concept) or when it should affect more than styles.
+- **`handlers` vs `propHandlers`.** A handler turns a _style property_ into CSS declarations and knows nothing about components. A prop handler turns a _component prop_ into other props — including `styles`, which then flow through the normal handlers. Reach for `propHandlers` when the input isn't a style value (an options object, a domain concept) or when it should affect more than styles.
 - **`recipes` vs `propHandlers`.** A recipe is a static named bundle. A prop handler computes its styles from a value.
 
 ---
@@ -123,12 +123,12 @@ configure({
 
 **The key is the trigger.** By default a handler runs only when a prop matching its key is present, so an absent prop costs one property check rather than a call. Override that with a tuple:
 
-| Definition | Runs when |
-|---|---|
-| `fn` | a prop named after the key is present |
-| `['glaze', fn]` | `glaze` is present |
-| `[['glaze', 'tint'], fn]` | either is present |
-| `['*', fn]` | always |
+| Definition                | Runs when                             |
+| ------------------------- | ------------------------------------- |
+| `fn`                      | a prop named after the key is present |
+| `['glaze', fn]`           | `glaze` is present                    |
+| `[['glaze', 'tint'], fn]` | either is present                     |
+| `['*', fn]`               | always                                |
 
 **Chaining.** Handlers run in registration order — plugins first, then direct `configure()` — and each receives the previous one's output. Registering the same key twice replaces the handler in place, keeping its position.
 
@@ -136,16 +136,16 @@ configure({
 
 ### Rules
 
-- **Be pure. Never mutate the input.** Style values are cached by object identity, so mutating a value object in place yields a stale class name *and* stale CSS. Return fresh objects.
+- **Be pure. Never mutate the input.** Style values are cached by object identity, so mutating a value object in place yields a stale class name _and_ stale CSS. Return fresh objects.
 - **Memoize the styles you build, per input value.** A reference-stable (ideally frozen) styles object lets the cache key reuse its serialization instead of recomputing it on every render. This is the single highest-leverage thing you can do for performance.
 - **Precedence is fixed** and not adjustable from a handler. Styles are merged as `factory defaults → styles → harvested style props`, and injected styles occupy the `styles` slot: they beat a component's own default styles and lose to a style prop passed at the call site. This matches how `recipe` already behaves.
-- **Prefer returning `styles` over bare style props.** Returning `{ fill: '#red' }` only works if `fill` is harvestable on *that* component (in its `styleProps`, or promoted via `baseStyleProps`); otherwise it leaks to the DOM.
+- **Prefer returning `styles` over bare style props.** Returning `{ fill: '#red' }` only works if `fill` is harvestable on _that_ component (in its `styleProps`, or promoted via `baseStyleProps`); otherwise it leaks to the DOM.
 
 ### What it cannot do
 
 - **`ref`** — `forwardRef` separates it from props, so it is out of reach.
 - **Sub-elements** (`Card.Title`) — they have no `styles` prop and no style-prop harvest, so middleware does not run on them.
-- **Zero-runtime mode** — see [Rendering modes](#rendering-modes-and-caveats).
+- **Build-time extraction** — see [Rendering modes](#rendering-modes-and-caveats).
 
 ---
 
@@ -161,7 +161,7 @@ configure({ baseStyleProps: ['radius', 'shadow'] });
 
 Names must be real style properties, must start with a lowercase letter, and must not collide with a prop `tasty()` consumes itself (`as`, `styles`, `variant`, `mods`, `tokens`, …); invalid entries are dropped with a development warning.
 
-`configure()` may run *after* your components are defined — each factory resolves its prop list lazily and refreshes when the registry changes.
+`configure()` may run _after_ your components are defined — each factory resolves its prop list lazily and refreshes when the registry changes.
 
 **Costs and caveats.** Each name adds one property check per render of every component, forever, so keep the list short. The effect is app-global and cannot be scoped to a subtree — use a factory's own `styleProps` for that. Be wary of names that collide with real DOM or component props (`width`, `size`, `color`): promoting one means every component swallows it as a style, including when rendering `as={SomeThirdPartyComponent}`.
 
@@ -211,7 +211,7 @@ export default {
 };
 ```
 
-`propHandlers` keys are JSX props rather than style keys, so they need no entry — but any *style* name or token a handler expands into does.
+`propHandlers` keys are JSX props rather than style keys, so they need no entry — but any _style_ name or token a handler expands into does.
 
 ---
 
@@ -274,7 +274,11 @@ export const glazePlugin: TastyPluginFactory = () => ({
 
   // Typed so `#glaze-bg` animates smoothly instead of snapping.
   properties: {
-    '#glaze-bg': { syntax: '<color>', inherits: false, initialValue: 'transparent' },
+    '#glaze-bg': {
+      syntax: '<color>',
+      inherits: false,
+      initialValue: 'transparent',
+    },
   },
 });
 ```
@@ -302,19 +306,19 @@ declare module '@tenphi/tasty' {
 }
 ```
 
-The object value is unambiguous here precisely because `glaze` is a **prop**. A style *value* of the same shape would be indistinguishable from a state map (`{ tone: … }` looks exactly like `{ hovered: … }`), which is why this belongs in `propHandlers` rather than `handlers`.
+The object value is unambiguous here precisely because `glaze` is a **prop**. A style _value_ of the same shape would be indistinguishable from a state map (`{ tone: … }` looks exactly like `{ hovered: … }`), which is why this belongs in `propHandlers` rather than `handlers`.
 
 ---
 
 ## Rendering modes and caveats
 
-| Mode | `functions` / `units` / `states` / `handlers` / `recipes` / `tokens` | `propHandlers` |
-|---|---|---|
-| Client | ✅ | ✅ |
-| SSR / RSC | ✅ | ✅ |
-| Zero-runtime (`tastyStatic`) | ✅ at build time | not applicable |
+| Mode                       | `functions` / `units` / `states` / `handlers` / `recipes` / `tokens` | `propHandlers` |
+| -------------------------- | -------------------------------------------------------------------- | -------------- |
+| Client                     | ✅                                                                   | ✅             |
+| SSR / RSC                  | ✅                                                                   | ✅             |
+| Build-time (`tastyStatic`) | ✅ at build time                                                     | not applicable |
 
-**Zero-runtime.** The Babel plugin transforms `tastyStatic()` calls, which take styles objects — there are no props in that pipeline, so there is nothing for props middleware to run on. Components you render through `tasty()` are untouched by the plugin and keep the runtime injector, so `propHandlers` work there exactly as in any client app; their CSS simply comes from the injector rather than the extracted stylesheet. Everything else runs at build time, which is why handlers, functions, and units must be pure functions of their input.
+**Build-time extraction.** The Babel plugin transforms `tastyStatic()` calls, which take styles objects — there are no props in that pipeline, so there is nothing for props middleware to run on. Components rendered through `tasty()` are untouched by the plugin; `propHandlers` work whether those components render on the server or in the browser. Everything in the `tastyStatic()` path runs at build time, which is why handlers, functions, and units must be pure functions of their input.
 
 **Server and client must configure identically.** Class names are derived from resolved styles, so a handler or promoted prop registered on one side and not the other produces a hydration mismatch. This is the same requirement as `namePrefix` — see [SSR → Hydration mismatch warnings](ssr.md#hydration-mismatch-warnings).
 

package/docs/react-api.md

@@ -1,6 +1,8 @@
 # React API
 
-The React-specific `tasty()` component factory, component props, and style functions. All Tasty style functions — `tasty()` components, `useStyles()`, `useGlobalStyles()`, `useRawCSS()`, `useKeyframes()`, `useProperty()`, `useFontFace()`, `useCounterStyle()`, and `useFunction()` — are hook-free and compatible with React Server Components. No `'use client'` directive needed. For the shared style language (state maps, tokens, units, extending semantics), see [Style DSL](dsl.md). For global configuration, see [Configuration](configuration.md). For the broader docs map, see the [Docs Hub](README.md).
+Use `tasty()` to turn state-aware style definitions into normal React components, extend existing Tasty components, and expose typed styling APIs to consumers.
+
+All Tasty style functions — `tasty()` components, `useStyles()`, `useGlobalStyles()`, `useRawCSS()`, `useKeyframes()`, `useProperty()`, `useFontFace()`, `useCounterStyle()`, and `useFunction()` — are hook-free and compatible with React Server Components. No `'use client'` directive is needed. For state maps, tokens, units, and extension semantics, see [Style DSL](dsl.md). For global configuration, see [Configuration](configuration.md). For the broader docs map, see the [Docs Hub](README.md).
 
 > **Note:** This file was previously named `runtime.md`. All functionality documented here works in both server and client contexts — "runtime" referred to style computation during React rendering, not to client-side JavaScript.
 
@@ -58,10 +60,12 @@ const Link = tasty({
 
 const Span = tasty({
   as: 'span',
-  styles: { fontWeight: 'bold' },
+  styles: { preset: 'strong' },
 });
 
-<Link href="/blog" padding="1x">Blog</Link>;
+<Link href="/blog" padding="1x">
+  Blog
+</Link>;
 ```
 
 The wrapped component only needs to forward `className` (and ideally `style`/`ref`). Tasty-specific props (`qa`, `qaVal`, `mods`, `tokens`, `styleProps`, `modProps`, `tokenProps`) are consumed by Tasty and never leak to the DOM.
@@ -84,7 +88,7 @@ const FlexibleBox = tasty({
 
 <FlexibleBox gap="2x" align="center" fill="#surface">
   Content
-</FlexibleBox>
+</FlexibleBox>;
 ```
 
 Style props accept state maps, so responsive values work through the same API:
@@ -113,7 +117,7 @@ import { Element } from '@tenphi/tasty';
 
 <Element as="section" padding="4x" fill="#surface">
   Content
-</Element>
+</Element>;
 ```
 
 > Note: `Element` shadows the global DOM `Element` type when imported from `@tenphi/tasty`. In files that need the DOM type, alias the import: `import { Element as TastyElement } from '@tenphi/tasty'`.
@@ -156,9 +160,9 @@ Map modifier names to type descriptors for precise TypeScript types:
 ```tsx
 const Button = tasty({
   modProps: {
-    isLoading: Boolean,   // isLoading?: boolean
-    isSelected: Boolean,  // isSelected?: boolean
-    size: ['small', 'medium', 'large'] as const,  // size?: 'small' | 'medium' | 'large'
+    isLoading: Boolean, // isLoading?: boolean
+    isSelected: Boolean, // isSelected?: boolean
+    size: ['small', 'medium', 'large'] as const, // size?: 'small' | 'medium' | 'large'
   },
   styles: {
     padding: { '': '2x 4x', 'size=small': '1x 2x', 'size=large': '3x 6x' },
@@ -166,18 +170,20 @@ const Button = tasty({
   },
 });
 
-<Button isLoading size="large">Submit</Button>
+<Button isLoading size="large">
+  Submit
+</Button>;
 // Renders: <button data-is-loading="" data-size="large">Submit</button>
 ```
 
 Available type descriptors:
 
-| Descriptor | TypeScript type | Example |
-|---|---|---|
-| `Boolean` | `boolean` | `isLoading: Boolean` |
-| `String` | `string` | `label: String` |
-| `Number` | `number` | `count: Number` |
-| `['a', 'b'] as const` | `'a' \| 'b'` | `size: ['sm', 'md', 'lg'] as const` |
+| Descriptor            | TypeScript type | Example                             |
+| --------------------- | --------------- | ----------------------------------- |
+| `Boolean`             | `boolean`       | `isLoading: Boolean`                |
+| `String`              | `string`        | `label: String`                     |
+| `Number`              | `number`        | `count: Number`                     |
+| `['a', 'b'] as const` | `'a' \| 'b'`    | `size: ['sm', 'md', 'lg'] as const` |
 
 ### Merge with `mods`
 
@@ -190,11 +196,11 @@ Mod props and the `mods` object can be used together. Mod props take precedence:
 
 ### When to use `modProps` vs `mods`
 
-| Use case | Recommendation |
-|---|---|
+| Use case                                     | Recommendation                                           |
+| -------------------------------------------- | -------------------------------------------------------- |
 | Component has a fixed set of known modifiers | `modProps` — cleaner API, better TypeScript autocomplete |
-| Component needs arbitrary/dynamic modifiers | `mods` — open-ended `Record<string, ModValue>` |
-| Both fixed and dynamic | Combine: `modProps` for known keys, `mods` for ad-hoc |
+| Component needs arbitrary/dynamic modifiers  | `mods` — open-ended `Record<string, ModValue>`           |
+| Both fixed and dynamic                       | Combine: `modProps` for known keys, `mods` for ad-hoc    |
 
 For architecture guidance on when to use modifiers vs `styleProps`, see [Methodology — modProps and mods](methodology.md#modprops-and-mods).
 
@@ -240,7 +246,7 @@ const Card = tasty({
   styles: { padding: '$card-size', fill: '#card-accent' },
 });
 
-<Card size="4x" color="#purple" />
+<Card size="4x" color="#purple" />;
 ```
 
 ### Merge with `tokens`
@@ -259,11 +265,11 @@ const Bar = tasty({
 
 ### When to use `tokenProps` vs `tokens`
 
-| Use case | Recommendation |
-|---|---|
-| Component has a fixed set of known token keys | `tokenProps` — cleaner API, better TypeScript autocomplete |
-| Component needs arbitrary/dynamic token values | `tokens` — open-ended `Record<string, TokenValue>` |
-| Both fixed and dynamic | Combine: `tokenProps` for known keys, `tokens` for ad-hoc |
+| Use case                                       | Recommendation                                             |
+| ---------------------------------------------- | ---------------------------------------------------------- |
+| Component has a fixed set of known token keys  | `tokenProps` — cleaner API, better TypeScript autocomplete |
+| Component needs arbitrary/dynamic token values | `tokens` — open-ended `Record<string, TokenValue>`         |
+| Both fixed and dynamic                         | Combine: `tokenProps` for known keys, `tokens` for ad-hoc  |
 
 For architecture guidance, see [Methodology — tokenProps](methodology.md#tokenprops).
 
@@ -282,11 +288,11 @@ const Button = tasty({
   variants: {
     default: { fill: '#blue', color: '#white' },
     danger: { fill: '#red', color: '#white' },
-    outline: { fill: 'transparent', color: '#blue', border: '1bw solid #blue' },
+    outline: { fill: '#clear', color: '#blue', border: '1bw solid #blue' },
   },
 });
 
-<Button variant="danger">Delete</Button>
+<Button variant="danger">Delete</Button>;
 ```
 
 ### Extending Variants with Base State Maps
@@ -342,7 +348,7 @@ const Card = tasty({
 <Card>
   <Card.Title>Card Title</Card.Title>
   <Card.Content>Card content</Card.Content>
-</Card>
+</Card>;
 ```
 
 Each entry in `elements` can be a tag name string or a config object:
@@ -368,7 +374,7 @@ const Card = tasty({
 
 <Card>
   <div data-element="Title">Card Title</div>
-</Card>
+</Card>;
 ```
 
 ### Selector Affix (`$`)
@@ -401,7 +407,7 @@ On the client, CSS is injected synchronously into the DOM (idempotent via the in
 
 All style functions below are plain functions (not React hooks) and can be used in any environment: client components, SSR with a `ServerStyleCollector`, and React Server Components. They retain their `use` prefix for backward compatibility, but do not use any React hooks internally.
 
-In server-only contexts (Next.js RSC without `'use client'`, Astro without `client:*` directives, SSG), components that use only Tasty style functions produce zero client JavaScript. Tasty never forces the `'use client'` boundary — that decision belongs to your component when it needs React interactivity (state, effects, event handlers).
+In server-only contexts, components that use only Tasty style functions ship no Tasty styling runtime. Astro without `client:*` directives produces no client JavaScript; server-only Next.js RSC follows the same Tasty architecture, while final output depends on the application deployment. Tasty never forces the `'use client'` boundary — that decision belongs to your component when it needs React interactivity (state, effects, event handlers).
 
 ### useStyles
 
@@ -480,7 +486,7 @@ function Spinner() {
       from: { transform: 'rotate(0deg)' },
       to: { transform: 'rotate(360deg)' },
     },
-    { name: 'spin' }
+    { name: 'spin' },
   );
 
   return <div style={{ animation: `${spin} 1s linear infinite` }} />;
@@ -497,10 +503,14 @@ function Pulse({ scale }: { scale: number }) {
       '100%': { transform: `scale(${scale})` },
     }),
     [scale],
-    { name: 'pulse' }
+    { name: 'pulse' },
   );
 
-  return <div style={{ animation: `${pulse} 500ms ease-in-out alternate infinite` }} />;
+  return (
+    <div
+      style={{ animation: `${pulse} 500ms ease-in-out alternate infinite` }}
+    />
+  );
 }
 ```
 
@@ -556,8 +566,16 @@ For multiple weights/styles, pass an array:
 
 ```tsx
 useFontFace('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' },
+  {
+    src: 'url("/fonts/brand-regular.woff2") format("woff2")',
+    fontWeight: 400,
+    fontDisplay: 'swap',
+  },
+  {
+    src: 'url("/fonts/brand-bold.woff2") format("woff2")',
+    fontWeight: 700,
+    fontDisplay: 'swap',
+  },
 ]);
 ```
 
@@ -575,11 +593,14 @@ Inject a `@counter-style` rule and get back the counter style name. Permanent
 import { useCounterStyle } from '@tenphi/tasty';
 
 function EmojiList() {
-  const styleName = useCounterStyle({
-    system: 'cyclic',
-    symbols: '"👍"',
-    suffix: '" "',
-  }, { name: 'thumbs' });
+  const styleName = useCounterStyle(
+    {
+      system: 'cyclic',
+      symbols: '"👍"',
+      suffix: '" "',
+    },
+    { name: 'thumbs' },
+  );
 
   return (
     <ol style={{ listStyleType: styleName }}>
@@ -606,7 +627,7 @@ Register a CSS `@function` (custom function). Permanent — no cleanup on unmoun
 ```tsx
 import { tasty, useFunction } from '@tenphi/tasty';
 
-const Box = tasty({ styles: { marginTop: '$$negative(10px)' } });
+const Box = tasty({ styles: { margin: '$$negative(10px) top' } });
 
 function Layout() {
   useFunction('$$negative', { args: ['$value'], result: '(-1 * $value)' });
@@ -621,8 +642,8 @@ Inside a `tasty()` component you call functions with the same `$$name(...)` suga
 ```tsx
 const Box = tasty({
   styles: {
-    '@function': { '$$negative': { args: ['$value'], result: '(-1 * $value)' } },
-    marginTop: '$$negative(10px)',
+    '@function': { $$negative: { args: ['$value'], result: '(-1 * $value)' } },
+    margin: '$$negative(10px) top',
   },
 });
 ```
@@ -655,6 +676,6 @@ See the [Functions section of the DSL reference](dsl.md#functions-function) for
 - **[Methodology](methodology.md)** — Recommended patterns: root + sub-elements, styleProps, tokens, wrapping
 - **[Configuration](configuration.md)** — Tokens, recipes, custom units, style handlers, TypeScript extensions
 - **[Style Properties](styles.md)** — Complete reference for all enhanced style properties
-- **[Zero Runtime (tastyStatic)](tasty-static.md)** — Build-time static styling with Babel plugin
+- **[Build-Time Extraction (`tastyStatic`)](tasty-static.md)** — Static styling with the Babel plugin
 - **[Server-Side Rendering](ssr.md)** — SSR setup for Next.js, Astro, and generic frameworks
 - **[Debug Utilities](debug.md)** — Inspect injected CSS, cache state, and active styles at runtime