@cube-dev/ui-kit 0.0.0-canary-d03ae24 → 0.0.0-canary-1e93c5c

package/docs/glaze/api.md

@@ -39,7 +39,7 @@ const d = glaze.fromRgb(122, 77, 191);
 const e = glaze.from(a.export());
 
 // Per-theme config override:
-const rawTheme = glaze(280, 80, { lightTone: false, darkTone: false });
+const rawTheme = glaze(280, 80, { lightLightness: false, darkLightness: false });
 ```
 
 The optional `config` parameter is a `GlazeConfigOverride` — see [Per-instance config override](#per-instance-config-override).
@@ -72,15 +72,15 @@ A `GlazeTheme` exposes:
 ### `theme.colors(defs)`
 
 ```ts
-theme.colors({ surface: { tone: 97 } });
-theme.colors({ text: { tone: 30 } });
+theme.colors({ surface: { lightness: 97 } });
+theme.colors({ text: { lightness: 30 } });
 // Both 'surface' and 'text' are now defined.
 ```
 
 ### `theme.color(name) / theme.color(name, def)`
 
 ```ts
-theme.color('surface', { tone: 97, saturation: 0.75 });    // set
+theme.color('surface', { lightness: 97, saturation: 0.75 });    // set
 const def = theme.color('surface');                              // get
 ```
 
@@ -91,11 +91,11 @@ Creates a new theme inheriting all color definitions, optionally replacing the h
 ```ts
 const danger = primary.extend({
   hue: 23,
-  colors: { 'accent-fill': { tone: 48, mode: 'fixed' } },
+  colors: { 'accent-fill': { lightness: 48, mode: 'fixed' } },
 });
 
-// Inherit parent's config override and widen the dark window further:
-const highSat = base.extend({ config: { darkTone: [10, 100] } });
+// Inherit parent's config override and tighten the dark window further:
+const highSat = base.extend({ config: { darkLightness: [10, 100] } });
 ```
 
 `GlazeExtendOptions`:
@@ -115,14 +115,14 @@ Flat token map grouped by scheme variant.
 
 ```ts
 theme.tokens()
-// → { light: { surface: 'oklch(...)' }, dark: { surface: 'oklch(...)' } }
+// → { light: { surface: 'okhsl(...)' }, dark: { surface: 'okhsl(...)' } }
 ```
 
 `GlazeJsonOptions`:
 
 | Option | Default | Description |
 |---|---|---|
-| `format` | `'oklch'` | Output color format. One of `'rgb' \| 'hsl' \| 'oklch'`. `'okhsl'` and `'okhst'` throw — use `tasty()` for those. |
+| `format` | `'okhsl'` | Output color format. One of `'okhsl' \| 'rgb' \| 'hsl' \| 'oklch'`. |
 | `modes` | `{ dark: true, highContrast: false }` (or global config) | Which scheme variants to include. |
 
 ### `theme.tasty(options?)`
@@ -141,12 +141,10 @@ theme.tasty()
 
 | Option | Default | Description |
 |---|---|---|
-| `format` | `'okhsl'` | Output color format. `'okhsl'` and `'okhst'` are supported here (Tasty-only spaces). |
+| `format` | `'okhsl'` | Output color format. |
 | `modes` | global config | Which scheme variants to include. |
 | `states.dark` | `'@dark'` (or global config) | State alias for dark mode tokens. |
 | `states.highContrast` | `'@high-contrast'` (or global config) | State alias for high-contrast tokens. |
-| `splitHue` | `false` | Emit hue as a separate custom property (`$name-hue` token + `var()` in `oklch` values). Requires `format: 'oklch'` and every color to be pastel. |
-| `name` | `'theme'` | Base name for the theme-level hue var (`$theme-hue` / `--theme-hue`). Palette export auto-derives this from the theme name. |
 | `prefix` | (palette only) | See [Palette](#palette). |
 
 When both `dark` and `highContrast` modes are enabled, dark high-contrast variants are emitted under the combined key `<dark> & <highContrast>` (e.g. `'@dark & @high-contrast'`).
@@ -158,8 +156,8 @@ Per-color JSON map.
 ```ts
 theme.json()
 // → {
-//   surface: { light: 'oklch(...)', dark: 'oklch(...)' },
-//   text:    { light: 'oklch(...)', dark: 'oklch(...)' },
+//   surface: { light: 'okhsl(...)', dark: 'okhsl(...)' },
+//   text:    { light: 'okhsl(...)', dark: 'okhsl(...)' },
 // }
 ```
 
@@ -183,137 +181,11 @@ theme.css();
 
 | Option | Default | Description |
 |---|---|---|
-| `format` | `'rgb'` | Output color format. `'okhsl'` and `'okhst'` throw — use `tasty()` for those. |
+| `format` | `'rgb'` | Output color format. |
 | `suffix` | `'-color'` | Suffix appended to each CSS property name. Pass `''` for bare property names. |
-| `splitHue` | `false` | Emit hue as a separate `--*-hue` custom property referenced via `var()` in `oklch` color values. Requires `format: 'oklch'` and every color to be pastel. Shadow/mix colors stay inline (blended hue; they do not follow `--hue` rotation). |
-| `name` | `'theme'` | Base name for the theme-level hue var (`--theme-hue`). Palette export auto-derives this from the theme name. |
 
 `GlazeCssResult` always contains all four keys (`light`, `dark`, `lightContrast`, `darkContrast`); empty if no colors are defined for that variant.
 
-### `theme.dtcg(options?)`
-
-W3C [Design Tokens Format Module (2025.10)](https://www.designtokens.org/) documents — the vendor-neutral JSON format consumed by Figma, Tokens Studio, Style Dictionary v4+, Terrazzo, Penpot, and every DTCG-compatible tool. Returns one spec-conformant token tree per scheme variant.
-
-```ts
-theme.dtcg()
-// → {
-//   light: {
-//     surface: {
-//       $type: 'color',
-//       $value: { colorSpace: 'srgb', components: [0.96, 0.94, 0.98], hex: '#f5f0fa' },
-//     },
-//   },
-//   dark: {
-//     surface: {
-//       $type: 'color',
-//       $value: { colorSpace: 'srgb', components: [0.16, 0.14, 0.2], hex: '#292333' },
-//     },
-//   },
-// }
-```
-
-Write each document to its own `.tokens.json` file — one file per scheme is the most tool-compatible convention (one per Style Dictionary theme / Tokens Studio set / Figma variable mode).
-
-`GlazeDtcgOptions`:
-
-| Option | Default | Description |
-|---|---|---|
-| `colorSpace` | `'srgb'` | Color space for `$value`. `'srgb'` emits gamma sRGB `components` (0–1) plus a `hex` hint — universally understood. `'oklch'` emits `[L, C, H]` components with no hex — Glaze-native, wide-gamut. |
-| `modes` | global config | Which scheme variants to include. `light` is always present. |
-
-`alpha` is included on `$value` only when the color's opacity is below 1. `$type` is always `'color'`.
-
-### `theme.dtcgResolver(options?)`
-
-A single W3C [DTCG Resolver-Module](https://www.designtokens.org/) document describing **every scheme variant in one file** — an alternative to `dtcg()`'s per-scheme files for tools that resolve sets + modifiers (e.g. Dispersa). The light document becomes `sets.base.sources[0]` (the default context); each other variant becomes a context override on a single `scheme` modifier.
-
-```ts
-theme.dtcgResolver({ modes: { highContrast: true } })
-// → {
-//   version: '2025.10',
-//   sets: {
-//     base: {
-//       sources: [
-//         {
-//           surface: {
-//             $type: 'color',
-//             $value: { colorSpace: 'srgb', components: [0.96, 0.94, 0.98], hex: '#f5f0fa' },
-//           },
-//         },
-//       ],
-//     },
-//   },
-//   modifiers: {
-//     scheme: {
-//       default: 'light',
-//       contexts: {
-//         light: [],
-//         dark: [
-//           {
-//             surface: {
-//               $type: 'color',
-//               $value: { colorSpace: 'srgb', components: [0.16, 0.14, 0.2], hex: '#292333' },
-//             },
-//           },
-//         ],
-//         lightContrast: [ /* … */ ],
-//         darkContrast: [ /* … */ ],
-//       },
-//     },
-//   },
-//   resolutionOrder: [
-//     { $ref: '#/sets/base' },
-//     { $ref: '#/modifiers/scheme' },
-//   ],
-// }
-```
-
-**Why one modifier with four contexts.** Glaze resolves `darkContrast` independently — it is not `dark` + `lightContrast` layered. The resolver model composes modifiers additively (last in `resolutionOrder` wins on conflict), so two independent modifiers (`scheme` × `contrast`) would produce wrong values for the dark + high-contrast permutation. One `scheme` modifier with a context per variant keeps every resolved value exact. Choose `dtcgResolver()` when you want single-file theming and feed it to a resolver tool; choose `dtcg()` for maximum per-file tool compatibility.
-
-`GlazeDtcgResolverOptions` (extends `GlazeDtcgOptions`, so `modes` and `colorSpace` pass through):
-
-| Option | Default | Description |
-|---|---|---|
-| `colorSpace` | `'srgb'` | Same as `dtcg()` — flows through to every source and context. |
-| `modes` | global config | Which scheme variants to emit as contexts. `light` is always present (the default); absent variants are omitted. |
-| `setName` | `'base'` | Name of the single set holding the default (light) token tree. |
-| `modifierName` | `'scheme'` | Name of the modifier describing the scheme axis. |
-| `contextNames` | identity | Override the four context names (`light` / `dark` / `lightContrast` / `darkContrast`) — e.g. `{ dark: 'night' }`. |
-| `version` | `'2025.10'` | Resolver document version. |
-
-### `theme.tailwind(options?)`
-
-A Tailwind CSS v4 `@theme` block (light baseline) plus dark / high-contrast overrides under configurable selectors. Returns a single ready-to-paste CSS string. The `--color-*` namespace auto-generates `bg-*` / `text-*` / `border-*` utilities.
-
-```css
-@theme {
-  --color-surface: oklch(0.96 0.01 280);
-  --color-text: oklch(0.3 0.05 280);
-}
-.dark {
-  --color-surface: oklch(0.16 0.01 280);
-  --color-text: oklch(0.85 0.05 280);
-}
-.high-contrast {
-  --color-surface: oklch(0.98 0.01 280);
-  --color-text: oklch(0.1 0.05 280);
-}
-.dark.high-contrast {
-  --color-surface: oklch(0.05 0.01 280);
-  --color-text: oklch(0.95 0.05 280);
-}
-```
-
-`GlazeTailwindOptions`:
-
-| Option | Default | Description |
-|---|---|---|
-| `format` | `'oklch'` | Output color format for the values. |
-| `namespace` | `'color-'` | CSS custom property namespace, forming `--<namespace><name>` (e.g. `--color-surface`). Named `namespace` to avoid clashing with the palette theme-prefix option. |
-| `darkSelector` | `'.dark'` | Selector wrapping the dark overrides. Pass an at-rule like `'@media (prefers-color-scheme: dark)'` to drive dark mode from the OS preference (it nests `:root` automatically). |
-| `highContrastSelector` | `'.high-contrast'` | Selector wrapping the light high-contrast overrides. The combined dark + high-contrast block uses `${darkSelector}${highContrastSelector}` (e.g. `.dark.high-contrast`). |
-| `modes` | global config | Which scheme variants to include. The `@theme` block (light) is always emitted when colors exist. |
-
 ### `theme.export()`
 
 ```ts
@@ -339,182 +211,61 @@ type ColorDef = RegularColorDef | ShadowColorDef | MixColorDef;
 
 | Field | Type | Description |
 |---|---|---|
-| `tone` | `HCPair<ToneValue>` | Number = absolute (0–100, contrast-uniform). `'+N'`/`'-N'` = relative to base's tone (requires `base`). `'max'`/`'min'` = forced to the scheme's tone extreme (no `base`). Optional HC pair `[normal, hc]`. |
+| `lightness` | `HCPair<number \| RelativeValue>` | Number = absolute (0–100). String (`'+N'`/`'-N'`) = relative to base's lightness (requires `base`). Optional HC pair `[normal, hc]`. |
 | `saturation` | `number` | Saturation factor applied to the seed saturation (0–1). Default: `1`. |
 | `hue` | `number \| RelativeValue` | Number = absolute (0–360). String (`'+N'`/`'-N'`) = relative to the **theme seed hue** (never to a base color). |
 | `base` | `string` | Name of another color in the same theme — makes this a *dependent* color. |
-| `contrast` | `HCPair<ContrastSpec>` | Contrast floor against `base`. Requires `base`. See [`contrast`](#contrast-floor). |
+| `contrast` | `HCPair<MinContrast>` | WCAG contrast floor against `base`. Requires `base`. |
 | `mode` | `'auto' \| 'fixed' \| 'static'` | Adaptation mode. Default: `'auto'`. See [Adaptation modes](#adaptation-modes). |
-| `autoFlip` | `boolean` | Flip out-of-bounds results (relative `tone` overshoot / unmet `contrast`) to the opposite side instead of clamping. Default: the global `autoFlip` (`true`). See [`autoFlip`](#autoflip). |
 | `opacity` | `number` | Fixed alpha 0–1. Output includes alpha in the CSS value. Combining with `contrast` is not recommended (a `console.warn` is emitted). |
-| `pastel` | `boolean` | Per-color override for the hue-independent "safe" chroma limit used in OKHSL↔sRGB conversions (luminance, contrast solving, output formatting). Falls through to the global / per-theme `pastel` config when omitted. Default: unset. See [Per-color `pastel`](#per-color-pastel). |
-| `role` | `RoleInput` | Semantic role against `base` (`'text'` / `'surface'` / `'border'` or an alias). Fixes APCA contrast polarity. Resolved via: explicit `role` → name inference → opposite of the base's role → `'text'`. See [Roles](#roles). |
 | `inherit` | `boolean` | Whether this color is inherited by child themes via `extend()`. Default: `true`. Set to `false` to make the color local to the current theme. |
 
-#### Tone values
-
-`tone` (0–100) replaces OKHSL lightness with a contrast-uniform axis — equal tone steps give equal WCAG contrast. See [`docs/okhst.md`](okhst.md) for the math. (To port old `lightness` values, see [migration.md](migration.md).)
+#### Lightness values
 
 | Form | Example | Meaning |
 |---|---|---|
-| Number (absolute) | `tone: 45` | Absolute tone 0–100. |
-| String (relative) | `tone: '-52'` | Relative to base color's tone (requires `base`). |
-| Extreme | `tone: 'max'` / `'min'` | Force to the scheme's highest (`'max'` = 100) or lowest (`'min'` = 0) tone. No `base` needed. |
-| HC pair | `tone: ['-7', '-20']` | `[normal, high-contrast]`. A single value applies to both. |
-
-**Absolute tone** on a dependent color (`base` set) positions the color independently. In dark mode it is tone-mapped (inverted + windowed) on its own. The `contrast` solver acts as a safety net.
-
-**Relative tone** applies a signed delta to the base color's resolved tone. Because tone is contrast-uniform, a fixed delta yields a fixed contrast step. In dark mode with `mode: 'auto'`, the offset is anchored to the base's per-scheme tone. If `base + delta` falls outside `[0, 100]`, the result is clamped to the boundary, or — with `autoFlip` (default on) — mirrored to the other side of the base.
+| Number (absolute) | `lightness: 45` | Absolute lightness 0–100. |
+| String (relative) | `lightness: '-52'` | Relative to base color's lightness (requires `base`). |
+| HC pair | `lightness: ['-7', '-20']` | `[normal, high-contrast]`. A single value applies to both. |
 
-**Extreme tone** (`'max'` / `'min'`) forces the color to the scheme's tone extreme without a contrast hack or a magic number. `'max'` resolves to author tone 100 and `'min'` to 0; both flow through scheme mapping like an absolute tone, so under `mode: 'auto'` they invert in dark (`'max'` is lightest in light, darkest in dark). Use `mode: 'static'` to pin the same extreme across schemes, or `mode: 'fixed'` to keep the same end without inverting. No `base` required.
+**Absolute lightness** on a dependent color (`base` set) positions the color independently. In dark mode it is dark-mapped on its own. The `contrast` solver acts as a safety net.
 
-A dependent color with `base` but no `tone` inherits the base's tone (equivalent to a delta of 0).
+**Relative lightness** applies a signed delta to the base color's resolved lightness. In dark mode with `mode: 'auto'`, the sign flips automatically so a `'-52'` light-mode offset becomes a `+52` dark-mode offset.
 
-#### `autoFlip`
+A dependent color with `base` but no `lightness` inherits the base's lightness (equivalent to a delta of 0).
 
-`autoFlip` governs what happens when a result would fall outside its valid range:
-
-- **Relative `tone` overshoot:** when `base ± delta` exceeds `[0, 100]`, `autoFlip` mirrors the delta to the other side of the base (e.g. `'+30'` becomes `'-30'`) instead of clamping to the boundary.
-- **`contrast` direction:** when the requested tone direction can't meet the floor, `autoFlip` lets the solver try the opposite side (the same behavior as the global `autoFlip`).
-
-`autoFlip` defaults to the global `autoFlip` (`true`). Set `autoFlip: false` on a color to clamp instead of mirror — useful when you want a relative offset to stay on the authored side of the base, or to keep an unmet contrast pinned to one direction's extreme.
-
-#### `contrast` (floor)
+#### `contrast` (WCAG floor)
 
 ```ts
-type ContrastPreset = 'AA' | 'AAA' | 'AA-large' | 'AAA-large';
-type ContrastSpec =
-  | number                                  // bare WCAG ratio
-  | ContrastPreset                          // named WCAG preset
-  | { wcag: HCPair<number | ContrastPreset> }
-  | { apca: HCPair<number> };               // APCA Lc target
+type MinContrast = number | 'AA' | 'AAA' | 'AA-large' | 'AAA-large';
 ```
 
-| Preset | WCAG ratio |
+| Preset | Ratio |
 |---|---|
 | `'AA-large'` | 3 |
 | `'AA'` | 4.5 |
 | `'AAA-large'` | 4.5 |
 | `'AAA'` | 7 |
 
-A bare number or preset means **WCAG**. Use `{ wcag }` / `{ apca }` to pick the metric explicitly. The `[normal, highContrast]` pair may live at the outer level (`[4.5, 7]`, `[{ wcag: 4.5 }, { wcag: 7 }]`) or inside the metric (`{ wcag: [4.5, 7] }`, `{ apca: [45, 60] }`).
-
-```ts
-contrast: 4.5                  // WCAG 4.5
-contrast: 'AAA'                // WCAG 7
-contrast: { wcag: 6 }          // WCAG 6
-contrast: { wcag: [4.5, 7] }   // WCAG 4.5 normal / 7 high-contrast (explicit)
-contrast: { apca: 60 }         // APCA Lc 60 normal / 75 high-contrast (auto)
-contrast: { apca: [45, 60] }   // APCA Lc 45 normal / 60 high-contrast (explicit)
-contrast: { apca: 'content' }  // APCA preset -> Lc 60 normal / 75 high-contrast (auto)
-contrast: { apca: ['content', 'body'] } // Lc 60 normal / 75 high-contrast (explicit)
-```
-
-**WCAG HC auto-promotion:** a bare WCAG preset (no `[normal, hc]` pair at either
-the outer `contrast` or inner `wcag` level) is automatically promoted to its
-spec-defined "Enhanced" successor in high-contrast mode — `AA` → `AAA` (4.5 → 7)
-and `AA-large` → `AAA-large` (3 → 4.5), per WCAG SC 1.4.3 → 1.4.6. `AAA` and
-`AAA-large` are already the top WCAG tier and are left unchanged; bare numeric
-targets have no successor tier and are also left unchanged. An explicit HC value
-via either pair overrides and skips the promotion.
-
-**APCA Enhanced Level (HC auto-boost):** a bare APCA scalar (no `[normal, hc]`
-pair at either the outer `contrast` or inner `apca` level) is automatically
-boosted by **+15 Lc** in high-contrast mode, the APCA analog of WCAG's
-AAA-over-AA step. On by default; an explicit HC value via either pair
-overrides it and skips the boost. The enhanced target is clamped to 106 Lc.
-For large/bold text (where APCA caps contrast at Lc 90 to avoid glare), pass
-an explicit HC pair to hold that ceiling — see
-[`docs/okhst.md`](okhst.md) §Enhanced Level.
-
-APCA preset keywords (Bronze Simple Mode conformance levels, role-independent):
-`'preferred'` (Lc 90), `'body'` (75), `'content'` (60, ~AA), `'large'` (45, ~3:1),
-`'non-text'` (30), `'min'` (15, point of invisibility). See
-[`docs/okhst.md`](okhst.md) §APCA.
+You can also pass any numeric ratio directly (e.g., `contrast: 4.5`, `contrast: 11`). The constraint is applied independently for each scheme — if the `lightness` already satisfies the floor it's kept, otherwise the solver adjusts lightness until the target is met.
 
-The floor is applied independently per scheme — if the `tone` already satisfies it the tone is kept, otherwise the solver searches in tone (contrast-uniform → a closed-form WCAG seed and fast convergence) until the target is met.
+By default, `autoFlip` lets the solver cross to the opposite side of the base color when the requested lightness direction cannot satisfy contrast. Set `glaze.configure({ autoFlip: false })` to keep strict directionality: unmet colors pin to that direction's 0 or 100 lightness extreme instead of falling back to the original requested value.
 
-By default, the solver crosses to the opposite side of the base color when the requested tone direction cannot satisfy the floor. This is controlled per-color by [`autoFlip`](#autoflip) (which defaults to the global `autoFlip`). Set `glaze.configure({ autoFlip: false })` — or `autoFlip: false` on a single color — to keep strict directionality: unmet colors pin to that direction's 0 or 100 tone extreme instead of falling back to the original requested value.
-
-**Full tone spectrum in HC mode:** in high-contrast variants the `lightTone` and `darkTone` window constraints are bypassed entirely (the window is forced to `[0, 100]`). Colors can reach the full range, maximizing perceivable contrast.
-
-**Chromatic drift (verification):** tone is contrast-uniform for grays. A chromatic swatch at a given tone shares its OKHSL lightness with the equivalent gray but drifts in real luminance, so a contrast-floored color may land slightly under its gray-tone expectation. Glaze measures the resolved result against the base and emits a deduped advisory `console.warn` when it drifts below the target. See [`docs/okhst.md`](okhst.md) §Verification.
+**Full lightness spectrum in HC mode:** in high-contrast variants the `lightLightness` and `darkLightness` window constraints are bypassed entirely. Colors can reach the full 0–100 range, maximizing perceivable contrast.
 
 #### Per-color hue override
 
 ```ts
 const theme = glaze(280, 80);
 theme.colors({
-  surface:     { tone: 97 },
-  gradientEnd: { tone: 90, hue: '+20' },   // 280 + 20 = 300
-  warning:     { tone: 60, hue: 40 },      // absolute
+  surface:     { lightness: 97 },
+  gradientEnd: { lightness: 90, hue: '+20' },   // 280 + 20 = 300
+  warning:     { lightness: 60, hue: 40 },      // absolute
 });
 ```
 
 Relative hue is always relative to the **theme seed hue**, not to a base color.
 
-#### Per-color `pastel`
-
-`pastel: true` on a single color def overrides the global / per-theme `pastel` config for that color only. It toggles the hue-independent "safe" chroma limit used in every OKHSL↔sRGB conversion that touches this color: luminance calculations during contrast solving, gamut clamping during sRGB blend / mix edges, and output formatting. The effective flag is carried on the resolved variant (`ResolvedColorVariant.pastel`) so formatting matches the gamut mapping applied during resolution.
-
-```ts
-const theme = glaze(280, 80);
-theme.colors({
-  plain: { tone: 50, saturation: 1 },
-  soft:  { tone: 50, saturation: 1, pastel: true },
-});
-// theme.resolve().get('soft')!.light.pastel === true
-// theme.css().light contains different rgb() triples for `--plain` and `--soft`
-```
-
-Omit the field to inherit the global / per-theme `pastel` config — useful for keeping the default behavior while opting a single accent into the pastel gamut.
-
-The flag is part of the def object, so `extend()` copies it through to child themes alongside the rest of the def. Override it again on the child to flip a single color back:
-
-```ts
-const parent = glaze(280, 80);
-parent.colors({ soft: { tone: 50, saturation: 1, pastel: true } });
-
-const child = parent.extend({
-  colors: { soft: { tone: 50, saturation: 1, pastel: false } },
-});
-// child.resolve().get('soft')!.light.pastel === false
-```
-
-> **Note:** Per-color `pastel` is also supported on `ShadowColorDef` and `MixColorDef` (see the tables above). For shadows the math itself happens in OKHSL space, so the flag mainly controls the gamut-mapped output formatting and any luminance verification for that variant.
->
-> Standalone `glaze.color()` tokens accept the same `pastel` field on both the structured (`GlazeColorInput`) and value-shorthand (`GlazeColorOverrides`) forms, and it survives the `export()` / `glaze.colorFrom()` round-trip.
-
-#### Roles
-
-A color's `role` describes how it is used against its `base` and fixes **APCA contrast polarity** — which side is the foreground vs the background. APCA is asymmetric (`|apca(a,b)| ≠ |apca(b,a)|`), so the role picks the correct argument order; WCAG is symmetric and unaffected.
-
-| Role | Polarity | Use | Aliases (name inference) |
-|---|---|---|---|
-| `'text'` | fg | Text / icons / foreground content | `text`, `fg`, `foreground`, `content`, `ink`, `label`, `stroke` |
-| `'border'` | fg | Non-text spot elements (borders, dividers, outlines) | `border`, `divider`, `outline`, `separator`, `hairline`, `rule` |
-| `'surface'` | bg | Backgrounds / fills | `surface`, `bg`, `background`, `fill`, `canvas`, `paper`, `layer` |
-
-Resolution chain (per color):
-
-1. Explicit `role` (normalized from an alias) wins.
-2. Else, when `inferRole` is enabled (default), infer from the color name — the **last** recognized token wins (`button-text` → `text`, `input-bg` → `surface`, `card-outline` → `border`).
-3. Else, the opposite of the base's role (a `surface` base ⇒ this is `text`).
-4. Else, `'text'` (foreground) — i.e. the base is treated as the background.
-
-```ts
-const theme = glaze(280, 60);
-theme.colors({
-  surface: { tone: 90 },
-  text:    { base: 'surface', contrast: { apca: 'content' } }, // inferred text
-  border:  { base: 'surface', tone: '-10' },                   // inferred border
-});
-// role fixes APCA polarity; set `pastel: true` explicitly if a border
-// needs the hue-independent safe chroma limit.
-```
-
-Disable name inference with `glaze.configure({ inferRole: false })` (the base-opposite and foreground-default fallbacks still apply).
-
 ### `ShadowColorDef`
 
 | Field | Type | Description |
@@ -524,7 +275,6 @@ Disable name inference with `glaze.configure({ inferRole: false })` (the base-op
 | `fg` | `string` | Optional foreground color name for tinting and intensity modulation. Must reference a non-shadow color. Omit for an achromatic shadow at full user-specified intensity. |
 | `intensity` | `HCPair<number>` | Shadow intensity, 0–100. Supports HC pairs. |
 | `tuning` | `ShadowTuning` | Per-color tuning overrides. Merged field-by-field with the global `shadowTuning`. |
-| `pastel` | `boolean` | Per-color `pastel` override. See [Per-color `pastel`](#per-color-pastel). |
 | `inherit` | `boolean` | Inheritance flag, default `true`. |
 
 See [Shadows](#shadows) below for the algorithm and tuning details.
@@ -539,9 +289,7 @@ See [Shadows](#shadows) below for the algorithm and tuning details.
 | `value` | `HCPair<number>` | Mix ratio 0–100 (0 = pure base, 100 = pure target). In `'transparent'` blend, this becomes the target's opacity. Supports HC pairs. |
 | `blend` | `'opaque' \| 'transparent'` | Default `'opaque'`. |
 | `space` | `'okhsl' \| 'srgb'` | Interpolation space for opaque blending. Default `'okhsl'`. Ignored for `'transparent'` (always composites in linear sRGB). |
-| `contrast` | `HCPair<ContrastSpec>` | Optional contrast floor against `base` (WCAG or APCA — see [`contrast`](#contrast-floor)). The solver adjusts the mix ratio (opaque) or opacity (transparent). |
-| `pastel` | `boolean` | Per-color `pastel` override. See [Per-color `pastel`](#per-color-pastel). |
-| `role` | `RoleInput` | Semantic role of the mixed result against `base`. Same semantics as `RegularColorDef.role` (see [Roles](#roles)). |
+| `contrast` | `HCPair<MinContrast>` | Optional WCAG floor against `base`. The solver adjusts the mix ratio (opaque) or opacity (transparent). |
 | `inherit` | `boolean` | Inheritance flag, default `true`. |
 
 See [Mix colors](#mix-colors) below.
@@ -564,10 +312,10 @@ glaze.color(color: GlazeFromInput | GlazeColorInput | GlazeColorValue, config?:
 
 | Shape | Example | Notes |
 |---|---|---|
-| **Bare string** | `'#26fcb2'` | Hex or CSS color function (`rgb()`, `hsl()`, `okhsl()`, `okhst()`, `oklch()`). |
-| **Value object** | `{ h: 152, s: 0.95, l: 0.74 }` | OKHSL, OKHST (`{ h, s, t }`), `{ r, g, b }` (sRGB 0–255), or `{ l, c, h }` (OKLCh). |
+| **Bare string** | `'#26fcb2'` | Hex or CSS color function (`rgb()`, `hsl()`, `okhsl()`, `oklch()`). |
+| **Value object** | `{ h: 152, s: 0.95, l: 0.74 }` | OKHSL, `{ r, g, b }` (sRGB 0–255), or `{ l, c, h }` (OKLCh). |
 | **`{ from, ...overrides }`** | `{ from: '#1a1a2e', base: bg, contrast: 'AA' }` | Value + color overrides in one object. |
-| **Structured** | `{ hue: 152, saturation: 95, tone: 74 }` | Full theme-style token (hue/saturation in 0–100, tone in 0–100). |
+| **Structured** | `{ hue: 152, saturation: 95, lightness: 74 }` | Full theme-style token (hue/saturation/lightness all in 0–100). |
 
 `GlazeColorValue` (bare string or value-object forms) accepts:
 
@@ -577,28 +325,23 @@ glaze.color(color: GlazeFromInput | GlazeColorInput | GlazeColorValue, config?:
 | `rgb()` | `'rgb(38 252 178)'`, `'rgb(38 252 178 / 0.8)'` | Modern space syntax. Alpha dropped with warning. |
 | `hsl()` | `'hsl(152 97% 57%)'` | Modern space syntax. Alpha dropped with warning. |
 | `okhsl()` | `'okhsl(152 95% 74%)'` | Glaze's own emit format. Alpha dropped with warning. |
-| `okhst()` | `'okhst(152 95% 70%)'` | OKHST tone input (third value is tone 0–100). **Input only** — never emitted. Alpha dropped with warning. |
 | `oklch()` | `'oklch(0.85 0.18 152)'` | Glaze's own emit format. Alpha dropped with warning. |
-| `OkhslColor` object | `{ h: 152, s: 0.95, l: 0.74 }` | OKHSL shape (h: 0–360, s/l: 0–1). Passing 0–100 for `s`/`l` throws with a hint to use the structured form. |
-| `OkhstColor` object | `{ h: 152, s: 0.95, t: 0.70 }` | OKHST shape (h: 0–360, s/t: 0–1). The `t` key disambiguates it from `{ h, s, l }`. **Input only.** |
+| `OkhslColor` object | `{ h: 152, s: 0.95, l: 0.74 }` | Glaze's native shape (h: 0–360, s/l: 0–1). Passing 0–100 for `s`/`l` throws with a hint to use the structured form. |
 | `RgbColor` object | `{ r: 38, g: 252, b: 178 }` | sRGB 0–255. RGB tuple `[r, g, b]` is not supported — use this object form. |
 | `OklchColor` object | `{ l: 0.85, c: 0.18, h: 152 }` | OKLCh (L/C: 0–1, H: degrees), same semantics as `oklch()` strings. |
 
-`GlazeColorInput` (structured form) is `{ hue, saturation, tone, ... }`:
+`GlazeColorInput` (structured form) is `{ hue, saturation, lightness, ... }`:
 
 | Field | Type | Description |
 |---|---|---|
 | `hue` | `number` | 0–360. |
 | `saturation` | `number` | 0–100. |
-| `tone` | `HCPair<number \| ExtremeValue>` | 0–100 (contrast-uniform) or `'max'`/`'min'`, optional HC pair. |
+| `lightness` | `HCPair<number>` | 0–100, optional HC pair. |
 | `saturationFactor` | `number` | Multiplier on the seed (0–1). Default: `1`. |
 | `mode` | `AdaptationMode` | Default: `'auto'`. |
-| `autoFlip` | `boolean` | Flip out-of-bounds results instead of clamping. Default: global `autoFlip`. |
 | `opacity` | `number` | Fixed alpha 0–1. |
 | `base` | `GlazeColorToken \| GlazeColorValue` | Optional dependency. See [Pairing colors](#pairing-colors). |
-| `contrast` | `HCPair<ContrastSpec>` | Contrast floor against `base` (WCAG or APCA). Without `base`, anchored to the literal seed. |
-| `pastel` | `boolean` | Per-color `pastel` override. Falls through to the global / per-theme `pastel` config when omitted. See [Per-color `pastel`](#per-color-pastel). |
-| `role` | `RoleInput` | Semantic role against `base` / the seed (see [Roles](#roles)). Fixes APCA polarity. |
+| `contrast` | `HCPair<MinContrast>` | WCAG floor against `base`. Without `base`, anchored to the literal seed. |
 | `name` | `string` | Debug label for warnings; doesn't change output keys. Reserved names (`'value'`, `'seed'`, `'externalBase'`) are rejected. |
 
 `GlazeFromInput` (from form) is `{ from: GlazeColorValue, ...colorOverrides }`:
@@ -608,15 +351,12 @@ glaze.color(color: GlazeFromInput | GlazeColorInput | GlazeColorValue, config?:
 | `from` | **Required.** The source color value — same forms as `GlazeColorValue`. |
 | `hue` | Number (absolute 0–360) or `'+N'`/`'-N'` (relative to seed, never to `base`). |
 | `saturation` | Override seed saturation (0–100). |
-| `tone` | Number (absolute 0–100), `'+N'`/`'-N'`, or `'max'`/`'min'`. Without `base`, relative anchors to the seed; with `base`, anchors to `base`'s tone per scheme. |
+| `lightness` | Number (absolute 0–100) or `'+N'`/`'-N'`. Without `base`, relative anchors to the seed; with `base`, anchors to `base`'s lightness per scheme. |
 | `saturationFactor` | Multiplier on the seed (0–1). |
 | `mode` | `'auto'` (default) / `'fixed'` / `'static'`. |
-| `autoFlip` | Flip out-of-bounds results instead of clamping. Default: global `autoFlip`. |
-| `contrast` | Contrast floor (WCAG or APCA). Without `base`, anchored to the literal seed; with `base`, solved per scheme. |
+| `contrast` | WCAG floor. Without `base`, anchored to the literal seed; with `base`, solved per scheme. |
 | `base` | `GlazeColorToken` or raw `GlazeColorValue`. See [Pairing colors](#pairing-colors). |
 | `opacity` | Fixed alpha 0–1. Combining with `contrast` is not recommended — `console.warn` is emitted. |
-| `pastel` | Per-color `pastel` override. Falls through to the global / per-theme `pastel` config when omitted. See [Per-color `pastel`](#per-color-pastel). |
-| `role` | Semantic role against `base` / the seed (see [Roles](#roles)). Fixes APCA polarity. |
 | `name` | Debug label only — surfaces in warnings/errors. Does not change output keys. |
 
 Named CSS colors (`'red'`, `'blueviolet'`) are not supported.
@@ -626,10 +366,10 @@ Named CSS colors (`'red'`, `'blueviolet'`) are not supported.
 Every input form defaults to `mode: 'auto'` so the resolved token adapts between light and dark like an ordinary theme color. The config snapshot taken at create time differs by input form:
 
 - **Value-shorthand** (bare strings, value objects, and `{ from, ...overrides }`):
-  - Light variant preserves the input tone exactly (`lightTone: false`).
-  - All other config fields (`darkTone`, `darkDesaturation`, `autoFlip`) snapshot from `globalConfig` at create time.
-- **Structured input** (`{ hue, saturation, tone, ... }`):
-  - Both tone windows snapshot from `globalConfig` at create time (same as a theme color).
+  - Light variant preserves the input lightness exactly (`lightLightness: false`).
+  - All other config fields (`darkLightness`, `darkDesaturation`, `darkCurve`, `autoFlip`) snapshot from `globalConfig` at create time.
+- **Structured input** (`{ hue, saturation, lightness, ... }`):
+  - Both lightness windows snapshot from `globalConfig` at create time (same as a theme color).
 - All fields are **snapshotted at color-creation time** — later `glaze.configure()` calls don't retroactively change existing tokens.
 
 ```ts
@@ -639,14 +379,11 @@ glaze.color('#26fcb2')
 // Value-object — same behavior
 glaze.color({ h: 152, s: 0.95, l: 0.74 })
 
-// OKHST value-object — tone axis
-glaze.color({ h: 152, s: 0.95, t: 0.70 })
-
 // From form — value + color overrides
 glaze.color({ from: '#1a1a2e', hue: '+20', contrast: 'AA' })
 
-// Structured form — explicit hue/saturation/tone (0–100)
-glaze.color({ hue: 152, saturation: 95, tone: 74 })
+// Structured form — explicit hue/saturation/lightness (0–100)
+glaze.color({ hue: 152, saturation: 95, lightness: 74 })
 ```
 
 ### Token methods
@@ -657,45 +394,43 @@ A `GlazeColorToken` exposes:
 |---|---|
 | `token.resolve()` | Resolve as a `ResolvedColor` (light/dark/lightContrast/darkContrast variants). |
 | `token.token(options?)` | Flat token map (no color-name key). Options: `format`, `modes`, `states`. |
-| `token.tasty(options?)` | [Tasty](https://tasty.style) state map (no color-name key). Same options as `token.token`. |
+| `token.tasty(options?)` | Tasty state map (no color-name key). Same options as `token.token`. |
 | `token.json(options?)` | JSON map (no color-name key). Options: `format`, `modes`. |
 | `token.css({ name, format?, suffix? })` | CSS custom property declarations grouped by scheme variant. `name` is **required** and becomes the variable identifier (`'brand'` → `--brand-color`). Defaults: `format: 'rgb'`, `suffix: '-color'` (matches `theme.css`). |
-| `token.dtcg(options?)` | DTCG color tokens, one per scheme variant (no color-name key). Each entry is a full `{ $type: 'color', $value }` token. Options: `colorSpace` (`'srgb'` \| `'oklch'`), `modes`. |
-| `token.dtcgResolver({ name, ... })` | A single DTCG Resolver-Module document for this color, keyed by `name` across all scheme variants. `name` is **required**. Same options as `theme.dtcgResolver()` plus `name`. |
-| `token.tailwind({ name, ... })` | Tailwind v4 `@theme` block + dark / high-contrast overrides for this color. `name` is **required** (forms `--color-<name>`). Same options as `theme.tailwind()` plus `name`. |
 | `token.export()` | JSON-safe snapshot — pass to `glaze.colorFrom(...)` to rehydrate. |
 
 ### Per-instance config override
 
-The optional `config` second argument (`GlazeConfigOverride`) overrides the resolve-relevant global config fields for a single token or theme. Fields that are omitted fall through to the live global config at create time (and are snapshotted). A tone window can be `[lo, hi]`, `{ lo, hi, eps }`, or `false` (disable clamping).
+The optional `config` second argument (`GlazeConfigOverride`) overrides the resolve-relevant global config fields for a single token or theme. Fields that are omitted fall through to the live global config at create time (and are snapshotted). Pass `false` for a lightness window to disable clamping entirely — equivalent to `[0, 100]`.
 
 `GlazeConfigOverride`:
 
 | Field | Default (from global) | Description |
 |---|---|---|
-| `lightTone` | `[10, 100]` | Light tone window: `[lo, hi]`, `{ lo, hi, eps }`, or `false` (disable clamping). |
-| `darkTone` | `[15, 95]` | Dark tone window: `[lo, hi]`, `{ lo, hi, eps }`, or `false` (disable clamping). |
+| `lightLightness` | `[10, 100]` | Light window `[lo, hi]` or `false` (disable clamping = `[0, 100]`). |
+| `darkLightness` | `[15, 95]` | Dark window `[lo, hi]` or `false` (disable clamping). |
 | `darkDesaturation` | `0.1` | Saturation reduction in dark scheme (0–1). |
-| `autoFlip` | `true` | Default for each color's `autoFlip`: when solving `contrast` (or applying a relative `tone` that overshoots), allow crossing to the opposite side instead of clamping. |
+| `darkCurve` | `0.5` | Möbius beta for dark `auto`-inversion (0–1). Accepts `[normal, hc]` pair. |
+| `autoFlip` | `true` | When solving `contrast`, allow the solver to switch lightness direction if the requested side can't meet the target. |
 | `shadowTuning` | `undefined` | Default shadow tuning (meaningful for themes; harmless on color tokens). |
 
 Config overrides apply to both `glaze.color()` tokens and `glaze()` themes:
 
 ```ts
-// Standalone color — preserve raw tone in both schemes
-glaze.color('#26fcb2', { darkTone: false })
+// Standalone color — preserve raw lightness in both schemes
+glaze.color('#26fcb2', { darkLightness: false })
 
 // Restore the #000 → white dark flip (full dark range)
 glaze.color('#000000', {
-  lightTone: false,
-  darkTone: [15, 100],
+  lightLightness: false,
+  darkLightness: [15, 100],
 })
 
 // Structured form with config override
-glaze.color({ hue: 152, saturation: 95, tone: 74 }, { darkTone: false })
+glaze.color({ hue: 152, saturation: 95, lightness: 74 }, { darkLightness: false })
 
 // Theme with config override
-const rawTheme = glaze(280, 80, { lightTone: false })
+const rawTheme = glaze(280, 80, { lightLightness: false })
 ```
 
 The override is **snapshotted at create time** so later `glaze.configure()` calls don't change already-created tokens or themes (for non-overridden fields, the snapshot captured the global value at creation time; for themes, non-overridden fields are re-read from the live global at resolve time — see [Theme config override](#theme-config-override)).
@@ -708,18 +443,17 @@ When a theme is created with a `GlazeConfigOverride`, the override is **merged o
 - Fields you didn't override still react to later `glaze.configure()` calls.
 
 ```ts
-const t = glaze(280, 80, { lightTone: [0, 50] });
-t.colors({ text: { tone: 50, saturation: 1 } });
-// text.light lands inside the [0, 50] window — always, regardless of
-// global lightTone changes.
+const t = glaze(280, 80, { lightLightness: [0, 50] });
+t.colors({ text: { lightness: 50, saturation: 1 } });
+// text.light.l ≈ 0.25 — always, regardless of global lightLightness changes.
 // text.dark.s reacts to glaze.configure({ darkDesaturation }) since it's not overridden.
 ```
 
 `extend` inherits the parent's override and shallow-merges the child's:
 
 ```ts
-const child = t.extend({ config: { darkTone: false } });
-// child: lightTone { lo: 0, hi: 50 } (inherited) + darkTone: false (added)
+const child = t.extend({ config: { darkLightness: false } });
+// child: lightLightness: [0, 50] (inherited) + darkLightness: false (added)
 ```
 
 `theme.export()` includes `config`; `glaze.from(data)` restores it.
@@ -739,7 +473,7 @@ Both value-form and structured-form tokens round-trip.
 
 ### Pairing colors
 
-Set `base` to anchor a standalone color to another standalone color or raw value. The contrast solver and relative `tone` offsets switch their anchor from the literal seed to the base's resolved variant per scheme — so the same text color automatically lands at AA against its background in light, dark, and high-contrast modes.
+Set `base` to anchor a standalone color to another standalone color or raw value. The WCAG contrast solver and relative `lightness` offsets switch their anchor from the literal seed to the base's resolved variant per scheme — so the same text color automatically lands at AA against its background in light, dark, and high-contrast modes.
 
 ```ts
 const bg = glaze.color('#1a1a2e');
@@ -747,10 +481,10 @@ const bg = glaze.color('#1a1a2e');
 // Text guaranteed AA against `bg` in every scheme.
 const text = glaze.color({ from: '#ffffff', base: bg, contrast: 'AA' });
 
-// Border 8 tone units lighter than `bg` in each scheme.
+// Border 8 lightness units lighter than `bg` in each scheme.
 const border = glaze.color({ from: '#000000',
   base: bg,
-  tone: '+8',
+  lightness: '+8',
   mode: 'fixed',
 });
 
@@ -761,11 +495,11 @@ const text2 = glaze.color({ from: '#ffffff', base: '#1a1a2e', contrast: 'AA' });
 Behavior with `base`:
 
 - `contrast` is solved per scheme against `base`'s resolved variant (light / dark / lightContrast / darkContrast).
-- Relative `tone: '+N'` / `'-N'` is anchored to `base`'s tone per scheme (matches theme behavior).
+- Relative `lightness: '+N'` / `'-N'` is anchored to `base`'s lightness per scheme (matches theme behavior).
 - Relative `hue: '+N'` / `'-N'` still anchors to the **seed** (the value passed to `glaze.color()`), not the base.
 - `mode` works as a per-pair knob.
 - The base token's `.resolve()` is called lazily on the first resolve of the dependent and the result is captured by reference; later mutations to the base don't apply.
-- **Structured bases are resolved at full range for linking math**: when a value/`from` color links to a base created via the structured form, the contrast/tone anchor uses the raw input tone (not the windowed output). This ensures the anchor matches what you intended, not what the light window remapped it to. The base's own `.resolve()` output is unaffected.
+- **Structured bases are resolved at full range for linking math**: when a value/`from` color links to a base created via the structured form, the contrast/lightness anchor uses the raw input lightness (not the windowed output). This ensures the anchor matches what you intended, not what the light window remapped it to. The base's own `.resolve()` output is unaffected.
 - When the contrast target is physically unreachable, `glaze` emits a single `console.warn` per `(name, scheme, target)` triple and returns the closest passing variant. Use the `name` override to make the warning identifiable.
 
 Chains compose:
@@ -788,8 +522,8 @@ The `name` override appears in `console.warn` / Error messages but **does not**
 
 ```ts
 theme.colors({
-  surface: { tone: 95 },
-  text:    { base: 'surface', tone: '-52', contrast: 'AAA' },
+  surface: { lightness: 95 },
+  text:    { base: 'surface', lightness: '-52', contrast: 'AAA' },
 
   'shadow-sm': { type: 'shadow', bg: 'surface', fg: 'text', intensity: 5 },
   'shadow-md': { type: 'shadow', bg: 'surface', fg: 'text', intensity: 10 },
@@ -882,7 +616,7 @@ For a simple fixed-alpha color (no shadow algorithm), use `opacity` on a regular
 
 ```ts
 theme.colors({
-  overlay: { tone: 0, opacity: 0.5 },
+  overlay: { lightness: 0, opacity: 0.5 },
 });
 // → 'oklch(0 0 0 / 0.5)'
 ```
@@ -897,8 +631,8 @@ Produces a solid color by interpolating between `base` and `target`:
 
 ```ts
 theme.colors({
-  surface: { tone: 95 },
-  accent:  { tone: 30 },
+  surface: { lightness: 95 },
+  accent:  { lightness: 30 },
   tint:    { type: 'mix', base: 'surface', target: 'accent', value: 30 },
 });
 ```
@@ -913,8 +647,8 @@ Produces the target color with controlled opacity — useful for hover overlays:
 
 ```ts
 theme.colors({
-  surface: { tone: 95 },
-  black:   { tone: 0, saturation: 0 },
+  surface: { lightness: 95 },
+  black:   { lightness: 0, saturation: 0 },
   hover: {
     type: 'mix', base: 'surface', target: 'black',
     value: 8, blend: 'transparent',
@@ -961,8 +695,8 @@ Mix colors can reference other mix colors:
 
 ```ts
 theme.colors({
-  white: { tone: 100, saturation: 0 },
-  black: { tone: 0, saturation: 0 },
+  white: { lightness: 100, saturation: 0 },
+  black: { lightness: 0, saturation: 0 },
   gray:  { type: 'mix', base: 'white', target: 'black', value: 50, space: 'srgb' },
   lightGray: { type: 'mix', base: 'white', target: 'gray', value: 50, space: 'srgb' },
 });
@@ -1111,56 +845,6 @@ const stylesheet = `
 `palette.css()` accepts the same `GlazeCssOptions` as `theme.css()` plus `GlazePaletteExportOptions`.
 It does not accept `modes`; all four result fields are always returned.
 
-### `palette.dtcg()`
-
-DTCG export for a palette. Prefix defaults to `true` and the palette-level `primary` is honored (the primary theme's tokens are duplicated without prefix as aliases).
-
-```ts
-palette.dtcg()
-// → {
-//   light: {
-//     'primary-surface': { $type: 'color', $value: { ... } },
-//     'surface':         { $type: 'color', $value: { ... } },  // unprefixed alias
-//     'danger-surface':  { $type: 'color', $value: { ... } },
-//   },
-//   dark: { ... },
-// }
-```
-
-Accepts `GlazeDtcgOptions` plus `GlazePaletteExportOptions`.
-
-### `palette.dtcgResolver()`
-
-Resolver-Module export for a palette. Same as `theme.dtcgResolver()` but merges every theme (with prefix / `primary` aliasing) into the single `sets.base` source and each `scheme` context. Prefix defaults to `true`; the palette-level `primary` is honored.
-
-```ts
-palette.dtcgResolver()
-// → {
-//   version: '2025.10',
-//   sets: { base: { sources: [ { 'primary-surface': {…}, 'surface': {…}, 'danger-surface': {…} } ] } },
-//   modifiers: { scheme: { default: 'light', contexts: { light: [], dark: [ {…} ] } } },
-//   resolutionOrder: [ { $ref: '#/sets/base' }, { $ref: '#/modifiers/scheme' } ],
-// }
-```
-
-Accepts `GlazeDtcgResolverOptions` plus `GlazePaletteExportOptions`.
-
-### `palette.tailwind()`
-
-Tailwind export for a palette. All themes are merged into a single `@theme` block (plus dark / high-contrast overrides), so each color is reachable as a Tailwind utility. Prefix defaults to `true`.
-
-```ts
-const css = palette.tailwind();
-// @theme {
-//   --color-primary-surface: oklch(...);
-//   --color-surface: oklch(...);          /* unprefixed alias */
-//   --color-danger-surface: oklch(...);
-// }
-// .dark { ... }
-```
-
-Accepts `GlazeTailwindOptions` plus `GlazePaletteExportOptions`. The palette `prefix` option (theme prefixing) is separate from `GlazeTailwindOptions.namespace` (the `--color-*` CSS namespace).
-
 ---
 
 ## Output formats
@@ -1169,40 +853,21 @@ Control the color format with the `format` option on any export method:
 
 | Format | Output (alpha = 1) | Output (alpha < 1) | Notes |
 |---|---|---|---|
-| `'okhsl'` (default for `tasty()`) | `okhsl(H S% L%)` | `okhsl(H S% L% / A)` | Glaze's native format, not a CSS function. **Tasty-only** (`tasty()`, `token()`, `.tasty()`). |
-| `'okhst'` | `okhst(H S% T%)` | `okhst(H S% T% / A)` | OKHST tone axis. **Tasty-only** — same restriction as `okhsl`. |
-| `'oklch'` (default for `tokens()` / `json()`) | `oklch(L C H)` | `oklch(L C H / A)` | OKLab-based LCH. Native CSS. Required for `splitHue`. |
-| `'rgb'` (default for `css()`) | `rgb(R G B)` | `rgb(R G B / A)` | Rounded integers, modern space syntax. |
+| `'okhsl'` (default for tokens/tasty/json) | `okhsl(H S% L%)` | `okhsl(H S% L% / A)` | Glaze's native format, not a CSS function. |
+| `'rgb'` (default for css) | `rgb(R G B)` | `rgb(R G B / A)` | Rounded integers, modern space syntax. |
 | `'hsl'` | `hsl(H S% L%)` | `hsl(H S% L% / A)` | Modern space syntax. |
+| `'oklch'` | `oklch(L C H)` | `oklch(L C H / A)` | OKLab-based LCH. |
 
 ```ts
-theme.tokens();                    // 'oklch(0.965 0.0123 280)'  (default)
+theme.tokens();                    // 'okhsl(280 60% 97%)'
 theme.tokens({ format: 'rgb' });   // 'rgb(244 240 250)'
-theme.tasty();                     // 'okhsl(280 60% 97%)'       (default)
-theme.tasty({ format: 'okhst' });  // 'okhst(280 60% 97%)'
+theme.tokens({ format: 'hsl' });   // 'hsl(270.5 45.2% 95.8%)'
+theme.tokens({ format: 'oklch' }); // 'oklch(0.965 0.0123 280)'
 ```
 
 All numeric output strips trailing zeros for cleaner CSS (e.g. `95` not `95.0`).
 
-The `format` option works on CSS-string exports: `theme.tokens()`, `theme.tasty()`, `theme.json()`, `theme.css()`, `theme.tailwind()`, the same on `palette`, and on `token.token()` / `.tasty()` / `.json()` / `.css()` / `.tailwind()`. **`okhsl` and `okhst` throw on non-Tasty exports** (`tokens`, `json`, `css`, `tailwind`) — they are not native CSS color spaces.
-
-### Hue channel splitting (`splitHue`)
-
-On `theme.css()`, `theme.tasty()`, `palette.css()`, `palette.tasty()`, and standalone `color.css()` with `format: 'oklch'`, set `splitHue: true` to emit hue as its own custom property so consumers can re-skin at runtime:
-
-```css
-/* theme.css({ format: 'oklch', splitHue: true, name: 'brand' }) */
---brand-hue: 240;
---accent-hue: calc(var(--brand-hue) + 20);
---surface-color: oklch(0.52 0.06 var(--brand-hue));
---accent-color: oklch(0.62 0.03 var(--accent-hue));
-```
-
-**Requirements:** every exported color must be pastel (`pastel: true` globally or per-color). Pastel mode bounds chroma by the hue-independent safe chroma at each lightness, so emitted `C` stays in sRGB for any rotated hue. Non-pastel palettes throw rather than emit values that would clip under rotation.
-
-**Limitations:** `oklch` only (native CSS `var()` in the hue slot). Shadow and mix colors stay inline (blended hue). Standalone `.token()` / `.tasty()` do not support `splitHue` (return shape cannot carry the `$name-hue` declaration).
-
-`theme.dtcg()` / `theme.dtcgResolver()` / `palette.dtcg()` / `palette.dtcgResolver()` ignore `format` — DTCG emits structured `$value` objects, not CSS strings. Use the `colorSpace` option (`'srgb'` or `'oklch'`) to pick the color representation instead.
+The `format` option works on every export: `theme.tokens()`, `theme.tasty()`, `theme.json()`, `theme.css()`, the same on `palette`, and on `token.token()` / `.tasty()` / `.json()` / `.css()`.
 
 ---
 
@@ -1212,66 +877,78 @@ On `theme.css()`, `theme.tasty()`, `palette.css()`, `palette.tasty()`, and stand
 
 | Mode | Behavior |
 |---|---|
-| `'auto'` (default) | Full adaptation. Dark is a single tone inversion (`100 − t`) remapped into the dark window. High-contrast uses the full range. |
-| `'fixed'` | Color stays recognizable. Tone is *mapped* (not inverted) into the dark window. Use for brand buttons, CTAs, status banners. |
-| `'static'` | No adaptation. Same tone in every scheme. |
+| `'auto'` (default) | Full adaptation. Light ↔ dark inversion via the Möbius curve. High-contrast boost. |
+| `'fixed'` | Color stays recognizable. Lightness is *mapped* (not inverted) into the dark window. Use for brand buttons, CTAs, status banners. |
+| `'static'` | No adaptation. Same value in every scheme. |
 
-### How relative tone adapts
+### How relative lightness adapts
 
-**`auto`** — the offset is anchored to the base's per-scheme tone:
+**`auto`** — relative lightness sign flips in dark scheme:
 
 ```
-Light: surface tone=97, text tone='-52' → tone 45 (dark text on light bg)
-Dark:  surface inverts to a low tone; the '-52' offset re-anchors to the
-       base's light tone and maps into the dark window (light text on dark bg)
+Light: surface L=97, text lightness='-52' → L=45 (dark text on light bg)
+Dark:  surface inverts to L≈20 (Möbius), sign flips → L=20+52=72
+       contrast solver may push further (light text on dark bg)
 ```
 
-**`fixed`** — tone is mapped (not inverted), relative sign preserved:
+**`fixed`** — lightness is mapped (not inverted), relative sign preserved:
 
 ```
-Light: accent-fill tone=52, accent-text tone='+20' → lighter than the fill
-Dark:  accent-fill maps into the dark window, sign preserved
+Light: accent-fill L=52, accent-text lightness='+48' → L=100 (white on brand)
+Dark:  accent-fill maps to L≈51.6, sign preserved → L≈99.6
 ```
 
-Offsets that would push past `[0, 100]` clamp to the boundary, or — with `autoFlip` (default on) — mirror to the other side of the base. Set `autoFlip: false` to keep the authored side and clamp instead.
-
-**`static`** — no adaptation, same tone in every scheme.
+**`static`** — no adaptation, same value in every scheme.
 
 ---
 
 ## Light / dark scheme mapping
 
-The mapping is now a single tone pipeline; there is no Möbius curve. See [`docs/okhst.md`](okhst.md) for the full math and the calibrated default constants.
-
-### Light scheme
+### Light scheme — lightness
 
-An authored tone (0–100) is remapped into the `lightTone` window. The window's `lo`/`hi` are OKHSL-lightness endpoints (0–100); the tone is positioned within the window's tone interval and converted to a final OKHSL lightness. `static` mode and HC variants use the full range.
+Absolute lightness values (root colors and dependent colors with absolute lightness) are mapped linearly within the configured `lightLightness` window:
 
-```
-window      = lightTone               // default [10, 100]
-finalTone   = remap(authorTone, window)
-finalL      = fromTone(finalTone)     // OKHSL lightness
+```ts
+const [lo, hi] = lightLightness; // default: [10, 100]
+const mappedL = (lightness * (hi - lo)) / 100 + lo;
 ```
 
-### Dark scheme
+Both `auto` and `fixed` modes use the same linear formula. `static` mode and HC variants bypass the mapping (identity: `mappedL = l`).
 
-**`auto`** — invert the tone, then remap into the dark window:
+| Color | Raw L | Mapped L (default `[10, 100]`) |
+|---|---|---|
+| surface (L=97) | 97 | 97.3 |
+| accent-fill (L=52) | 52 | 56.8 |
+| near-black (L=0) | 0 | 10 |
 
-```
-window    = darkTone                  // default [15, 95]
-inverted  = 100 - authorTone
-finalTone = remap(inverted, window)
+### Dark scheme — lightness
+
+**`auto`** — inverted with a Möbius transformation within the configured window:
+
+```ts
+const [lo, hi] = darkLightness; // default: [15, 95]
+const t = (100 - lightness) / 100;
+const invertedL = lo + (hi - lo) * t / (t + darkCurve * (1 - t));
+// darkCurve default: 0.5
 ```
 
-Because tone is contrast-uniform, the inversion preserves contrast steps without a fitted curve — the asymmetry between light and dark lives entirely in the two windows' `(lo, hi, eps)` scalars (`eps` defaults to the reference `0.05`).
+The `darkCurve` parameter (default `0.5`, range 0–1) controls how much the dark-mode inversion expands lightness deltas. Lower values produce stronger expansion; `1` gives linear (legacy) behavior. Accepts `[normal, highContrast]` pairs (e.g. `darkCurve: [0.5, 0.3]`).
 
-**`fixed`** — remap into the dark window without inversion:
+Unlike a power curve, the Möbius transformation provides **proportional expansion** — small and large deltas are scaled by similar ratios, preserving the visual hierarchy of the light theme.
 
+**`fixed`** — mapped without inversion (not affected by `darkCurve`):
+
+```ts
+const mappedL = (lightness * (hi - lo)) / 100 + lo;
 ```
-finalTone = remap(authorTone, darkTone)
-```
 
-In high-contrast variants both windows are bypassed (forced to the full `[0, 100]` range): `auto` still inverts, `fixed`/`static` do not.
+| Color | Light L | Auto (curve=0.5) | Auto (curve=1, linear) | Fixed (mapped) |
+|---|---|---|---|---|
+| surface (L=97) | 97 | 19.7 | 17.4 | 92.6 |
+| accent-fill (L=52) | 52 | 66.9 | 53.4 | 56.6 |
+| accent-text (L=100) | 100 | 15 | 15 | 95 |
+
+In high-contrast variants the `darkLightness` window is bypassed — `auto` uses the Möbius curve over the full `[0, 100]` range, `fixed` uses identity.
 
 ### Dark scheme — saturation
 
@@ -1289,9 +966,10 @@ S_dark = S_light * (1 - darkDesaturation) // default: 0.1
 
 ```ts
 glaze.configure({
-  lightTone: [10, 100], // [lo, hi]; or { lo, hi, eps } / false to disable clamping
-  darkTone: [15, 95],   // [lo, hi]; or { lo, hi, eps } / false to disable clamping
+  lightLightness: [10, 100],   // or false to disable clamping
+  darkLightness: [15, 95],     // or false to disable clamping
   darkDesaturation: 0.1,
+  darkCurve: 0.5,              // or [normal, hc] pair
   states: {
     dark: '@dark',
     highContrast: '@high-contrast',
@@ -1307,23 +985,20 @@ glaze.configure({
 });
 ```
 
-A `ToneWindow` is `[lo, hi]` (OKHSL-lightness endpoints, reference eps — the common form), `{ lo, hi, eps }` (advanced: explicit per-mode render eps), or `false` to disable clamping (full range `[0, 100]` at the reference eps). `false` removes the *boundaries*, not the contrast-uniform tone curve.
-
 `GlazeConfig`:
 
 | Field | Default | Description |
 |---|---|---|
-| `lightTone` | `[10, 100]` | Light scheme tone window: `[lo, hi]`, `{ lo, hi, eps }`, or `false` to disable clamping. Bypassed in HC. |
-| `darkTone` | `[15, 95]` | Dark scheme tone window: `[lo, hi]`, `{ lo, hi, eps }`, or `false` to disable clamping. Bypassed in HC. |
+| `lightLightness` | `[10, 100]` | Light scheme lightness window `[lo, hi]`, or `false` to disable clamping (equivalent to `[0, 100]`). Bypassed in HC. |
+| `darkLightness` | `[15, 95]` | Dark scheme lightness window, or `false` to disable clamping. Bypassed in HC. |
 | `darkDesaturation` | `0.1` | Saturation reduction in dark scheme (0–1). |
+| `darkCurve` | `0.5` | Möbius beta for dark `auto`-inversion (0–1). Accepts `[normal, hc]` pair. |
 | `states.dark` | `'@dark'` | State alias for dark mode tokens (Tasty export). |
 | `states.highContrast` | `'@high-contrast'` | State alias for HC tokens. |
 | `modes.dark` | `true` | Include dark variants in exports. |
 | `modes.highContrast` | `false` | Include HC variants. |
 | `shadowTuning` | `undefined` | Default tuning for all shadow colors. Per-color tuning merges field-by-field. |
-| `autoFlip` | `true` | Default for each color's `autoFlip`. When solving `contrast` (or applying a relative `tone` that overshoots `[0, 100]`), allow crossing to the opposite side instead of clamping. With `false`, only the requested direction is considered; unmet contrasts pin the tone to that direction's extreme (and emit a warning) and overshooting offsets clamp to the boundary. Override per color via [`autoFlip`](#autoflip). |
-| `pastel` | `false` | Hue-independent "safe" chroma limit across all colors so scaling saturation never exceeds the sRGB boundary at any hue for the given lightness. Override per color via [`pastel`](#per-color-pastel). |
-| `inferRole` | `true` | Infer each color's [`role`](#roles) from its name when no explicit `role` is set. Set to `false` to opt out of name-based inference (the base-opposite and foreground-default fallbacks still apply). |
+| `autoFlip` | `true` | When solving `contrast`, allow the solver to switch away from the requested lightness direction if that side can't meet the target. With `false`, only the requested direction is considered; unmet contrasts pin the lightness to that direction's extreme (and emit a warning). |
 
 | Method | Description |
 |---|---|
@@ -1364,12 +1039,10 @@ Resolution priority (highest first):
 | Condition | Behavior |
 |---|---|
 | `contrast` without `base` in a **theme** color | Validation error |
-| Relative `tone` without `base` in a **theme** color | Validation error |
+| Relative `lightness` without `base` in a **theme** color | Validation error |
 | `contrast` without `base` in `glaze.color()` | Anchors against the literal seed (no error) |
-| Relative `tone` without `base` in `glaze.color()` | Anchors against the literal seed (no error) |
-| Relative `tone` overshoots `[0, 100]` | Mirror to the other side of the base (`autoFlip` on, default), or clamp to the boundary (`autoFlip` off) |
-| `tone` resolves outside 0–100 | Clamp silently |
-| `'max'` / `'min'` without `base` | Allowed — resolves to the scheme's tone extreme (root color) |
+| Relative `lightness` without `base` in `glaze.color()` | Anchors against the literal seed (no error) |
+| `lightness` resolves outside 0–100 | Clamp silently |
 | `saturation` outside 0–1 | Clamp silently |
 | Circular `base` references | Validation error |
 | `base` references non-existent name | Validation error |
@@ -1439,68 +1112,35 @@ formatOklch(280, 60, 95); // 'oklch(0.95 ... 280)'
 
 To attach an alpha component, use `glaze.format(variant, format)` on a `ResolvedColorVariant` (which carries the `alpha` channel) instead of these raw writers.
 
-### OKHST tone utilities
-
-```ts
-import {
-  toTone,
-  fromTone,
-  toneFromY,
-  yFromTone,
-  okhstToOkhsl,
-  okhslToOkhst,
-  variantToOkhsl,
-  REF_EPS,
-} from '@tenphi/glaze';
-```
-
-| Function | Description |
-|---|---|
-| `toTone(l, eps?)` | OKHSL lightness (0–1) → tone (0–100). Defaults to `REF_EPS`. |
-| `fromTone(t, eps?)` | Tone (0–100) → OKHSL lightness (0–1). Inverse of `toTone`. |
-| `toneFromY(y, eps?)` / `yFromTone(t, eps?)` | Same transfer in luminance space (0–1). |
-| `okhstToOkhsl({ h, s, t })` | OKHST → OKHSL (`{ h, s, l }`). |
-| `okhslToOkhst({ h, s, l })` | OKHSL → OKHST (`{ h, s, t }`). |
-| `variantToOkhsl(variant)` | `ResolvedColorVariant` (stores `t`) → `{ h, s, l, alpha }` for rendering. |
-| `REF_EPS` | Reference epsilon (`0.05`) for the canonical tone axis. |
-
-`ResolvedColorVariant` now stores `{ h, s, t, alpha }` (tone, not lightness). Use `variantToOkhsl(variant).l` to recover OKHSL lightness. See [`docs/okhst.md`](okhst.md) for the full model.
-
 ### Contrast solver
 
 ```ts
 import {
-  findToneForContrast,
+  findLightnessForContrast,
   findValueForMixContrast,
-  resolveContrastForMode,
   resolveMinContrast,
-  apcaContrast,
 } from '@tenphi/glaze';
 ```
 
 | Function | Description |
 |---|---|
-| `findToneForContrast(opts)` | Binary-search for the tone (0–1) that meets a contrast floor (WCAG or APCA) against a base color. Returns `{ tone, contrast, met, branch, flipped? }`. |
+| `findLightnessForContrast(opts)` | Binary-search for the OKHSL lightness that meets a WCAG contrast floor against a base color. Returns `{ lightness, contrast, met, branch }`. |
 | `findValueForMixContrast(opts)` | Same, but searches for a mix `value` (0–1) that meets a contrast floor between a base and a target. |
-| `resolveContrastForMode(spec, isHC, polarity?, outerExplicitHC?)` | Resolves a `ContrastSpec` to `{ metric: 'wcag' \| 'apca', target }` for the requested mode (picks the normal or HC entry of any pair). In HC, applies the metric's auto-enhancement unless `outerExplicitHC` is set or the inner metric pair carries an explicit HC value: APCA +15 Lc (clamped to 106); WCAG AA → AAA / AA-large → AAA-large (AAA-family and bare numbers unchanged). |
-| `resolveMinContrast(value)` | Resolves a `MinContrast` (WCAG preset or number) to a numeric ratio. |
-| `apcaContrast(yText, yBg)` | APCA Lc magnitude (0–106) for two relative luminances. |
-
-Exported constants: `APCA_PRESETS`, `APCA_HC_ENHANCEMENT` (`15`, the Enhanced Level delta), `APCA_MAX_LC` (`106`).
+| `resolveMinContrast(value)` | Resolves a `MinContrast` (preset or number) to a numeric ratio. |
 
-`findToneForContrast` options:
+`findLightnessForContrast` options:
 
 | Option | Default | Description |
 |---|---|---|
 | `hue` | — | Candidate hue (0–360). |
 | `saturation` | — | Candidate saturation (0–1). |
-| `preferredTone` | — | Preferred candidate tone (0–1). Kept if it already meets the target. |
+| `preferredLightness` | — | Preferred candidate lightness (0–1). Kept if it already meets the target. |
 | `baseLinearRgb` | — | Base color as linear sRGB tuple. |
-| `contrast` | — | `ResolvedContrast` (`{ metric, target }`). |
-| `toneRange` | `[0, 1]` | Search bounds in tone. |
+| `contrast` | — | WCAG floor (`MinContrast`). |
+| `lightnessRange` | `[0, 1]` | Search bounds. |
 | `epsilon` | `1e-4` | Convergence threshold. |
-| `maxIterations` | `18` | Max binary-search iterations per branch. |
-| `initialDirection` | higher-contrast side | Direction to search first (`'lighter'` or `'darker'`). |
+| `maxIterations` | `14` | Max binary-search iterations per branch. |
+| `initialDirection` | higher-contrast side | Direction to search first (`'lighter'` or `'darker'`). Theme resolution sets this from the requested lightness relative to the base color. |
 | `flip` | `false` | When `true`, try the opposite direction if the initial one doesn't meet the target. When `false`, only the initial direction is searched — unmet contrasts pin the result to that direction's extreme. |
 
-Result: `{ tone, contrast, met, branch: 'lighter' | 'darker' | 'preferred', flipped? }`. `flipped: true` indicates the initial direction failed and the opposite direction satisfied the target.
+Result: `{ lightness, contrast, met, branch: 'lighter' | 'darker' | 'preferred', flipped? }`. `flipped: true` indicates the initial direction failed and the opposite direction satisfied the target.