@cube-dev/ui-kit 0.0.0-canary-7c5dc45 → 0.0.0-canary-7d44972

package/docs/glaze/api.md

@@ -6,18 +6,12 @@ Full reference for every public method, option, and type exported by `@tenphi/gl
 
 - [Theme creation](#theme-creation)
 - [Theme methods](#theme-methods)
-  - [DTCG](#themedtcgoptions)
-  - [DTCG Resolver-Module](#themedtcgresolveroptions)
-  - [Tailwind CSS](#themetailwindoptions)
-- [High-contrast pairs](#high-contrast-pairs)
 - [Color definitions](#color-definitions)
-  - [Dark seed](#dark-seed-darkhue--darksaturation)
 - [Standalone color tokens](#standalone-color-tokens)
 - [Shadows](#shadows)
 - [Mix colors](#mix-colors)
 - [Palette](#palette)
 - [Output formats](#output-formats)
-- [Hue channel splitting](#hue-channel-splitting-splithue)
 - [Adaptation modes](#adaptation-modes)
 - [Light / dark scheme mapping](#light--dark-scheme-mapping)
 - [Configuration](#configuration)
@@ -29,42 +23,25 @@ Full reference for every public method, option, and type exported by `@tenphi/gl
 
 ## Theme creation
 
-| Method                                | Description                                                                                                           |
-| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `glaze(hue, saturation?, config?)`    | Create a theme from hue (0–360) and saturation (0–100). Optional `config` overrides the global config for this theme. |
-| `glaze({ hue, saturation, darkHue?, darkSaturation? }, config?)` | Create a theme from an options object, with optional per-theme config override. `darkHue` / `darkSaturation` seed the dark schemes — see [Dark seed](#dark-seed-darkhue--darksaturation). |
-| `glaze.themeFrom(data)`               | Create a theme from a `theme.export()` snapshot (`kind: 'theme'`).                                                    |
-| `glaze.from(data)`                    | Compat alias for `glaze.themeFrom`.                                                                                   |
-| `glaze.fromHex(hex)`                  | Create a theme from a hex color (`#rgb` or `#rrggbb`). Extracts hue and saturation.                                   |
-| `glaze.fromRgb(r, g, b)`              | Create a theme from RGB values (0–255). Extracts hue and saturation.                                                  |
-| `glaze.paletteFrom(data)`             | Create a palette from a `palette.export()` snapshot (`kind: 'palette'`).                                              |
-| `glaze.colorFrom(data)`               | Create a color token from a `token.export()` snapshot (`kind: 'color'`).                                              |
-| `glaze.isThemeExport(data)`           | Type guard for theme authoring snapshots.                                                                             |
-| `glaze.isColorTokenExport(data)`      | Type guard for color-token authoring snapshots.                                                                       |
-| `glaze.isPaletteExport(data)`         | Type guard for palette authoring snapshots.                                                                           |
+| Method | Description |
+|---|---|
+| `glaze(hue, saturation?, config?)` | Create a theme from hue (0–360) and saturation (0–100). Optional `config` overrides the global config for this theme. |
+| `glaze({ hue, saturation }, config?)` | Create a theme from an options object, with optional per-theme config override. |
+| `glaze.from(data)` | Create a theme from an exported configuration (`theme.export()` snapshot). |
+| `glaze.fromHex(hex)` | Create a theme from a hex color (`#rgb` or `#rrggbb`). Extracts hue and saturation. |
+| `glaze.fromRgb(r, g, b)` | Create a theme from RGB values (0–255). Extracts hue and saturation. |
 
 ```ts
 const a = glaze(280, 80);
 const b = glaze({ hue: 280, saturation: 80 });
-const bDark = glaze({ hue: 280, saturation: 80, darkHue: 268, darkSaturation: 65 });
 const c = glaze.fromHex('#7a4dbf');
 const d = glaze.fromRgb(122, 77, 191);
-const e = glaze.themeFrom(a.export());
+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 });
 ```
 
-Authoring restore triad (parallel to `.export()` on each instance):
-
-| Export | Restore |
-| ------ | ------- |
-| `theme.export()` | `glaze.themeFrom()` |
-| `token.export()` | `glaze.colorFrom()` |
-| `palette.export()` | `glaze.paletteFrom()` |
-
-Every snapshot includes `kind` + `version` (`GLAZE_EXPORT_VERSION`, currently `1`). Legacy snapshots without those fields still restore. Wrong `kind`, or a `version` outside `1..=GLAZE_EXPORT_VERSION`, throws.
-
 The optional `config` parameter is a `GlazeConfigOverride` — see [Per-instance config override](#per-instance-config-override).
 
 ---
@@ -73,43 +50,38 @@ The optional `config` parameter is a `GlazeConfigOverride` — see [Per-instance
 
 A `GlazeTheme` exposes:
 
-| Method                          | Description                                                                                         |
-| ------------------------------- | --------------------------------------------------------------------------------------------------- |
-| `theme.hue` (readonly)          | The hue seed (0–360).                                                                               |
-| `theme.saturation` (readonly)   | The saturation seed (0–100).                                                                        |
-| `theme.darkHue` (readonly)      | The dark-scheme hue seed (0–360), or `undefined` when `hue` is reused.                              |
-| `theme.darkSaturation` (readonly) | The dark-scheme saturation seed (0–100), or `undefined` when `saturation` is reused.              |
-| `theme.colors(defs)`            | Add/replace colors (additive merge — adds new, overwrites existing by name, doesn't remove others). |
-| `theme.color(name)`             | Get a color definition by name.                                                                     |
-| `theme.color(name, def)`        | Set a single color definition.                                                                      |
-| `theme.remove(name \| names[])` | Remove one or more color definitions.                                                               |
-| `theme.has(name)`               | Check if a color is defined.                                                                        |
-| `theme.list()`                  | List all defined color names.                                                                       |
-| `theme.reset()`                 | Clear all color definitions.                                                                        |
-| `theme.export(override?)`       | Export the theme configuration as a JSON-safe object (optional config override at export time).     |
-| `theme.extend(options)`         | Create a child theme inheriting all color definitions (see [`extend`](#themeextendoptions) below).  |
-| `theme.resolve()`               | Resolve all colors and return a `Map<string, ResolvedColor>`.                                       |
-| `theme.tokens(options?)`        | Export as a flat token map grouped by scheme variant.                                               |
-| `theme.tasty(options?)`         | Export as [Tasty](https://tasty.style) style-to-state bindings.                                                            |
-| `theme.json(options?)`          | Export as plain JSON.                                                                               |
-| `theme.css(options?)`           | Export as CSS custom property declarations.                                                         |
-| `theme.dtcg(options?)`          | Export one W3C DTCG token tree per scheme.                                                          |
-| `theme.dtcgResolver(options?)`  | Export one DTCG Resolver-Module document containing every scheme.                                   |
-| `theme.tailwind(options?)`      | Export a Tailwind CSS v4 theme and scheme overrides.                                                |
+| Method | Description |
+|---|---|
+| `theme.hue` (readonly) | The hue seed (0–360). |
+| `theme.saturation` (readonly) | The saturation seed (0–100). |
+| `theme.colors(defs)` | Add/replace colors (additive merge — adds new, overwrites existing by name, doesn't remove others). |
+| `theme.color(name)` | Get a color definition by name. |
+| `theme.color(name, def)` | Set a single color definition. |
+| `theme.remove(name \| names[])` | Remove one or more color definitions. |
+| `theme.has(name)` | Check if a color is defined. |
+| `theme.list()` | List all defined color names. |
+| `theme.reset()` | Clear all color definitions. |
+| `theme.export()` | Export the theme configuration as a JSON-safe object. |
+| `theme.extend(options)` | Create a child theme inheriting all color definitions (see [`extend`](#themeextendoptions) below). |
+| `theme.resolve()` | Resolve all colors and return a `Map<string, ResolvedColor>`. |
+| `theme.tokens(options?)` | Export as a flat token map grouped by scheme variant. |
+| `theme.tasty(options?)` | Export as Tasty style-to-state bindings. |
+| `theme.json(options?)` | Export as plain JSON. |
+| `theme.css(options?)` | Export as CSS custom property declarations. |
 
 ### `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
-const def = theme.color('surface'); // get
+theme.color('surface', { lightness: 97, saturation: 0.75 });    // set
+const def = theme.color('surface');                              // get
 ```
 
 ### `theme.extend(options)`
@@ -119,89 +91,73 @@ 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`:
 
-| Field        | Type                  | Description                                                                                  |
-| ------------ | --------------------- | -------------------------------------------------------------------------------------------- |
-| `hue`        | `number`              | Replace the hue seed. Defaults to the parent's hue.                                          |
-| `saturation` | `number`              | Replace the saturation seed. Defaults to the parent's saturation.                            |
-| `darkHue`    | `number`              | Replace the dark hue seed. Defaults to the parent's `darkHue`.                               |
-| `darkSaturation` | `number`          | Replace the dark saturation seed. Defaults to the parent's `darkSaturation`.                 |
-| `colors`     | `ColorMap`            | Per-theme overrides (additive merge over the inherited map).                                 |
-| `config`     | `GlazeConfigOverride` | Config override for the child. Shallow-merged with the parent's override — child fields win. |
+| Field | Type | Description |
+|---|---|---|
+| `hue` | `number` | Replace the hue seed. Defaults to the parent's hue. |
+| `saturation` | `number` | Replace the saturation seed. Defaults to the parent's saturation. |
+| `colors` | `ColorMap` | Per-theme overrides (additive merge over the inherited map). |
+| `config` | `GlazeConfigOverride` | Config override for the child. Shallow-merged with the parent's override — child fields win. |
 
 Colors marked with `inherit: false` on the parent are **not** copied into the child.
 
-### `theme.resolve()`
-
-Resolves the dependency graph and returns a
-`Map<string, ResolvedColor>`. Export methods call it automatically; use it
-directly for tests, diagnostics, or a custom output pipeline.
-
-```ts
-const resolved = theme.resolve();
-const surface = resolved.get('surface');
-// surface?.light.t is canonical tone on 0–1.
-```
-
 ### `theme.tokens(options?)`
 
 Flat token map grouped by scheme variant.
 
 ```ts
-theme.tokens();
-// → { light: { surface: 'oklch(...)' }, dark: { surface: 'oklch(...)' } }
+theme.tokens()
+// → { 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. |
-| `modes`  | `{ dark: true, highContrast: false }` (or global config) | Which scheme variants to include.                                                                                 |
+| Option | Default | Description |
+|---|---|---|
+| `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?)`
 
-Style-to-state bindings for the [Tasty](https://tasty.style) style system. Uses `#name` color token keys and state aliases. By default the dark and high-contrast variants are keyed by media-query states (`'@media(prefers-color-scheme: dark)'`, `'@media(prefers-contrast: more)'`) so tokens work without registering custom states.
+Tasty style-to-state bindings for the [Tasty style system](https://tasty.style/docs). Uses `#name` color token keys and state aliases (`''`, `@dark`, etc.).
 
 ```ts
-theme.tasty();
+theme.tasty()
 // → {
-//   '#surface': { '': 'oklch(...)', '@media(prefers-color-scheme: dark)': 'oklch(...)' },
+//   '#surface': { '': 'okhsl(...)', '@dark': 'okhsl(...)' },
 //   ...
 // }
 ```
 
 `GlazeTokenOptions`:
 
-| Option                | Default                                                   | Description                                                                                                                                      |
-| --------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `format`              | `'oklch'`                                                 | Output color format. `'okhsl'` and `'okhst'` are also supported here ([Tasty](https://tasty.style)-only spaces).                                                        |
-| `modes`               | global config                                             | Which scheme variants to include.                                                                                                                |
-| `states.dark`         | `'@media(prefers-color-scheme: dark)'` (or global config) | State alias for dark mode tokens.                                                                                                                |
-| `states.highContrast` | `'@media(prefers-contrast: more)'` (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).                                                                                                                         |
+| Option | Default | Description |
+|---|---|---|
+| `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. |
+| `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. `'@media(prefers-color-scheme: dark) & @media(prefers-contrast: more)'`).
+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'`).
 
 ### `theme.json(options?)`
 
 Per-color JSON map.
 
 ```ts
-theme.json();
+theme.json()
 // → {
-//   surface: { light: 'oklch(...)', dark: 'oklch(...)' },
-//   text:    { light: 'oklch(...)', dark: 'oklch(...)' },
+//   surface: { light: 'okhsl(...)', dark: 'okhsl(...)' },
+//   text:    { light: 'okhsl(...)', dark: 'okhsl(...)' },
 // }
 ```
 
@@ -214,8 +170,8 @@ CSS custom property declaration strings, grouped by scheme variant.
 ```ts
 theme.css();
 // → {
-//   light: '--surface-color: oklch(...);\n--text-color: oklch(...);',
-//   dark:  '--surface-color: oklch(...);\n--text-color: oklch(...);',
+//   light: '--surface-color: rgb(...);\n--text-color: rgb(...);',
+//   dark:  '--surface-color: rgb(...);\n--text-color: rgb(...);',
 //   lightContrast: '...',
 //   darkContrast:  '...',
 // }
@@ -223,188 +179,23 @@ theme.css();
 
 `GlazeCssOptions`:
 
-| Option     | Default    | Description                                                                                                                                                                                                                                 |
-| ---------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `format`   | `'oklch'`  | Output color format. One of `'rgb' \| 'hsl' \| 'oklch'`. `'okhsl'` and `'okhst'` throw — use `tasty()` for those.                                                                                                                           |
-| `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.                                                                                                                                |
+| Option | Default | Description |
+|---|---|---|
+| `format` | `'rgb'` | Output color format. |
+| `suffix` | `'-color'` | Suffix appended to each CSS property name. Pass `''` for bare property names. |
 
 `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(override?)`
+### `theme.export()`
 
 ```ts
 const snapshot = theme.export();
-// → {
-//     kind: 'theme',
-//     version: 1,
-//     hue: 280,
-//     saturation: 80,
-//     colors: { surface: { ... }, ... },
-//     config: { lightTone: {...}, darkTone: {...}, pastel: false, ... },
-//   }
-
-const restored = glaze.themeFrom(snapshot);
-```
-
-Returns a deep-cloned, JSON-safe authoring snapshot (definitions + frozen
-effective config — not resolved color strings). Freezes
-`getConfig() ∪ instance local ∪ override` at call time. Restored themes pin
-that freeze as their local override. Distinct from `theme.json()`, which
-emits resolved color strings.
-
----
-
-## High-contrast pairs
-
-`HCPair<T>` means either one value used in both ordinary and high-contrast
-schemes, or an explicit `[normal, highContrast]` pair:
+// → { hue: 280, saturation: 80, colors: { surface: { ... }, ... } }
 
-```ts
-type HCPair<T> = T | [T, T];
-```
-
-It is used by `tone`, `contrast`, shadow `intensity`, and mix `value`:
-
-```ts
-tone: '-8'; // -8 in normal and HC
-tone: ['-8', '-16']; // -8 normal, -16 HC
-contrast: {
-  apca: 'content';
-} // preset with automatic HC enhancement
-contrast: {
-  apca: ['content', 'body'];
-} // explicit normal/HC targets
+const restored = glaze.from(snapshot);
 ```
 
-For `contrast`, the pair may wrap the whole spec or live inside the selected
-metric. An explicit HC value disables automatic APCA enhancement or WCAG preset
-promotion for that color.
+The export contains only the configuration — not resolved color values. Resolved values are recomputed on demand.
 
 ---
 
@@ -418,288 +209,88 @@ type ColorDef = RegularColorDef | ShadowColorDef | MixColorDef;
 
 ### `RegularColorDef`
 
-| Field        | Type                            | Description                                                                                                                                                                                                                                                                        |
-| ------------ | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `tone`       | `HCPair<ToneValue>`             | Number = absolute (0–100). `'+N'`/`'-N'` = a signed **tone delta** from the base (requires `base`). `'max'`/`'min'` = forced to the scheme's tone extreme (no `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).                                                                                                                                                                    |
-| `darkHue`    | `number \| RelativeValue`       | Dark-scheme hue. Number = absolute (0–360). String = relative to the **theme dark seed hue**. Falls back to `hue`. See [Dark seed](#dark-seed-darkhue--darksaturation).                                                                                                            |
-| `darkSaturation` | `number`                    | Dark-scheme saturation factor (0–1) over the dark seed saturation. Falls back to `saturation`. When set, the global `darkDesaturation` reduction is **not** applied on top.                                                                                                        |
-| `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).                                                                                                                                                                                                 |
-| `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 per-theme / per-token `pastel` override 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 authored OKHSL lightness with a contrast-shaped axis.
-Equal tone differences give equal WCAG contrast for neutrals; chromatic results
-can drift in measured luminance. See [OKHST in Glaze](okhst.md). To port old
-`lightness` values, see [migration.md](migration.md).
-
-| Form                | Example                 | Meaning                                                                                       |
-| ------------------- | ----------------------- | --------------------------------------------------------------------------------------------- |
-| Number (absolute)   | `tone: 45`              | Absolute tone 0–100.                                                                          |
-| String (tone delta) | `tone: '-52'`           | Signed difference from the base color's resolved tone (requires `base`).                      |
-| Extreme             | `tone: 'max'` / `'min'` | Force to the scheme's highest (`'max'` = 100) or lowest (`'min'` = 0) tone. With a `base`, the light-scheme shift is replayed in dark. 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.
-
-**A tone delta** applies a signed difference to the base color's resolved tone.
-It gives an exact contrast step for neutrals and a stable visual progression for
-chromatic colors. In dark mode with `mode: 'auto'`, it 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. If the mirrored target is also out of range, the original
-delta is kept and clamped on the authored side.
-
-**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. Without a `base`, 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.
-
-**Extreme tone with a `base`** keeps the pair's contrast across schemes. The tone windows are asymmetric by default (`lightTone: [10, 100]`, `darkTone: [15, 95]`), so re-mapping the extreme through the dark window would squeeze the base-to-extreme span and cost contrast. Instead Glaze measures the tone shift the light scheme applied between the base and the extreme, then replays it against the base's resolved dark tone — mirrored under `mode: 'auto'` (both ends invert), same-signed under `'fixed'`. The result is clamped to `[0, 100]` only, so it may cross the `darkTone` window edge; that is intentional, since the author asked for the extreme. When the shift does not fit above or below the dark base, the color pins at tone 100 / 0. `mode: 'static'` is unaffected, and high-contrast variants already use the full range.
+| Field | Type | Description |
+|---|---|---|
+| `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<MinContrast>` | WCAG contrast floor against `base`. Requires `base`. |
+| `mode` | `'auto' \| 'fixed' \| 'static'` | Adaptation mode. Default: `'auto'`. See [Adaptation modes](#adaptation-modes). |
+| `opacity` | `number` | Fixed alpha 0–1. Output includes alpha in the CSS value. Combining with `contrast` is not recommended (a `console.warn` is emitted). |
+| `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. |
 
-```ts
-theme.colors({
-  bg: { tone: 60 },
-  fg: { base: 'bg', tone: 'max' },
-});
-// light: bg 62.0, fg 100.0 — shift +38.0, contrast 3.18:1
-// dark:  bg 43.9, fg 5.9   — shift -38.0, contrast 3.18:1
-```
-
-A dependent color with `base` but no `tone` inherits the base's tone (equivalent to a delta of 0).
+#### Lightness values
 
-#### `autoFlip`
+| Form | Example | Meaning |
+|---|---|---|
+| 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. |
 
-`autoFlip` governs what happens when a result would fall outside its valid range:
+**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.
 
-- **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. If the mirrored target is also outside `[0, 100]`, the original delta is kept and clamped on the authored side.
-- **`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`).
+**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` 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.
+A dependent color with `base` but no `lightness` inherits the base's lightness (equivalent to a delta of 0).
 
-#### `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 |
-| ------------- | ---------- |
-| `'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.
+| Preset | Ratio |
+|---|---|
+| `'AA-large'` | 3 |
+| `'AA'` | 4.5 |
+| `'AAA-large'` | 4.5 |
+| `'AAA'` | 7 |
 
-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).
+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 preferred `tone` already
-satisfies it, the tone is kept; otherwise the solver uses the tone-shaped scale
-for a closed-form WCAG seed and fast search 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 [Contrast verification](okhst.md#contrast-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.
 
-#### Dark seed (`darkHue` / `darkSaturation`)
-
-Tone inverts automatically between light and dark, but hue and saturation do
-not — by default every scheme reuses the one seed, with dark getting a flat
-`darkDesaturation` haircut. When a palette needs a genuinely different chroma in
-dark (a cooler accent, a calmer surface tint), author a second seed:
-
-```ts
-const theme = glaze({
-  hue: 280,
-  saturation: 80,
-  darkHue: 268, // dark schemes seed from 268 instead of 280
-  darkSaturation: 65, // and from 65 instead of 80
-});
-```
-
-Individual colors can override either channel for dark on their own:
-
-```ts
-theme.colors({
-  surface: { tone: 97 },
-  accent: { tone: 55, hue: '+20', darkHue: '+35' },
-  warning: { tone: 60, saturation: 0.9, darkSaturation: 0.6 },
-});
-```
-
-Both apply to the `dark` **and** `darkContrast` variants. The rules:
-
-| Rule | Behavior |
-| ---- | -------- |
-| Units | Seed-level `darkSaturation` is `0–100` (like `saturation` on the theme). Def-level `darkSaturation` is a `0–1` factor (like `saturation` on a color def). |
-| Fallback | `darkHue` falls back to `hue`, `darkSaturation` to `saturation`, and the def falls back to the seed. Omitting everything reproduces the previous behavior exactly. |
-| Relative hue | `darkHue: '+N'` anchors to the theme's **dark** seed hue. A plain `hue: '+N'` with no `darkHue` also re-anchors to the dark seed, so a whole palette rotates together. |
-| Absolute hue | An absolute `hue` (no `darkHue`) is used verbatim in dark — absolute means absolute in every scheme. |
-| `darkDesaturation` | Bypassed as soon as any explicit dark saturation is authored, at either level. The value you write is the value you get. |
-| `mode: 'static'` | Ignores both. A static color is pinned to one hue and saturation across every scheme. |
-| Shadows and mixes | Have no channels of their own — they derive hue and saturation from their `bg` / `fg` / `target`, so they inherit dark overrides automatically. |
-
-With [`splitHue`](#hue-channel-splitting-splithue), a dark seed makes the hue
-custom properties scheme-dependent; Glaze re-declares them in the dark block
-automatically.
-
-#### Per-color `pastel`
-
-`pastel: true` on a single color def overrides the per-theme / per-token `pastel` override 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 theme/token `pastel` override (default `false`) — 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                                                                                                                                                             |
-| ----------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `type`      | `'shadow'`       | Discriminator.                                                                                                                                                          |
-| `bg`        | `string`         | Background color name — must reference a non-shadow color in the same theme.                                                                                            |
-| `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`.                                                                                                                                       |
+| Field | Type | Description |
+|---|---|---|
+| `type` | `'shadow'` | Discriminator. |
+| `bg` | `string` | Background color name — must reference a non-shadow color in the same theme. |
+| `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`. |
+| `inherit` | `boolean` | Inheritance flag, default `true`. |
 
 See [Shadows](#shadows) below for the algorithm and tuning details.
 
 ### `MixColorDef`
 
-| Field      | Type                        | Description                                                                                                                                                    |
-| ---------- | --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `type`     | `'mix'`                     | Discriminator.                                                                                                                                                 |
-| `base`     | `string`                    | "From" color name.                                                                                                                                             |
-| `target`   | `string`                    | "To" color name.                                                                                                                                               |
-| `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)).                                              |
-| `inherit`  | `boolean`                   | Inheritance flag, default `true`.                                                                                                                              |
+| Field | Type | Description |
+|---|---|---|
+| `type` | `'mix'` | Discriminator. |
+| `base` | `string` | "From" color name. |
+| `target` | `string` | "To" color name. |
+| `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<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.
 
@@ -719,155 +310,130 @@ glaze.color(color: GlazeFromInput | GlazeColorInput | GlazeColorValue, config?:
 
 `glaze.color()` accepts **four input shapes**, discriminated by structure:
 
-| 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). |
-| **`{ 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).                    |
+| Shape | Example | Notes |
+|---|---|---|
+| **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, lightness: 74 }` | Full theme-style token (hue/saturation/lightness all in 0–100). |
 
 `GlazeColorValue` (bare string or value-object forms) accepts:
 
-| Form                | Example                                        | Notes                                                                                                                                 |
-| ------------------- | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
-| Hex                 | `'#26fcb2'`, `'#26fcb2ff'`, `'#abc'`           | 3, 6, or 8 digits. Alpha is dropped with a `console.warn` — use `opacity` instead.                                                    |
-| `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). Not native CSS; it can also be serialized by [Tasty](https://tasty.style) exports. 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 }`                 | Direct OKHST input shape (h: 0–360, s/t: 0–1). The `t` key disambiguates it from `{ h, s, l }`.                                       |
-| `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, ... }`:
-
-| Field              | Type                                 | Description                                                                                                                                     |
-| ------------------ | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
-| `hue`              | `number`                             | 0–360.                                                                                                                                          |
-| `saturation`       | `number`                             | 0–100.                                                                                                                                          |
-| `tone`             | `HCPair<number \| ExtremeValue>`     | 0–100 (contrast-shaped) or `'max'`/`'min'`, optional HC pair.                                                                                   |
-| `saturationFactor` | `number`                             | Multiplier on the seed (0–1). Default: `1`.                                                                                                     |
-| `darkHue`          | `number \| RelativeValue`            | Dark-scheme hue. Absolute (0–360) or `'+N'`/`'-N'` relative to the dark seed hue (which defaults to `hue`). Falls back to `hue`.                 |
-| `darkSaturation`   | `number`                             | Dark-scheme seed saturation (0–100). Falls back to `saturation`.                                                                                |
-| `darkSaturationFactor` | `number`                         | Dark-scheme multiplier on the dark seed (0–1). Falls back to `saturationFactor`.                                                                |
-| `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 per-theme / per-token `pastel` override when omitted. See [Per-color `pastel`](#per-color-pastel). |
-| `role`             | `RoleInput`                          | Semantic role against `base` / the seed (see [Roles](#roles)). Fixes APCA polarity.                                                             |
-| `name`             | `string`                             | Debug label for warnings; doesn't change output keys. Reserved names (`'value'`, `'seed'`, `'externalBase'`) are rejected.                      |
+| Form | Example | Notes |
+|---|---|---|
+| Hex | `'#26fcb2'`, `'#26fcb2ff'`, `'#abc'` | 3, 6, or 8 digits. Alpha is dropped with a `console.warn` — use `opacity` instead. |
+| `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. |
+| `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 }` | 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, lightness, ... }`:
+
+| Field | Type | Description |
+|---|---|---|
+| `hue` | `number` | 0–360. |
+| `saturation` | `number` | 0–100. |
+| `lightness` | `HCPair<number>` | 0–100, optional HC pair. |
+| `saturationFactor` | `number` | Multiplier on the seed (0–1). Default: `1`. |
+| `mode` | `AdaptationMode` | Default: `'auto'`. |
+| `opacity` | `number` | Fixed alpha 0–1. |
+| `base` | `GlazeColorToken \| GlazeColorValue` | Optional dependency. See [Pairing colors](#pairing-colors). |
+| `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 }`:
 
-| Field              | Notes                                                                                                                                                       |
-| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `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. |
-| `saturationFactor` | Multiplier on the seed (0–1).                                                                                                                               |
-| `darkHue`          | Dark-scheme hue: absolute (0–360) or `'+N'`/`'-N'` relative to the dark seed hue. Falls back to `hue`.                                                      |
-| `darkSaturation`   | Dark-scheme seed saturation (0–100). Falls back to `saturation`.                                                                                            |
-| `darkSaturationFactor` | Dark-scheme multiplier on the dark seed (0–1). Falls back to `saturationFactor`.                                                                        |
-| `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.                                                |
-| `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 per-theme / per-token `pastel` override 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.                                                                                |
+| Field | Notes |
+|---|---|
+| `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). |
+| `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'`. |
+| `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. |
+| `name` | Debug label only — surfaces in warnings/errors. Does not change output keys. |
 
 Named CSS colors (`'red'`, `'blueviolet'`) are not supported.
 
 ### Defaults
 
-Every input form defaults to `mode: 'auto'` so the resolved token adapts between light and dark like an ordinary theme color. Tokens store a **sparse local** config override; omitted fields fall through to the live global at resolve time (same as themes). Authoring `.export(override?)` freezes `getConfig() ∪ local ∪ override` at call time.
+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` as a local default).
-  - Other omitted fields track the live global config.
-- **Structured input** (`{ hue, saturation, tone, ... }`):
-  - Omitted tone windows and other fields track the live global config (same as a theme color).
-- `pastel` is instance-only — set via the config override or per-color `pastel`, not `glaze.configure()`.
+  - 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
 // Bare string — adapts automatically
-glaze.color('#26fcb2');
+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.7 });
+glaze.color({ h: 152, s: 0.95, l: 0.74 })
 
 // From form — value + color overrides
-glaze.color({ from: '#1a1a2e', hue: '+20', contrast: 'AA' });
+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
 
 A `GlazeColorToken` exposes:
 
-| Method                                  | Description                                                                                                                                                                                                                |
-| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `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.json(options?)`                  | JSON map (no color-name key). Options: `format`, `modes`.                                                                                                                                                                  |
+| Method | Description |
+|---|---|
+| `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 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(override?)`               | JSON-safe snapshot — freezes effective config at call time; pass to `glaze.colorFrom(...)` to rehydrate. Optional `override` merges over the instance local (and nested `base` exports).                                  |
+| `token.export()` | JSON-safe snapshot — pass to `glaze.colorFrom(...)` to rehydrate. |
 
 ### Per-instance config override
 
-The optional `config` argument (`GlazeConfigOverride`) overrides
-resolve-relevant fields for a token or theme. A tone window can be
-`[lo, hi]`, `{ lo, hi, eps }`, or `false` (full range). Both themes and
-standalone tokens keep a sparse local override — omitted fields (except
-instance-only `pastel`) fall through to the live global at resolve time.
+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 / fixed) | 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).                                                                                        |
-| `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. |
-| `pastel`           | `false` (instance-only)       | Theme/token-level pastel default for colors that omit per-color `pastel`. Not available on `glaze.configure()`.                                                         |
-| `inferRole`        | `true`                        | Infer color `role` from the name when unset.                                                                                                                           |
-| `shadowTuning`     | `undefined`                   | Default shadow tuning (meaningful for themes; harmless on color tokens).                                                                                               |
+| Field | Default (from global) | Description |
+|---|---|---|
+| `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). |
+| `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, pastel: true });
+glaze.color({ hue: 152, saturation: 95, lightness: 74 }, { darkLightness: false })
 
 // Theme with config override
-const rawTheme = glaze(280, 80, { lightTone: false, pastel: true });
+const rawTheme = glaze(280, 80, { lightLightness: false })
 ```
 
-See [Theme config override](#theme-config-override).
+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)).
 
 ### Theme config override
 
@@ -877,31 +443,24 @@ 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(override?)` freezes `getConfig() ∪ instance local ∪ override` at
-call time. Restoring via `glaze.themeFrom(data)` (or the compat alias
-`glaze.from`) pins that freeze as the restored theme's local override — matching
-standalone color-token behavior.
+`theme.export()` includes `config`; `glaze.from(data)` restores it.
 
 ### `glaze.colorFrom(data)`
 
-Inverse of `token.export()`. The exported snapshot includes the original input,
-all overrides (with any `base` token recursively serialized), and the effective
-config freeze from export time — so later `glaze.configure()` calls don't change
-rehydrated tokens.
+Inverse of `token.export()`. The exported snapshot includes the original input, all overrides (with any `base` token recursively serialized), and the full effective config — so later `glaze.configure()` calls don't change rehydrated tokens.
 
 ```ts
 const text = glaze.color({ from: '#1a1a1a', contrast: 'AA' });
@@ -914,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');
@@ -922,11 +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.
-const border = glaze.color({
-  from: '#000000',
+// Border 8 lightness units lighter than `bg` in each scheme.
+const border = glaze.color({ from: '#000000',
   base: bg,
-  tone: '+8',
+  lightness: '+8',
   mode: 'fixed',
 });
 
@@ -937,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:
@@ -964,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 },
@@ -1004,22 +562,20 @@ theme.colors({
 
 Fine-tune behavior per-color or globally via `glaze.configure({ shadowTuning })`. Per-color `tuning` is merged field-by-field with the global one.
 
-| Parameter          | Default        | Description                                                                           |
-| ------------------ | -------------- | ------------------------------------------------------------------------------------- |
-| `saturationFactor` | `0.18`         | Fraction of fg saturation kept in pigment.                                            |
-| `maxSaturation`    | `0.25`         | Upper clamp on pigment saturation.                                                    |
-| `lightnessFactor`  | `0.25`         | Multiplier for bg lightness → pigment lightness.                                      |
-| `lightnessBounds`  | `[0.05, 0.20]` | Clamp range for pigment lightness.                                                    |
-| `minGapTarget`     | `0.05`         | Target minimum gap between pigment and bg lightness.                                  |
-| `alphaMax`         | `1.0`          | Asymptotic maximum alpha.                                                             |
-| `bgHueBlend`       | `0.2`          | Blend weight pulling pigment hue toward bg hue. `0` = pure fg hue, `1` = pure bg hue. |
+| Parameter | Default | Description |
+|---|---|---|
+| `saturationFactor` | `0.18` | Fraction of fg saturation kept in pigment. |
+| `maxSaturation` | `0.25` | Upper clamp on pigment saturation. |
+| `lightnessFactor` | `0.25` | Multiplier for bg lightness → pigment lightness. |
+| `lightnessBounds` | `[0.05, 0.20]` | Clamp range for pigment lightness. |
+| `minGapTarget` | `0.05` | Target minimum gap between pigment and bg lightness. |
+| `alphaMax` | `1.0` | Asymptotic maximum alpha. |
+| `bgHueBlend` | `0.2` | Blend weight pulling pigment hue toward bg hue. `0` = pure fg hue, `1` = pure bg hue. |
 
 ```ts
 theme.colors({
   'shadow-soft': {
-    type: 'shadow',
-    bg: 'surface',
-    intensity: 10,
+    type: 'shadow', bg: 'surface', intensity: 10,
     tuning: { alphaMax: 0.3, saturationFactor: 0.1 },
   },
 });
@@ -1047,12 +603,12 @@ const css = glaze.format(v, 'oklch');
 
 `GlazeShadowInput`:
 
-| Field       | Type              | Description                                                                    |
-| ----------- | ----------------- | ------------------------------------------------------------------------------ |
-| `bg`        | `GlazeColorValue` | Background. Any `GlazeColorValue` form. Alpha components dropped with warning. |
-| `fg`        | `GlazeColorValue` | Optional foreground. Same forms as `bg`.                                       |
-| `intensity` | `number`          | 0–100.                                                                         |
-| `tuning`    | `ShadowTuning`    | Optional.                                                                      |
+| Field | Type | Description |
+|---|---|---|
+| `bg` | `GlazeColorValue` | Background. Any `GlazeColorValue` form. Alpha components dropped with warning. |
+| `fg` | `GlazeColorValue` | Optional foreground. Same forms as `bg`. |
+| `intensity` | `number` | 0–100. |
+| `tuning` | `ShadowTuning` | Optional. |
 
 ### Fixed opacity (regular colors)
 
@@ -1060,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)'
 ```
@@ -1075,9 +631,9 @@ Produces a solid color by interpolating between `base` and `target`:
 
 ```ts
 theme.colors({
-  surface: { tone: 95 },
-  accent: { tone: 30 },
-  tint: { type: 'mix', base: 'surface', target: 'accent', value: 30 },
+  surface: { lightness: 95 },
+  accent:  { lightness: 30 },
+  tint:    { type: 'mix', base: 'surface', target: 'accent', value: 30 },
 });
 ```
 
@@ -1091,14 +647,11 @@ 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',
+    type: 'mix', base: 'surface', target: 'black',
+    value: 8, blend: 'transparent',
   },
 });
 // hover → black with alpha = 0.08
@@ -1108,10 +661,10 @@ The output color has `h`, `s`, `l` from the target and `alpha = value / 100`.
 
 ### Blend space (opaque only)
 
-| `space`             | Behavior                                  | Best for                                                 |
-| ------------------- | ----------------------------------------- | -------------------------------------------------------- |
-| `'okhsl'` (default) | Perceptually uniform OKHSL interpolation. | Design token derivation.                                 |
-| `'srgb'`            | Linear sRGB channel interpolation.        | Matching browser compositing of CSS color-mix / overlay. |
+| `space` | Behavior | Best for |
+|---|---|---|
+| `'okhsl'` (default) | Perceptually uniform OKHSL interpolation. | Design token derivation. |
+| `'srgb'` | Linear sRGB channel interpolation. | Matching browser compositing of CSS color-mix / overlay. |
 
 Transparent blending always composites in linear sRGB (matches browser alpha compositing).
 
@@ -1142,22 +695,10 @@ Mix colors can reference other mix colors:
 
 ```ts
 theme.colors({
-  white: { tone: 100, saturation: 0 },
-  black: { tone: 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',
-  },
+  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' },
 });
 ```
 
@@ -1179,67 +720,35 @@ const palette = glaze.palette(
 
 `GlazePaletteOptions`:
 
-| Option    | Description                                                                                                                                                                                                       |
-| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Option | Description |
+|---|---|
 | `primary` | Name of the primary theme. The primary's tokens are duplicated **without** prefix in all exports, providing convenient short aliases alongside the prefixed versions. Throws if the name doesn't match any theme. |
 
 A `GlazePalette` exposes:
 
-| Method                           | Description                                                                                          |
-| -------------------------------- | ---------------------------------------------------------------------------------------------------- |
-| `palette.list()`                 | Theme names in insertion order.                                                                      |
-| `palette.primary`                | Primary theme name, if set.                                                                          |
-| `palette.theme(name)`            | Get a live theme instance by name.                                                                   |
-| `palette.themes()`               | Shallow copy of the theme map (same instances the palette holds).                                    |
-| `palette.export(override?)`      | Authoring snapshot — restorable via `glaze.paletteFrom()`. Optional override forwarded to themes.    |
-| `palette.tokens(options?)`       | Flat token map grouped by scheme variant.                                                            |
-| `palette.tasty(options?)`        | [Tasty](https://tasty.style) style-to-state bindings.                                                |
-| `palette.json(options?)`         | Per-theme **resolved** color JSON (not restorable as authoring config).                              |
-| `palette.css(options?)`          | CSS custom property declaration strings.                                                             |
-| `palette.dtcg(options?)`         | Per-scheme W3C DTCG token trees.                                                                     |
-| `palette.dtcgResolver(options?)` | One DTCG Resolver-Module document for every scheme.                                                  |
-| `palette.tailwind(options?)`     | One Tailwind CSS v4 theme with scheme overrides.                                                     |
-
-### `palette.export(override?)` / `glaze.paletteFrom()`
-
-```ts
-const snapshot = palette.export();
-// → {
-//     kind: 'palette',
-//     version: 1,
-//     primary: 'brand',
-//     themes: { brand: { kind: 'theme', ... }, danger: { ... } },
-//   }
-
-const restored = glaze.paletteFrom(JSON.parse(JSON.stringify(snapshot)));
-const brand = restored.theme('brand')!;
-```
-
-Optional `override` is forwarded to each nested `theme.export(override)`.
-Config snapshot vs resolved output: use `export()` / `paletteFrom()` to
-persist and restore the authoring graph (themes, color defs, relations). Use
-`json()` / `tokens()` / `css()` / … to emit resolved color strings for apps
-and design tools.
+| Method | Description |
+|---|---|
+| `palette.tokens(options?)` | Flat token map grouped by scheme variant. |
+| `palette.tasty(options?)` | Tasty style-to-state bindings. |
+| `palette.json(options?)` | Per-theme JSON map (no prefix needed — keyed by theme name). |
+| `palette.css(options?)` | CSS custom property declaration strings. |
 
 ### `GlazePaletteExportOptions`
 
 Shared by `tokens`, `tasty`, and `css`:
 
-| Option    | Default                        | Description                                                                                  |
-| --------- | ------------------------------ | -------------------------------------------------------------------------------------------- |
-| `prefix`  | `true` (= `"<themeName>-"`)    | `false` disables prefixing. Or pass a custom map: `{ primary: 'brand-', danger: 'error-' }`. |
-| `primary` | inherits from palette creation | `string` to override, `false` to disable for this call.                                      |
+| Option | Default | Description |
+|---|---|---|
+| `prefix` | `true` (= `"<themeName>-"`) | `false` disables prefixing. Or pass a custom map: `{ primary: 'brand-', danger: 'error-' }`. |
+| `primary` | inherits from palette creation | `string` to override, `false` to disable for this call. |
 
 Each export method also accepts its own format/options shape:
 
-| Method                           | Additional options                        |
-| -------------------------------- | ----------------------------------------- |
-| `palette.tokens(options?)`       | `format`, `modes`                         |
-| `palette.tasty(options?)`        | `format`, `modes`, `states`               |
-| `palette.css(options?)`          | `format`, `suffix`                        |
-| `palette.dtcg(options?)`         | `colorSpace`, `modes`                     |
-| `palette.dtcgResolver(options?)` | `colorSpace`, `modes`, resolver names     |
-| `palette.tailwind(options?)`     | `format`, `modes`, selectors, `namespace` |
+| Method | Additional options |
+|---|---|
+| `palette.tokens(options?)` | `format`, `modes` |
+| `palette.tasty(options?)` | `format`, `modes`, `states` |
+| `palette.css(options?)` | `format`, `suffix` |
 
 `palette.css()` does not accept `modes`; it always returns all four CSS strings (`light`, `dark`, `lightContrast`, `darkContrast`).
 
@@ -1250,8 +759,8 @@ By default all palette tokens are prefixed:
 ```ts
 palette.tokens();
 // → {
-//   light: { 'primary-surface': 'oklch(...)', 'danger-surface': 'oklch(...)' },
-//   dark:  { 'primary-surface': 'oklch(...)', 'danger-surface': 'oklch(...)' },
+//   light: { 'primary-surface': 'okhsl(...)', 'danger-surface': 'okhsl(...)' },
+//   dark:  { 'primary-surface': 'okhsl(...)', 'danger-surface': 'okhsl(...)' },
 // }
 ```
 
@@ -1287,10 +796,10 @@ const palette = glaze.palette(
 palette.tokens();
 // → {
 //   light: {
-//     'primary-surface': 'oklch(...)',
-//     'danger-surface':  'oklch(...)',
-//     'success-surface': 'oklch(...)',
-//     'surface':         'oklch(...)',  // unprefixed alias
+//     'primary-surface': 'okhsl(...)',
+//     'danger-surface':  'okhsl(...)',
+//     'success-surface': 'okhsl(...)',
+//     'surface':         'okhsl(...)',  // unprefixed alias
 //   },
 // }
 ```
@@ -1316,8 +825,8 @@ JSON export groups by theme name (no prefix needed):
 ```ts
 palette.json();
 // → {
-//   primary: { surface: { light: 'oklch(...)', dark: 'oklch(...)' } },
-//   danger:  { surface: { light: 'oklch(...)', dark: 'oklch(...)' } },
+//   primary: { surface: { light: 'okhsl(...)', dark: 'okhsl(...)' } },
+//   danger:  { surface: { light: 'okhsl(...)', dark: 'okhsl(...)' } },
 // }
 ```
 
@@ -1336,113 +845,29 @@ 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
 
 Control the color format with the `format` option on any export method:
 
-| Format                                        | Output (alpha = 1) | Output (alpha < 1)   | Notes                                                                                         |
-| --------------------------------------------- | ------------------ | -------------------- | --------------------------------------------------------------------------------------------- |
-| `'oklch'` (default for CSS-string exports)    | `oklch(L C H)`     | `oklch(L C H / A)`   | OKLab-based LCH. Native CSS. Required for `splitHue`.                                       |
-| `'rgb'`                                       | `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.                                                                          |
-| `'okhsl'`                                     | `okhsl(H S% L%)`   | `okhsl(H S% L% / A)` | Glaze's native format, not a CSS function. **[Tasty](https://tasty.style)-only** (`tasty()`, `token()`, `.tasty()`). |
-| `'okhst'`                                     | `okhst(H S% T%)`   | `okhst(H S% T% / A)` | OKHST tone axis. **[Tasty](https://tasty.style)-only** — same restriction as `okhsl`.                                |
+| Format | Output (alpha = 1) | Output (alpha < 1) | Notes |
+|---|---|---|---|
+| `'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({ format: 'rgb' }); // 'rgb(244 240 250)'
-theme.tasty(); // 'oklch(0.965 0.0123 280)'   (default)
-theme.tasty({ format: 'okhst' }); // 'okhst(280 60% 97%)'
+theme.tokens();                    // 'okhsl(280 60% 97%)'
+theme.tokens({ format: 'rgb' });   // 'rgb(244 240 250)'
+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](https://tasty.style) 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` on the theme/token override 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.
-
-**Dark hues:** hue vars are scheme-independent unless the theme or a color authors a [dark hue](#dark-seed-darkhue--darksaturation). When one does, the whole hue set is re-declared in the dark block (and in the Tasty dark state, gated by `modes.dark`):
-
-```css
-/* glaze({ hue: 240, saturation: 18, darkHue: 200 }) */
-:root {
-  --brand-hue: 240;
-  --accent-hue: calc(var(--brand-hue) + 20);
-}
-/* dark */
---brand-hue: 200;
---accent-hue: calc(var(--brand-hue) + 20);
-```
-
-`--accent-hue` repeats verbatim on purpose: a custom property substitutes `var()` at computed-value time on the element that declares it, so it has to be re-declared to pick up the new `--brand-hue`. Colors with `mode: 'static'` are pinned to an absolute hue instead, so they don't drift with the dark seed.
-
-**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()`.
 
 ---
 
@@ -1450,84 +875,87 @@ On `theme.css()`, `theme.tasty()`, `palette.css()`, `palette.tasty()`, and stand
 
 `mode` controls how a color adapts across schemes:
 
-| Mode               | Behavior                                                                                                                                     |
-| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
-| `'auto'` (default) | Full adaptation. Dark uses **dark tone inversion** (`100 − t`) and then remaps into the dark tone 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.                                                                                                    |
+| Mode | Behavior |
+|---|---|
+| `'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. If the mirror also overshoots, the original side is kept and clamped. 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 a single tone pipeline; there is no Möbius curve. See
-[Scheme adaptation](okhst.md#scheme-adaptation) for the product-level model and
-the [canonical OKHST specification](https://github.com/tenphi/okhst) for the
-transfer math.
-
-### Light scheme
+### Light scheme — lightness
 
-An authored tone (0–100) is remapped into the `lightTone` **tone window**.
-The window's `lo`/`hi` are OKHSL-lightness boundaries (0–100); authored tone is
-positioned within the corresponding tone interval and converted to 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
 ```
 
-The inversion preserves authored tone spacing without a fitted curve. This is
-exactly contrast-even for neutrals and approximate for chromatic colors. The
-ordinary light/dark asymmetry lives in the two windows' `(lo, hi, eps)` values
-(`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
 
 `darkDesaturation` reduces saturation for all colors in dark scheme:
 
 ```ts
-S_dark = S_light * (1 - darkDesaturation); // default: 0.1
+S_dark = S_light * (1 - darkDesaturation) // default: 0.1
 ```
 
 `static` mode skips desaturation.
@@ -1538,12 +966,13 @@ 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: '@media(prefers-color-scheme: dark)',
-    highContrast: '@media(prefers-contrast: more)',
+    dark: '@dark',
+    highContrast: '@high-contrast',
   },
   modes: {
     dark: true,
@@ -1556,33 +985,28 @@ glaze.configure({
 });
 ```
 
-A `ToneWindow` is `[lo, hi]` (OKHSL-lightness boundaries, reference eps — the
-common form), `{ lo, hi, eps }` (advanced: explicit per-scheme render eps), or
-`false` for the full range `[0, 100]` at the reference eps. `false` removes the
-boundaries, not the tone transfer.
-
 `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.                                                                                                                                                                                                                                                                                                                   |
-| `darkDesaturation`    | `0.1`                                  | Saturation reduction in dark scheme (0–1).                                                                                                                                                                                                                                                                                                                                                                                |
-| `states.dark`         | `'@media(prefers-color-scheme: dark)'` | State alias for dark mode tokens ([Tasty](https://tasty.style) export). Defaults to a media query so tokens react to the OS preference without registering custom states.                                                                                                                                                                                                                                                                        |
-| `states.highContrast` | `'@media(prefers-contrast: more)'`     | State alias for HC tokens ([Tasty](https://tasty.style) export).                                                                                                                                                                                                                                                                                                                                                                                 |
-| `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). |
-| `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).                                                                                                                                                                                                                     |
-
-| Method                    | Description                                                                         |
-| ------------------------- | ----------------------------------------------------------------------------------- |
+| Field | Default | Description |
+|---|---|---|
+| `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` | 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 |
+|---|---|
 | `glaze.configure(config)` | Merge into the global config. Bumps a config version that invalidates theme caches. |
-| `glaze.getConfig()`       | Snapshot the current resolved config (shallow copy).                                |
-| `glaze.resetConfig()`     | Reset to defaults (also bumps the version counter).                                 |
+| `glaze.getConfig()` | Snapshot the current resolved config (shallow copy). |
+| `glaze.resetConfig()` | Reset to defaults (also bumps the version counter). |
 
-Themes and standalone color tokens keep a sparse local `GlazeConfigOverride` and merge the live global at resolve time for omitted fields. Authoring `.export(override?)` freezes the effective merge at call time; restored instances pin that freeze. `pastel` is instance-only (theme/token override or per-color) — not set via `configure()`.
+Standalone `glaze.color()` tokens snapshot the resolve-relevant fields at create time, so later `configure()` calls don't change already-created tokens. Themes merge the live global at resolve time for fields not overridden via `GlazeConfigOverride`.
 
 ---
 
@@ -1612,38 +1036,30 @@ Resolution priority (highest first):
 
 ## Validation
 
-Invalid definitions throw before resolution when Glaze cannot produce a
-well-defined dependency graph. Recoverable numeric bounds are clamped. A
-physically unreachable contrast floor or a potentially misleading
-contrast/opacity combination emits `console.warn` and returns the closest
-available result.
-
-| Condition                                           | Behavior                                                                                                 |
-| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
-| `contrast` without `base` in a **theme** color      | Validation error                                                                                         |
-| Relative `tone` 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). If the mirror also overshoots, clamp on the authored side. |
-| `tone` resolves outside 0–100                       | Clamp silently                                                                                           |
-| `'max'` / `'min'` without `base`                    | Allowed — resolves to the scheme's tone extreme (root color)                                             |
-| `saturation` outside 0–1                            | Clamp silently                                                                                           |
-| Circular `base` references                          | Validation error                                                                                         |
-| `base` references non-existent name                 | Validation error                                                                                         |
-| Shadow `bg` references non-existent color           | Validation error                                                                                         |
-| Shadow `fg` references non-existent color           | Validation error                                                                                         |
-| Shadow `bg` references another shadow color         | Validation error                                                                                         |
-| Shadow `fg` references another shadow color         | Validation error                                                                                         |
-| Regular color `base` references a shadow color      | Validation error                                                                                         |
-| Shadow `intensity` outside 0–100                    | Clamp silently                                                                                           |
-| `contrast` + `opacity` combined                     | `console.warn`                                                                                           |
-| Mix `base` references non-existent color            | Validation error                                                                                         |
-| Mix `target` references non-existent color          | Validation error                                                                                         |
-| Mix `base` references a shadow color                | Validation error                                                                                         |
-| Mix `target` references a shadow color              | Validation error                                                                                         |
-| Mix `value` outside 0–100                           | Clamp silently                                                                                           |
-| Circular references involving mix colors            | Validation error                                                                                         |
-| Contrast target physically unreachable              | `console.warn` (deduped per `(name, scheme, target)`); closest passing variant returned                  |
+| Condition | Behavior |
+|---|---|
+| `contrast` 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 `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 |
+| Shadow `bg` references non-existent color | Validation error |
+| Shadow `fg` references non-existent color | Validation error |
+| Shadow `bg` references another shadow color | Validation error |
+| Shadow `fg` references another shadow color | Validation error |
+| Regular color `base` references a shadow color | Validation error |
+| Shadow `intensity` outside 0–100 | Clamp silently |
+| `contrast` + `opacity` combined | `console.warn` |
+| Mix `base` references non-existent color | Validation error |
+| Mix `target` references non-existent color | Validation error |
+| Mix `base` references a shadow color | Validation error |
+| Mix `target` references a shadow color | Validation error |
+| Mix `value` outside 0–100 | Clamp silently |
+| Circular references involving mix colors | Validation error |
+| Contrast target physically unreachable | `console.warn` (deduped per `(name, scheme, target)`); closest passing variant returned |
 
 ---
 
@@ -1669,19 +1085,19 @@ import {
 } from '@tenphi/glaze';
 ```
 
-| Function                              | Description                                                              |
-| ------------------------------------- | ------------------------------------------------------------------------ |
-| `okhslToLinearSrgb(h, s, l)`          | OKHSL (h: 0–360, s/l: 0–1) → linear sRGB tuple.                          |
-| `okhslToSrgb(h, s, l)`                | OKHSL → gamma-encoded sRGB tuple (0–1 per channel).                      |
-| `okhslToOklab([h, s, l])`             | OKHSL → OKLab `[L, a, b]`.                                               |
-| `oklabToOkhsl([L, a, b])`             | OKLab → OKHSL.                                                           |
-| `srgbToOkhsl([r, g, b])`              | Gamma sRGB (0–1) → OKHSL.                                                |
-| `hslToSrgb(h, s, l)`                  | CSS HSL → sRGB tuple.                                                    |
-| `parseHex(hex)`                       | Parse `#rgb` / `#rrggbb` to sRGB tuple. Returns `null` on invalid input. |
-| `parseHexAlpha(hex)`                  | Parse `#rgb` / `#rrggbb` / `#rrggbbaa`; returns `[r, g, b, a?]`.         |
-| `relativeLuminanceFromLinearRgb(rgb)` | WCAG relative luminance from linear sRGB.                                |
-| `contrastRatioFromLuminance(yA, yB)`  | WCAG contrast ratio from two luminances.                                 |
-| `gamutClampedLuminance(linearRgb)`    | Relative luminance with channel clamping for out-of-gamut colors.        |
+| Function | Description |
+|---|---|
+| `okhslToLinearSrgb(h, s, l)` | OKHSL (h: 0–360, s/l: 0–1) → linear sRGB tuple. |
+| `okhslToSrgb(h, s, l)` | OKHSL → gamma-encoded sRGB tuple (0–1 per channel). |
+| `okhslToOklab([h, s, l])` | OKHSL → OKLab `[L, a, b]`. |
+| `oklabToOkhsl([L, a, b])` | OKLab → OKHSL. |
+| `srgbToOkhsl([r, g, b])` | Gamma sRGB (0–1) → OKHSL. |
+| `hslToSrgb(h, s, l)` | CSS HSL → sRGB tuple. |
+| `parseHex(hex)` | Parse `#rgb` / `#rrggbb` to sRGB tuple. Returns `null` on invalid input. |
+| `parseHexAlpha(hex)` | Parse `#rgb` / `#rrggbb` / `#rrggbbaa`; returns `[r, g, b, a?]`. |
+| `relativeLuminanceFromLinearRgb(rgb)` | WCAG relative luminance from linear sRGB. |
+| `contrastRatioFromLuminance(yA, yB)` | WCAG contrast ratio from two luminances. |
+| `gamutClampedLuminance(linearRgb)` | Relative luminance with channel clamping for out-of-gamut colors. |
 
 ### Format writers
 
@@ -1689,77 +1105,42 @@ import {
 import { formatOkhsl, formatRgb, formatHsl, formatOklch } from '@tenphi/glaze';
 
 formatOkhsl(280, 60, 95); // 'okhsl(280 60% 95%)'
-formatRgb(280, 60, 95); // 'rgb(244 240 250)'
-formatHsl(280, 60, 95); // 'hsl(280 60% 95%)'
+formatRgb(280, 60, 95);   // 'rgb(244 240 250)'
+formatHsl(280, 60, 95);   // 'hsl(280 60% 95%)'
 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` stores `{ h, s, t, alpha }` (tone, not lightness). Use
-`variantToOkhsl(variant).l` to recover OKHSL lightness. See
-[OKHST in Glaze](okhst.md) for the 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? }`.                                                                                                                                                                                                                                 |
-| `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`).
-
-`findToneForContrast` 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.                                                                                                                                   |
-| `baseLinearRgb`    | —                    | Base color as linear sRGB tuple.                                                                                                                                                                       |
-| `contrast`         | —                    | `ResolvedContrast` (`{ metric, target }`).                                                                                                                                                             |
-| `toneRange`        | `[0, 1]`             | Search bounds in tone.                                                                                                                                                                                 |
-| `epsilon`          | `1e-4`               | Convergence threshold.                                                                                                                                                                                 |
-| `maxIterations`    | `18`                 | Max binary-search iterations per branch.                                                                                                                                                               |
-| `initialDirection` | higher-contrast side | Direction to search first (`'lighter'` or `'darker'`).                                                                                                                                                 |
-| `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.
+| Function | Description |
+|---|---|
+| `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. |
+| `resolveMinContrast(value)` | Resolves a `MinContrast` (preset or number) to a numeric ratio. |
+
+`findLightnessForContrast` options:
+
+| Option | Default | Description |
+|---|---|---|
+| `hue` | — | Candidate hue (0–360). |
+| `saturation` | — | Candidate saturation (0–1). |
+| `preferredLightness` | — | Preferred candidate lightness (0–1). Kept if it already meets the target. |
+| `baseLinearRgb` | — | Base color as linear sRGB tuple. |
+| `contrast` | — | WCAG floor (`MinContrast`). |
+| `lightnessRange` | `[0, 1]` | Search bounds. |
+| `epsilon` | `1e-4` | Convergence threshold. |
+| `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: `{ lightness, contrast, met, branch: 'lighter' | 'darker' | 'preferred', flipped? }`. `flipped: true` indicates the initial direction failed and the opposite direction satisfied the target.