@tenphi/glaze 0.0.0-snapshot.9a14acf → 0.0.0-snapshot.9dc79fc

package/dist/index.cjs

@@ -370,6 +370,27 @@ const sRGBGammaToLinear = (val) => {
 	const abs = Math.abs(val);
 	return abs <= .04045 ? val / 12.92 : sign * Math.pow((abs + .055) / 1.055, 2.4);
 };
+/** Gamma-encoded sRGB clamped to the display gamut — what a browser paints. */
+function toDisplayGamma(linearRgb) {
+	return [
+		Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[0]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[1]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[2])))
+	];
+}
+/**
+* Browser alpha compositing: `source-over` interpolates the gamma-encoded
+* channels, not linear light (50% black over white paints `#808080`).
+* Takes display-gamma inputs and returns the composite as linear sRGB for
+* the luminance pipeline.
+*/
+function compositeOverGamma(baseGamma, overlayGamma, alpha) {
+	return [
+		sRGBGammaToLinear(baseGamma[0] + (overlayGamma[0] - baseGamma[0]) * alpha),
+		sRGBGammaToLinear(baseGamma[1] + (overlayGamma[1] - baseGamma[1]) * alpha),
+		sRGBGammaToLinear(baseGamma[2] + (overlayGamma[2] - baseGamma[2]) * alpha)
+	];
+}
 /**
 * Convert OKHSL to gamma-encoded sRGB (clamped to 0–1).
 * h: 0–360, s: 0–1, l: 0–1. Returns [r, g, b] with each channel 0–1.
@@ -402,6 +423,11 @@ function gamutClampedLuminance(linearRgb) {
 * soft-clamp threshold in `apcaContrast` is calibrated against this basis,
 * so the solver must feed it `Ys`, not WCAG relative luminance. Channels
 * are gamut-clamped to [0, 1] first, matching `gamutClampedLuminance`.
+*
+* This is exactly the luminance Glaze's contrast solver (and its drift
+* check) feeds `apcaContrast`, so
+* `apcaContrast(apcaLuminanceFromLinearRgb(text), apcaLuminanceFromLinearRgb(bg))`
+* reproduces the solver's Lc for a resolved pair.
 */
 function apcaLuminanceFromLinearRgb(linearRgb) {
 	const r = Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[0])));
@@ -507,7 +533,9 @@ function hslToSrgb(h, s, l) {
 }
 /**
 * Parse a hex color string (#rgb or #rrggbb) to sRGB [r, g, b] in 0–1 range.
-* Returns null if the string is not a valid hex color.
+* The leading `#` is optional. Returns null if the string is not a valid hex
+* color: a wrong length, any character outside `0-9a-f` (case-insensitive),
+* or a form with alpha.
 *
 * For 8-digit hex (`#rrggbbaa`) and 4-digit hex (`#rgba`) with alpha,
 * use {@link parseHexAlpha}.
@@ -517,66 +545,33 @@ function parseHex(hex) {
 	if (!result || result.alpha !== void 0) return null;
 	return result.rgb;
 }
+/** Hex digits only — no sign, whitespace, or `0x` prefix. */
+const HEX_DIGITS_RE = /^[0-9a-f]+$/i;
 /**
 * Parse a hex color string (#rgb, #rrggbb, #rgba, or #rrggbbaa) to
 * sRGB [r, g, b] in 0–1 range plus an optional alpha (0–1).
-* Returns null if the string is not a valid hex color.
+* The leading `#` is optional. Returns null if the string is not a valid hex
+* color: a wrong length or any character outside `0-9a-f`
+* (case-insensitive).
+*
+* Every digit is checked up front: `parseInt` alone stops at the first bad
+* character, so `'#1z2z3z'` would otherwise read as `#010203`.
 */
 function parseHexAlpha(hex) {
 	const h = hex.startsWith("#") ? hex.slice(1) : hex;
-	if (h.length === 3) {
-		const r = parseInt(h[0] + h[0], 16);
-		const g = parseInt(h[1] + h[1], 16);
-		const b = parseInt(h[2] + h[2], 16);
-		if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
-		return { rgb: [
-			r / 255,
-			g / 255,
-			b / 255
-		] };
-	}
-	if (h.length === 4) {
-		const r = parseInt(h[0] + h[0], 16);
-		const g = parseInt(h[1] + h[1], 16);
-		const b = parseInt(h[2] + h[2], 16);
-		const a = parseInt(h[3] + h[3], 16);
-		if (isNaN(r) || isNaN(g) || isNaN(b) || isNaN(a)) return null;
-		return {
-			rgb: [
-				r / 255,
-				g / 255,
-				b / 255
-			],
-			alpha: a / 255
-		};
-	}
-	if (h.length === 6) {
-		const r = parseInt(h.slice(0, 2), 16);
-		const g = parseInt(h.slice(2, 4), 16);
-		const b = parseInt(h.slice(4, 6), 16);
-		if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
-		return { rgb: [
-			r / 255,
-			g / 255,
-			b / 255
-		] };
-	}
-	if (h.length === 8) {
-		const r = parseInt(h.slice(0, 2), 16);
-		const g = parseInt(h.slice(2, 4), 16);
-		const b = parseInt(h.slice(4, 6), 16);
-		const a = parseInt(h.slice(6, 8), 16);
-		if (isNaN(r) || isNaN(g) || isNaN(b) || isNaN(a)) return null;
-		return {
-			rgb: [
-				r / 255,
-				g / 255,
-				b / 255
-			],
-			alpha: a / 255
-		};
-	}
-	return null;
+	if (!HEX_DIGITS_RE.test(h)) return null;
+	const full = h.length === 3 || h.length === 4 ? Array.from(h, (digit) => digit + digit).join("") : h;
+	if (full.length !== 6 && full.length !== 8) return null;
+	const channel = (i) => parseInt(full.slice(i, i + 2), 16) / 255;
+	const rgb = [
+		channel(0),
+		channel(2),
+		channel(4)
+	];
+	return full.length === 8 ? {
+		rgb,
+		alpha: channel(6)
+	} : { rgb };
 }
 function fmt$1(value, decimals) {
 	return parseFloat(value.toFixed(decimals)).toString();
@@ -672,6 +667,16 @@ function formatOklch(h, s, l, pastel = false) {
 	return `oklch(${fmt$1(L, 4)} ${fmt$1(C, 4)} ${fmt$1(hh, 2)})`;
 }
 /**
+* Format linear sRGB channels as a CSS `color(srgb-linear R G B)` string with
+* 4 decimals. Unlike the other writers it takes linear light, not OKHSL, and
+* does not clamp: a channel may exceed 1, which is how an HDR glow value
+* (`glaze.formatHdr()`) goes past SDR white — `1` is SDR white, `2` one stop
+* above it. Opaque only; HDR values carry no alpha.
+*/
+function formatSrgbLinear(rgb) {
+	return `color(srgb-linear ${fmt$1(rgb[0], 4)} ${fmt$1(rgb[1], 4)} ${fmt$1(rgb[2], 4)})`;
+}
+/**
 * Convert gamma-encoded sRGB channels (0–1) to a 6-digit lowercase hex
 * string (`#rrggbb`). Channels are clamped to [0,1] and rounded to 8-bit.
 * Alpha is not encoded here — DTCG carries it as a separate `alpha` field.
@@ -697,217 +702,6 @@ function okhslToOklch(h, s, l, pastel = false) {
 	];
 }
 
-//#endregion
-//#region src/config.ts
-/**
-* Build a fresh defaults object. Called from module init and from
-* `resetConfig()` so the two paths can't drift.
-*
-* `pastel: false` is a fixed instance default — not globally configurable.
-*/
-function defaultConfig() {
-	return {
-		lightTone: {
-			lo: 10,
-			hi: 100,
-			eps: .05
-		},
-		darkTone: {
-			lo: 15,
-			hi: 95,
-			eps: .05
-		},
-		darkDesaturation: .1,
-		states: {
-			dark: "@media(prefers-color-scheme: dark)",
-			highContrast: "@media(prefers-contrast: more)"
-		},
-		modes: {
-			dark: true,
-			highContrast: false
-		},
-		autoFlip: true,
-		pastel: false,
-		inferRole: true,
-		contrastLevel: "auto"
-	};
-}
-/**
-* Validate an authored `contrastLevel`. Numbers clamp to 0–100 so a slider
-* can't produce an out-of-range level; a non-finite number throws rather than
-* silently reading as `'auto'`, which would turn a `NaN` slider value into an
-* invisible no-op.
-*/
-function normalizeContrastLevel(value) {
-	if (value === void 0 || value === "auto") return "auto";
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`glaze: contrastLevel must be a finite number 0–100 or 'auto' (got ${String(value)}).`);
-	return Math.max(0, Math.min(100, value));
-}
-let globalConfig = defaultConfig();
-/**
-* Monotonic counter incremented on every `configure()` / `resetConfig()`
-* call. Theme / palette caches read this to invalidate stale resolve
-* results when the config changes between exports.
-*/
-let configVersion = 0;
-/** Live reference to the current config. Mutated by `configure()` / `resetConfig()`. */
-function getConfig() {
-	return globalConfig;
-}
-function getConfigVersion() {
-	return configVersion;
-}
-/**
-* Public-facing snapshot used by `glaze.getConfig()`. Returns a shallow
-* copy so callers can't mutate the live config.
-*/
-function snapshotConfig() {
-	return { ...globalConfig };
-}
-function configure(config) {
-	configVersion++;
-	globalConfig = {
-		lightTone: config.lightTone ?? globalConfig.lightTone,
-		darkTone: config.darkTone ?? globalConfig.darkTone,
-		darkDesaturation: config.darkDesaturation ?? globalConfig.darkDesaturation,
-		states: {
-			dark: config.states?.dark ?? globalConfig.states.dark,
-			highContrast: config.states?.highContrast ?? globalConfig.states.highContrast
-		},
-		modes: {
-			dark: config.modes?.dark ?? globalConfig.modes.dark,
-			highContrast: config.modes?.highContrast ?? globalConfig.modes.highContrast
-		},
-		shadowTuning: config.shadowTuning ?? globalConfig.shadowTuning,
-		autoFlip: config.autoFlip ?? globalConfig.autoFlip,
-		pastel: false,
-		inferRole: config.inferRole ?? globalConfig.inferRole,
-		contrastLevel: normalizeContrastLevel(config.contrastLevel ?? globalConfig.contrastLevel)
-	};
-}
-function resetConfig() {
-	configVersion++;
-	globalConfig = defaultConfig();
-}
-/**
-* Merge a per-instance config override over a base resolved config.
-* Only fields present in `override` are replaced; others fall through
-* from `base`. `false` for tone windows passes through as-is
-* (treated as the full range by `activeWindow()` in okhst.ts).
-*
-* `pastel` is instance-only: `override.pastel ?? false`, never inherited
-* from the global base.
-*/
-function mergeConfig(base, override) {
-	if (!override) return base.pastel === false ? base : {
-		...base,
-		pastel: false
-	};
-	return {
-		lightTone: override.lightTone !== void 0 ? override.lightTone : base.lightTone,
-		darkTone: override.darkTone !== void 0 ? override.darkTone : base.darkTone,
-		darkDesaturation: override.darkDesaturation ?? base.darkDesaturation,
-		states: base.states,
-		modes: base.modes,
-		shadowTuning: override.shadowTuning ?? base.shadowTuning,
-		autoFlip: override.autoFlip ?? base.autoFlip,
-		pastel: override.pastel ?? false,
-		inferRole: override.inferRole ?? base.inferRole,
-		contrastLevel: normalizeContrastLevel(override.contrastLevel ?? base.contrastLevel)
-	};
-}
-/**
-* Freeze `getConfig() ∪ instanceLocal ∪ exportArg` as a plain, resolve-relevant
-* override for authoring export, so restored snapshots pin these fields. Later
-* wins; nested objects (`shadowTuning`) replace wholesale. The final
-* `structuredClone` detaches tone-window / shadow objects that `mergeConfig`
-* may still share with the live global config.
-*/
-function freezeConfigForExport(instanceLocal, exportArg) {
-	const effective = mergeConfig(getConfig(), {
-		...instanceLocal,
-		...exportArg
-	});
-	const out = {
-		lightTone: effective.lightTone,
-		darkTone: effective.darkTone,
-		darkDesaturation: effective.darkDesaturation,
-		autoFlip: effective.autoFlip,
-		pastel: effective.pastel,
-		inferRole: effective.inferRole
-	};
-	if (effective.shadowTuning !== void 0) out.shadowTuning = effective.shadowTuning;
-	const authoredLevel = exportArg?.contrastLevel ?? instanceLocal?.contrastLevel;
-	if (authoredLevel !== void 0) out.contrastLevel = normalizeContrastLevel(authoredLevel);
-	return structuredClone(out);
-}
-
-//#endregion
-//#region src/types.ts
-/**
-* Current authoring-export schema version. Bump when the export shape
-* changes in a non-compatible way. Written on every `.export()` snapshot.
-*/
-const GLAZE_EXPORT_VERSION = 1;
-
-//#endregion
-//#region src/serialize.ts
-/**
-* Authoring-export helpers: schema version, type guards, and restore
-* validation shared by `themeFrom` / `colorFrom` / `paletteFrom`.
-*/
-function isPlainObject(data) {
-	return typeof data === "object" && data !== null && !Array.isArray(data);
-}
-/**
-* Reject unknown / invalid schema versions. Missing `version` is allowed
-* (legacy snapshots). Present versions must be an integer in
-* `1..=GLAZE_EXPORT_VERSION`.
-*/
-function assertExportVersion(data, factory) {
-	if (data.version === void 0) return;
-	if (typeof data.version !== "number" || !Number.isInteger(data.version) || data.version < 1) throw new Error(`${factory}: invalid "version" field — expected an integer >= 1 (got ${JSON.stringify(data.version)}).`);
-	if (data.version > GLAZE_EXPORT_VERSION) throw new Error(`${factory}: unsupported export version ${data.version} (this library supports version ${GLAZE_EXPORT_VERSION}). Upgrade @tenphi/glaze to load this snapshot.`);
-}
-/**
-* When `kind` is present, it must match the factory. Missing `kind` is
-* allowed for legacy snapshots.
-*/
-function assertExportKind(data, expected, factory) {
-	if (data.kind === void 0) return;
-	if (data.kind !== expected) throw new Error(`${factory}: expected kind "${expected}", got ${JSON.stringify(data.kind)}.`);
-}
-function hasThemeShape(data) {
-	return typeof data.hue === "number" && typeof data.saturation === "number" && !("form" in data) && !("themes" in data);
-}
-function hasColorTokenShape(data) {
-	return data.form === "value" || data.form === "structured";
-}
-function hasPaletteShape(data) {
-	return isPlainObject(data.themes) && !("form" in data) && typeof data.hue !== "number";
-}
-/** Type guard for theme authoring snapshots (prefers `kind`, falls back to shape). */
-function isThemeExport(data) {
-	if (!isPlainObject(data)) return false;
-	if (data.kind === "theme") return hasThemeShape(data);
-	if (data.kind !== void 0) return false;
-	return hasThemeShape(data);
-}
-/** Type guard for color-token authoring snapshots. */
-function isColorTokenExport(data) {
-	if (!isPlainObject(data)) return false;
-	if (data.kind === "color") return hasColorTokenShape(data);
-	if (data.kind !== void 0) return false;
-	return hasColorTokenShape(data);
-}
-/** Type guard for palette authoring snapshots. */
-function isPaletteExport(data) {
-	if (!isPlainObject(data)) return false;
-	if (data.kind === "palette") return hasPaletteShape(data);
-	if (data.kind !== void 0) return false;
-	return hasPaletteShape(data);
-}
-
 //#endregion
 //#region src/hc-pair.ts
 function pairNormal(p) {
@@ -923,6 +717,22 @@ function lerp(a, b, f) {
 	return a + (b - a) * f;
 }
 /**
+* A rejected input as a validation error shows it. Numbers and `undefined`
+* via `String` (`JSON.stringify(NaN)` is "null"), a bigint with its `n`
+* (JSON can't write one), anything else via JSON so a string shows its quotes
+* and an array its shape — falling back to `String` for what JSON can't write
+* (a symbol, a function, a cycle).
+*/
+function showValue(value) {
+	if (typeof value === "number" || value === void 0) return String(value);
+	if (typeof value === "bigint") return `${value}n`;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/**
 * Blend fraction at/above which an un-interpolable HC pair switches from its
 * normal entry to its high-contrast one (level 50).
 */
@@ -962,7 +772,7 @@ function hcMirrorsNormal(config) {
 	return contrastFraction(config) === 1;
 }
 /**
-* A numeric HC pair at a blend fraction (shadow `intensity`, mix `value`).
+* A numeric HC pair at a blend fraction (shadow / glow `intensity`, mix `value`).
 *
 * The endpoints return the authored entry *by identity* rather than through
 * float arithmetic — `a + (b - a) * 1` is not bit-exactly `b` in IEEE 754, and
@@ -1080,12 +890,18 @@ function isAbsoluteTone(tone) {
 * - the `{ h, s, t }` <-> `{ h, s, l }` color-space converters,
 * - the resolved-variant edge adapter (`variantToOkhsl`),
 * - the per-scheme tone mapping that replaced the Möbius dark curve
-*   (`mapToneForScheme`), the dark desaturation reducer, and the solver's scheme
-*   tone range,
-* - the scheme tone window, including the high-contrast bypass and its
-*   continuous generalization under a manual contrast level.
+*   (`mapToneForScheme`) and its per-scheme inverses (`unmapLightTone` /
+*   `unmapDarkTone`, which the resolver uses to find where a base sits on the
+*   authored scale), the dark map off that scale (`mapDarkToneUnclamped`, for a
+*   step from a base pushed past the dark window) and the dark-window
+*   comparison across configs (`sameDarkWindow`), the dark desaturation
+*   reducer, and the scheme tone range that clamps a contrast-solved color's
+*   preferred tone,
+* - the scheme tone window — validated and clamped by `normalizeToneWindow` —
+*   including the high-contrast bypass and its continuous generalization under
+*   a manual contrast level.
 *
-* See `docs/okhst.md` for the full specification and the calibrated
+* See `docs/okhst.mdx` for the full specification and the calibrated
 * default constants.
 */
 /**
@@ -1160,27 +976,51 @@ function variantToOkhsl(v) {
 	};
 }
 /**
-* Normalize any {@link ToneWindow} form to `{ lo, hi, eps }`.
+* Largest render eps a tone window accepts. The transfers divide by
+* `log(1 + eps) - log(eps)`, which loses precision as eps grows (colors are
+* visibly wrong by ~1e14) and cancels to 0 — `NaN` tones — from ~1e15. At 1e6
+* the tone ↔ luminance round trip still holds to ~1e-9, and past ~1e3 the
+* curve is already linear in luminance, so the cap costs nothing usable.
+*/
+const MAX_WINDOW_EPS = 1e6;
+/**
+* Normalize any {@link ToneWindow} form to `{ lo, hi, eps }`, validated.
 * - `false`: full range `[0, 100]` at the reference eps (boundaries removed,
 *   curve preserved).
 * - `[lo, hi]`: endpoints at the reference eps (the common form).
-* - `{ lo, hi, eps }`: passed through (advanced eps tuning).
+* - `{ lo, hi, eps }`: an explicit render eps (advanced eps tuning).
+*
+* A bad window never fails on its own — `[90, 20]` silently inverts the scale
+* and an `eps` of 0 turns every tone into `NaN` — so this throws a `glaze:`
+* error when the value is none of the three forms, an endpoint is not a finite
+* number, `lo > hi`, or `eps` is not a finite number in `(0, MAX_WINDOW_EPS]`.
+* Endpoints then clamp into `[0, 100]`, the OKHSL lightness range. `lo === hi`
+* is allowed: a zero-width window renders every tone at that one lightness.
+*
+* `field` names the window in the error message (`lightTone` / `darkTone`).
 */
-function normalizeToneWindow(win) {
+function normalizeToneWindow(win, field = "tone window") {
 	if (win === false) return {
 		lo: 0,
 		hi: 100,
 		eps: REF_EPS
 	};
-	if (Array.isArray(win)) return {
-		lo: win[0],
-		hi: win[1],
-		eps: REF_EPS
-	};
+	const raw = win;
+	let lo;
+	let hi;
+	let eps = REF_EPS;
+	if (Array.isArray(raw) && raw.length === 2) [lo, hi] = raw;
+	else if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) ({lo, hi, eps} = raw);
+	else throw new Error(`glaze: ${field} must be [lo, hi], { lo, hi, eps }, or false (got ${showValue(raw)}).`);
+	for (const [name, value] of [["lo", lo], ["hi", hi]]) if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`glaze: ${field} ${name} must be a finite number (got ${showValue(value)}).`);
+	if (typeof eps !== "number" || !Number.isFinite(eps) || eps <= 0 || eps > MAX_WINDOW_EPS) throw new Error(`glaze: ${field} eps must be a finite number above 0 and at most 1e6 (got ${showValue(eps)}).`);
+	const from = lo;
+	const to = hi;
+	if (from > to) throw new Error(`glaze: ${field} lo (${from}) is above hi (${to}). A window runs from its dark end to its light end: [lo, hi] with lo ≤ hi, e.g. [${to}, ${from}].`);
 	return {
-		lo: win.lo,
-		hi: win.hi,
-		eps: win.eps
+		lo: clamp(from, 0, 100),
+		hi: clamp(to, 0, 100),
+		eps
 	};
 }
 /**
@@ -1244,16 +1084,78 @@ function mapToneForScheme(authorTone, mode, isDark, isHighContrast, config) {
 	const win = activeWindow(isHighContrast, isDark ? "dark" : "light", config);
 	return clamp(toTone(remapToneToLightness(clamp(isDark && mode === "auto" ? 100 - authorTone : authorTone, 0, 100), win) / 100), 0, 100);
 }
+/**
+* The dark `auto` branch of {@link mapToneForScheme} without its clamp to the
+* authored `0–100` scale: a tone below 0 lands past the dark window's top, one
+* above 100 past its bottom, and only the stored tone is clamped (to the full
+* range). That makes it the inverse of `unmapDarkTone(…, 'auto', …)` off the
+* scale too, so a step can start from a base a contrast floor pushed past the
+* window. Inside `0–100` it is `mapToneForScheme` bit for bit.
+*/
+function mapDarkToneUnclamped(authorTone, isHighContrast, config) {
+	const win = activeWindow(isHighContrast, "dark", config);
+	return clamp(toTone(remapToneToLightness(100 - authorTone, win) / 100), 0, 100);
+}
+/**
+* Whether two configs give one pass the same active dark window — endpoints and
+* render eps, after the high-contrast bypass and a manual level's widening. An
+* authored tone only means the same dark tone under both when they do.
+*/
+function sameDarkWindow(isHighContrast, a, b) {
+	const wa = activeWindow(isHighContrast, "dark", a);
+	const wb = activeWindow(isHighContrast, "dark", b);
+	return wa.lo === wb.lo && wa.hi === wb.hi && wa.eps === wb.eps;
+}
+/**
+* Inverse of {@link remapToneToLightness} on canonical tone: the position
+* (0–100) in the window that renders at a stored canonical tone. A tone outside
+* the window comes back outside `0–100`; a zero-width window has no inverse, so
+* the tone is returned unchanged.
+*/
+function unmapWindow(tone, win) {
+	const loT = toTone(win.lo / 100, win.eps);
+	const hiT = toTone(win.hi / 100, win.eps);
+	if (hiT === loT) return tone;
+	return (toTone(fromTone(tone), win.eps) - loT) / (hiT - loT) * 100;
+}
+/**
+* Inverse of the light branch of {@link mapToneForScheme}: the authored tone
+* (0–100) that the active light window places at a stored canonical tone.
+* `static` is the identity, like the forward map. A tone outside the window
+* comes back outside `0–100` (callers clamp); a zero-width window has no
+* inverse, so the tone is returned unchanged.
+*/
+function unmapLightTone(tone, mode, isHighContrast, config) {
+	if (mode === "static") return tone;
+	return unmapWindow(tone, activeWindow(isHighContrast, "light", config));
+}
+/**
+* Inverse of the dark branch of {@link mapToneForScheme}: the authored tone
+* (0–100) that the active dark window places at a stored canonical tone —
+* inverted back (`100 - position`) under `auto`, as is under `fixed`, and the
+* identity under `static`. A tone outside the window comes back outside
+* `0–100` (a contrast floor can push a color past the window; callers clamp);
+* a zero-width window has no inverse, so only the inversion is undone.
+*/
+function unmapDarkTone(tone, mode, isHighContrast, config) {
+	if (mode === "static") return tone;
+	const position = unmapWindow(tone, activeWindow(isHighContrast, "dark", config));
+	return mode === "auto" ? 100 - position : position;
+}
 /** Dark-scheme desaturation reducer (unchanged from the legacy pipeline). */
 function mapSaturationDark(s, mode, config) {
 	if (mode === "static") return s;
 	return s * (1 - config.darkDesaturation);
 }
 /**
-* Tone search range (0–1) for the contrast solver in a given scheme.
-* `static` searches the full range; otherwise the scheme window's tone
-* endpoints (HC bypasses to full range, a manual `contrastLevel` widens
-* toward it — see `activeWindow`).
+* A scheme's window as canonical tone endpoints (0–1): `[0, 1]` for `static`,
+* otherwise the active window's `lo` / `hi` (HC bypasses to the full range, a
+* manual `contrastLevel` widens toward it — see `activeWindow`).
+*
+* The resolver uses it only to clamp a contrast-solved color's *preferred*
+* tone into the window before the solve. It is not the solver's search range:
+* the solver always searches the full `[0, 1]`, so a contrast floor can push a
+* color outside the window when the window can't meet it.
 */
 function schemeToneRange(isDark, mode, isHighContrast, config) {
 	if (mode === "static") return [0, 1];
@@ -1262,260 +1164,293 @@ function schemeToneRange(isDark, mode, isHighContrast, config) {
 }
 
 //#endregion
-//#region src/color-value.ts
+//#region src/lighting.ts
 /**
-* Parsing and validation for `GlazeColorValue` — the literal color forms.
+* Shadow and glow color computation.
 *
-* Hex, the CSS color functions Glaze emits, and the four value-object shapes all
-* land here and come out as OKHSL. Split out of `color-token.ts` so both
-* consumers can reach it without an import cycle: standalone `glaze.color()`
-* tokens build on it, and the resolver needs it for a theme color's `from`. It
-* depends on nothing but the color math, which is what keeps that true.
-*/
-/**
-* Matches the CSS color functions Glaze itself emits (`rgb()`, `hsl()`,
-* `okhsl()`, `oklch()`) plus their legacy alpha aliases (`rgba()`, `hsla()`).
+* Owns the shadow / glow / mix def predicates, the default lighting tuning
+* and its merge, and the exact lighting solver (`computeLighting`). Both
+* types emit a translucent pigment over a known surface (`bg`) whose opacity
+* is solved so the composite lands an exact tone step away from it: darker
+* for `shadow`, lighter for `glow`, in every scheme. Compositing is modeled
+* the way browsers paint it — `source-over` on gamma-encoded sRGB — and the
+* step is measured in the WCAG-shaped tone of the composite's luminance, so
+* it holds on chromatic surfaces too. An optional object (`fg`) scales the
+* step the way bounce light does. The resolver consumes this module per
+* scheme variant; `glaze.shadow()` / `glaze.glow()` call it directly.
 *
-* Only bare numeric components are supported. Named colors (`red`),
-* relative-color syntax (`from <color> ...`), and angle units other
-* than bare degrees (`deg` is the only suffix tolerated by `parseFloat`)
-* are out of scope.
-*/
-const COLOR_FN_RE = /^(rgba?|hsla?|okhsl|okhst|oklch)\(\s*([^)]*)\s*\)$/i;
-function parseNumberOrPercent(raw, percentScale) {
-	if (raw.endsWith("%")) return parseFloat(raw) / 100 * percentScale;
-	return parseFloat(raw);
+* HDR glows: with `glowTuning.headroom` above 0, a glow whose target tone
+* (surface tone + step) passes 100 also gets an HDR value, computed in closed
+* form after the untouched SDR solve. SDR is pinned at its brightest there —
+* the pigment at opacity 1, or a white surface at opacity 0 — and the HDR
+* value is an opaque exposure of that color: the base times `2^exposure`, the
+* gain that lands the exact step, capped per channel at `2^headroom`
+* (`MAX_HEADROOM` stops at most). A pigment that cannot lift a non-white
+* surface at all gets none and keeps the SDR shortfall warning. Since the
+* value lands the whole step, only a full-reach glow meets SDR at the boundary
+* (`exposure` → 0); one with `reach` below 1 jumps from its pigment to the
+* exact step. `hdrToLinearSrgb` turns a resolved HDR value back into linear
+* sRGB for the writers.
+*/
+/** Most stops of HDR headroom a glow may use; larger values clamp to it. */
+const MAX_HEADROOM = 2;
+function isShadowDef(def) {
+	return def.type === "shadow";
+}
+function isGlowDef(def) {
+	return def.type === "glow";
+}
+/** A `shadow` or `glow` def — the translucent overlay types. */
+function isLightingDef(def) {
+	return isShadowDef(def) || isGlowDef(def);
 }
+function isMixDef(def) {
+	return def.type === "mix";
+}
+const DEFAULT_LIGHTING_TUNING = {
+	objectInfluence: .5,
+	tint: 0,
+	reach: 1,
+	hueBleed: 0
+};
 /**
-* Split the body of a CSS color function into its components and detect
-* whether an alpha channel was present.
-*
-* Handles both modern slash syntax (`R G B / A` or `R, G, B / A`) and
-* legacy comma syntax (`R, G, B, A`). The alpha value itself is discarded
-* by the caller — standalone Glaze colors have no opacity field.
+* Defaults ← global (`shadowTuning` / `glowTuning`) ← per-color, field by
+* field. `headroom` defaults to 0 and clamps to `0–MAX_HEADROOM`; the config
+* and def validators have already rejected a non-finite or negative value and
+* warned about one above the maximum.
 */
-function splitColorBody(body) {
-	const slashIdx = body.indexOf("/");
-	if (slashIdx !== -1) return {
-		components: body.slice(0, slashIdx).trim().split(/[\s,]+/).filter(Boolean),
-		hadAlpha: body.slice(slashIdx + 1).trim().length > 0
-	};
-	const components = body.split(/[\s,]+/).filter(Boolean);
-	if (components.length === 4) {
-		components.pop();
-		return {
-			components,
-			hadAlpha: true
-		};
-	}
+function resolveLightingTuning(perColor, globalTuning) {
+	const headroom = perColor?.headroom ?? globalTuning?.headroom ?? 0;
 	return {
-		components,
-		hadAlpha: false
+		...DEFAULT_LIGHTING_TUNING,
+		...globalTuning,
+		...perColor,
+		headroom: clamp(headroom, 0, MAX_HEADROOM)
 	};
 }
-function warnDroppedAlpha(input) {
-	console.warn(`glaze: alpha component dropped from "${input}" (standalone color has no opacity field).`);
+function circularLerp(a, b, t) {
+	let diff = b - a;
+	if (diff > 180) diff -= 360;
+	else if (diff < -180) diff += 360;
+	return ((a + diff * t) % 360 + 360) % 360;
 }
-function parseColorString(input) {
-	if (input.startsWith("#")) {
-		const parsed = parseHexAlpha(input);
-		if (!parsed) throw new Error(`glaze: invalid hex color "${input}".`);
-		if (parsed.alpha !== void 0) warnDroppedAlpha(input);
-		const [h, s, l] = srgbToOkhsl(parsed.rgb);
-		return {
-			h,
-			s,
-			l
-		};
-	}
-	const m = input.match(COLOR_FN_RE);
-	if (!m) throw new Error(`glaze: unsupported color string "${input}".`);
-	const fn = m[1].toLowerCase();
-	const { components, hadAlpha } = splitColorBody(m[2].trim());
-	if (hadAlpha) warnDroppedAlpha(input);
-	if (components.length !== 3) throw new Error(`glaze: expected 3 components in "${input}".`);
-	switch (fn) {
-		case "rgb":
-		case "rgba": {
-			const [h, s, l] = srgbToOkhsl([
-				parseNumberOrPercent(components[0], 255) / 255,
-				parseNumberOrPercent(components[1], 255) / 255,
-				parseNumberOrPercent(components[2], 255) / 255
-			]);
-			return {
-				h,
-				s,
-				l
-			};
-		}
-		case "hsl":
-		case "hsla": {
-			const [oh, os, ol] = srgbToOkhsl(hslToSrgb(parseFloat(components[0]), parseNumberOrPercent(components[1], 1), parseNumberOrPercent(components[2], 1)));
-			return {
-				h: oh,
-				s: os,
-				l: ol
-			};
-		}
-		case "okhsl": return {
-			h: parseFloat(components[0]),
-			s: parseNumberOrPercent(components[1], 1),
-			l: parseNumberOrPercent(components[2], 1)
-		};
-		case "okhst": return okhstToOkhsl({
-			h: parseFloat(components[0]),
-			s: parseNumberOrPercent(components[1], 1),
-			t: parseNumberOrPercent(components[2], 1)
-		});
-		case "oklch": {
-			const L = parseNumberOrPercent(components[0], 1);
-			const C = parseNumberOrPercent(components[1], .4);
-			const hRad = parseFloat(components[2]) * Math.PI / 180;
-			const [h, s, l] = oklabToOkhsl([
-				L,
-				C * Math.cos(hRad),
-				C * Math.sin(hRad)
-			]);
-			return {
-				h,
-				s,
-				l
-			};
-		}
+const SAT_EPSILON = 1e-6;
+const BISECT_ITERATIONS = 40;
+const GOLDEN = (Math.sqrt(5) - 1) / 2;
+/** Float noise a target tone may sit above 100 without counting as HDR. */
+const HDR_TRIGGER_EPS = 1e-9;
+/** Float noise a surface tone may sit below 100 and still count as white. */
+const WHITE_SURFACE_EPS = 1e-6;
+/**
+* Object factor `k = max(0, 1 + β · d · (t_bg − t_fg) / 100)`, with `d = +1`
+* for a shadow and `−1` for a glow. Calibrated so an object at the surface's
+* own tone — or no object at all — gives exactly the authored step: a darker
+* object deepens its shadow, a lighter one strengthens its glow.
+*/
+function objectFactor(kind, bgTone, fgTone, objectInfluence) {
+	if (fgTone === void 0) return 1;
+	const d = kind === "shadow" ? 1 : -1;
+	return Math.max(0, 1 + objectInfluence * d * (bgTone - fgTone) / 100);
+}
+/**
+* The pigment: pure black (shadow) / pure white (glow) by default. `reach`
+* below 1 parks it part of the way from the surface's tone to that extreme so
+* a `tint` — saturation in the surface's hue, optionally pulled toward the
+* object's hue by `hueBleed` — can show.
+*/
+function pigmentFor(kind, bg, fg, bgTone, tuning) {
+	const reach = clamp(tuning.reach, 0, 1);
+	const tone = kind === "shadow" ? bgTone * (1 - reach) : bgTone + (100 - bgTone) * reach;
+	const bleed = clamp(tuning.hueBleed, 0, 1);
+	return {
+		h: fg !== void 0 && fg.s > SAT_EPSILON && bleed > 0 ? circularLerp(bg.h, fg.h, bleed) : bg.h,
+		s: clamp(tuning.tint, 0, 1),
+		l: clamp(fromTone(tone), 0, 1)
+	};
+}
+/**
+* Solve the pigment opacity that moves `bg` exactly `intensity × k` tones
+* darker (shadow) or lighter (glow) once the browser composites it.
+*
+* The composite's luminance is convex in alpha (each gamma channel moves
+* linearly and the sRGB decode is convex), so the "has reached the step"
+* predicate is monotone whenever full opacity reaches it and a bisection
+* lands it exactly. When it doesn't, the step is out of reach — a glow on
+* white, a deep shadow on near-black — and the result pins to the pigment's
+* strongest composite, reporting what it reached in `reached`.
+*
+* A glow with `headroom` above 0 whose target tone passes 100 also gets
+* `hdr` (see `exposeGlow`) when SDR is pinned at its brightest
+* (`pinnedBase`); the SDR fields are the same with or without it.
+*/
+function computeLighting(kind, bg, fg, intensity, tuning, pastel) {
+	const bgTone = toTone(bg.l);
+	const k = objectFactor(kind, bgTone, fg === void 0 ? void 0 : toTone(fg.l), tuning.objectInfluence);
+	const step = clamp(intensity, 0, 100) * k;
+	const pigment = pigmentFor(kind, bg, fg, bgTone, tuning);
+	const bgGamma = toDisplayGamma(okhslToLinearSrgb(bg.h, bg.s, bg.l, bg.pastel ?? pastel));
+	const pigmentGamma = toDisplayGamma(okhslToLinearSrgb(pigment.h, pigment.s, pigment.l, pastel));
+	const toneAt = (alpha) => toneFromY(relativeLuminanceFromLinearRgb(compositeOverGamma(bgGamma, pigmentGamma, alpha)));
+	const surfaceTone = toneAt(0);
+	const d = kind === "shadow" ? 1 : -1;
+	const gain = (alpha) => d * (surfaceTone - toneAt(alpha));
+	const { alpha, reached } = solveOpacity(kind, gain, step);
+	const result = {
+		...pigment,
+		alpha,
+		step,
+		reached
+	};
+	const headroom = tuning.headroom ?? 0;
+	if (kind === "glow" && headroom > 0 && step > 0) {
+		const base = pinnedBase(alpha, surfaceTone, pigment, bg, pastel);
+		const hdr = base === void 0 ? void 0 : exposeGlow(base, surfaceTone, step, headroom);
+		if (hdr !== void 0) result.hdr = hdr;
 	}
-	throw new Error(`glaze: unsupported color function "${fn}".`);
+	return result;
 }
 /**
-* Validate a user-supplied `OkhslColor`. Catches the common 0-100 vs 0-1
-* confusion (the structured form uses 0-100, OKHSL objects use 0-1).
+* The SDR opacity solve: the smallest opacity whose composite reaches `step`,
+* or — out of reach — the pigment's strongest composite.
 */
-function validateOkhslColor(value) {
-	const { h, s, l } = value;
-	if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(l)) throw new Error("glaze.color: OkhslColor h/s/l must be finite numbers.");
-	if (s > 1.5 || l > 1.5) throw new Error("glaze.color: OkhslColor s/l must be in 0–1 range. Did you mean the structured form { hue, saturation, tone } (which uses 0–100)?");
-}
-/** Validate a user-supplied `{ r, g, b }` object in 0–255. */
-function validateRgbColor(value) {
-	for (const key of [
-		"r",
-		"g",
-		"b"
-	]) {
-		const n = value[key];
-		if (!Number.isFinite(n) || n < 0 || n > 255) throw new Error(`glaze.color: RgbColor ${key} must be a finite number in 0–255 (got ${n}).`);
+function solveOpacity(kind, gain, step) {
+	if (step <= 0) return {
+		alpha: 0,
+		reached: 0
+	};
+	let hi = 1;
+	if (gain(1) < step) {
+		hi = kind === "shadow" ? strongestShadowAlpha(gain) : 1;
+		const reached = gain(hi);
+		if (reached < step) return reached > 0 ? {
+			alpha: hi,
+			reached
+		} : {
+			alpha: 0,
+			reached: 0
+		};
 	}
+	let lo = 0;
+	for (let i = 0; i < BISECT_ITERATIONS; i++) {
+		const mid = (lo + hi) / 2;
+		if (gain(mid) < step) lo = mid;
+		else hi = mid;
+	}
+	return {
+		alpha: hi,
+		reached: gain(hi)
+	};
 }
-/** Validate a user-supplied `{ l, c, h }` OKLCh object. */
-function validateOklchColor(value) {
-	const { l, c, h } = value;
-	if (!Number.isFinite(l) || !Number.isFinite(c) || !Number.isFinite(h)) throw new Error("glaze.color: OklchColor l/c/h must be finite numbers.");
-	if (l > 1.5 || c > 1.5) throw new Error("glaze.color: OklchColor l/c must be in 0–1 range (matching oklch() strings).");
-}
-function oklchComponentsToOkhsl(l, c, hDeg) {
-	const hRad = hDeg * Math.PI / 180;
-	const [h, s, outL] = oklabToOkhsl([
-		l,
-		c * Math.cos(hRad),
-		c * Math.sin(hRad)
-	]);
+/** An OKHSL color in the standard (non-pastel) space the HDR base uses. */
+function standardOkhsl(c, pastel) {
+	if (!pastel) return {
+		h: c.h,
+		s: c.s,
+		l: c.l
+	};
+	const [h, s, l] = oklabToOkhsl(okhslToOklab(c.h, c.s, c.l, true));
 	return {
 		h,
 		s,
-		l: outL
+		l
 	};
 }
-function isRgbColorObject(value) {
-	return "r" in value && "g" in value && "b" in value;
-}
-function isOklchColorObject(value) {
-	return "c" in value && "l" in value && "h" in value;
-}
-function isOkhstColorObject(value) {
-	return "t" in value && "h" in value && "s" in value;
-}
-/** Validate a user-supplied `{ h, s, t }` OKHST object (s/t in 0–1). */
-function validateOkhstColor(value) {
-	const { h, s, t } = value;
-	if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(t)) throw new Error("glaze.color: OkhstColor h/s/t must be finite numbers.");
-	if (s > 1.5 || t > 1.5) throw new Error("glaze.color: OkhstColor s/t must be in 0–1 range. Did you mean the structured form { hue, saturation, tone } (which uses 0–100)?");
-}
 /**
-* Extract an OKHSL color from any `GlazeColorValue` form. Also used by
-* `glaze.shadow()` so all shadow inputs (hex, color functions, OKHSL,
-* literal objects) go through one parser.
-*/
-function extractOkhslFromValue(value) {
-	if (typeof value === "string") return parseColorString(value);
-	if (Array.isArray(value)) throw new Error("glaze.color: RGB tuple [r, g, b] is no longer supported — use { r, g, b } instead.");
-	if (isRgbColorObject(value)) {
-		validateRgbColor(value);
-		const [h, s, l] = srgbToOkhsl([
-			value.r / 255,
-			value.g / 255,
-			value.b / 255
-		]);
-		return {
-			h,
-			s,
-			l
-		};
-	}
-	if (isOklchColorObject(value)) {
-		validateOklchColor(value);
-		return oklchComponentsToOkhsl(value.l, value.c, value.h);
-	}
-	if (isOkhstColorObject(value)) {
-		validateOkhstColor(value);
-		return okhstToOkhsl(value);
-	}
-	validateOkhslColor(value);
-	return value;
+* What SDR paints once it is pinned at its brightest, as standard OKHSL — the
+* only color an HDR glow exposes. Past white SDR cannot land the step, so the
+* solved opacity is 0 or 1 there: at 1 that is the pigment itself; at 0 it is
+* the surface, which counts only when it is white (no pigment can lift white,
+* and SDR shows white). A pigment that cannot lift a non-white surface at all
+* — `reach: 0` on a gray surface, say, or a `tint` that only darkens — paints
+* nothing in SDR, so there is nothing to expose. (On a chromatic surface a
+* `reach: 0` pigment, a gray at the surface's tone, can measure slightly
+* brighter; it then pins at 1 like any pigment.) An exposure of the bare
+* surface would be an opaque, brighter copy of it where SDR leaves the surface
+* showing, and a neutral one clips to opaque white wherever HDR is clamped.
+* `undefined` then (and for any opacity between, which only float noise at the
+* trigger reaches).
+*/
+function pinnedBase(alpha, surfaceTone, pigment, bg, pastel) {
+	if (alpha === 1) return standardOkhsl(pigment, pastel);
+	if (alpha === 0 && surfaceTone >= 100 - WHITE_SURFACE_EPS) return standardOkhsl(bg, bg.pastel ?? pastel);
+}
+/**
+* HDR value of a glow past white: an opaque exposure of `base` — what SDR
+* paints at its brightest (`pinnedBase`), as standard OKHSL — by the gain that
+* lands the target tone `surfaceTone + step`, capped so no channel passes
+* `2^headroom` (displays clip per channel; for a neutral base that is a cap on
+* luminance). `undefined` when the target stays at or below 100 — the trigger
+* depends on the target alone — or when the base is black and has nothing to
+* expose.
+*
+* Tone runs past 100 unchanged (`toneFromY` / `yFromTone` are unclamped), so
+* equal tone steps above white are still equal `Y + 0.05` ratios. The gain is
+* measured on the base as stored, so base × `2^exposure` lands the step to
+* float precision. It lands the whole step, not just the part past white: a
+* base at white (full `reach`) meets SDR with `exposure` → 0 as the target
+* goes to 100⁺, while a base below white (`reach` under 1) starts at
+* `log2(Y(100) / Y(base))` — just under white SDR stays short at the pigment
+* and warns; just past it HDR lands the exact step.
+*/
+function exposeGlow(base, surfaceTone, step, headroom) {
+	const target = surfaceTone + step;
+	if (!(target > 100 + HDR_TRIGGER_EPS)) return void 0;
+	const linear = okhslToLinearSrgb(base.h, base.s, base.l);
+	const yBase = relativeLuminanceFromLinearRgb(linear);
+	const peak = Math.max(linear[0], linear[1], linear[2]);
+	if (!(yBase > 0) || !(peak > 0)) return void 0;
+	const m = Math.min(yFromTone(target) / yBase, 2 ** headroom / peak);
+	if (!(m > 1)) return void 0;
+	return {
+		...base,
+		exposure: Math.log2(m),
+		reached: toneFromY(yBase * m) - surfaceTone
+	};
+}
+/** The solver's HDR value (OKHSL base) as a `ResolvedHdr` (OKHST base). */
+function toResolvedHdr(hdr) {
+	const { h, s, t } = okhslToOkhst(hdr);
+	return {
+		h,
+		s,
+		t,
+		exposure: hdr.exposure
+	};
 }
-
-//#endregion
-//#region src/format-guard.ts
-const NON_NATIVE_FORMATS = new Set(["okhsl", "okhst"]);
 /**
-* Throw when a non-native Glaze color space is requested for an export that
-* emits raw CSS or non-Tasty token maps.
+* Linear sRGB of a resolved HDR value: the base's channels times
+* `2^exposure`, unclamped (the brightest channel can reach `2^headroom`).
+* The base is non-pastel OKHSL, so no `pastel` flag applies.
 */
-function assertNativeFormat(format, method) {
-	if (format !== void 0 && NON_NATIVE_FORMATS.has(format)) throw new Error(`glaze: ${format} output is only supported by tasty() (not a native CSS color space). Use tasty({ format: '${format}' }) or pick a native format (oklch|hsl|rgb) for ${method}().`);
+function hdrToLinearSrgb(hdr) {
+	const { h, s, l } = okhstToOkhsl(hdr);
+	const [r, g, b] = okhslToLinearSrgb(h, s, l);
+	const m = 2 ** hdr.exposure;
+	return [
+		r * m,
+		g * m,
+		b * m
+	];
 }
-const SCHEME_FIELDS = [
-	{
-		field: "light",
-		modes: () => true
-	},
-	{
-		field: "dark",
-		modes: (m) => m.dark
-	},
-	{
-		field: "lightContrast",
-		modes: (m) => m.highContrast
-	},
-	{
-		field: "darkContrast",
-		modes: (m) => m.dark && m.highContrast
-	}
-];
 /**
-* Throw when `splitHue` is enabled but any exported color is not pastel.
-* Hue rotation is only clip-free when chroma is bounded by the hue-independent
-* safe chroma (`computeSafeChromaOKLCH`).
+* Opacity of a shadow pigment's darkest composite. Full opacity for pure
+* black; a tinted pigment whose channels pull in different directions can
+* bottom out earlier, so a golden-section search over the unimodal gain finds
+* it and the better of that and full opacity wins. (A glow needs no search:
+* convex luminance peaks at an endpoint, and full opacity is the one that
+* lightens.)
 */
-function assertAllPastel(resolved, modes) {
-	const nonPastel = [];
-	for (const [name, color] of resolved) for (const { field, modes: active } of SCHEME_FIELDS) {
-		if (!active(modes)) continue;
-		if (color[field].pastel !== true) {
-			if (!nonPastel.includes(name)) nonPastel.push(name);
-			break;
-		}
+function strongestShadowAlpha(gain) {
+	let a = 0;
+	let b = 1;
+	for (let i = 0; i < BISECT_ITERATIONS; i++) {
+		const c = b - GOLDEN * (b - a);
+		const e = a + GOLDEN * (b - a);
+		if (gain(c) < gain(e)) a = c;
+		else b = e;
 	}
-	if (nonPastel.length === 0) return;
-	throw new Error(`glaze: splitHue requires every color to be pastel (hue rotation is only clip-free when chroma is bounded by the hue-independent safe chroma). Non-pastel: ${nonPastel.join(", ")}. Set pastel: true (per-theme, per-token, or per-color) or drop splitHue.`);
+	const peak = (a + b) / 2;
+	return gain(peak) > gain(1) ? peak : 1;
 }
 
 //#endregion
@@ -1528,9 +1463,24 @@ function assertAllPastel(resolved, modes) {
 * contrast-uniform, the WCAG branch gets a closed-form seed and the search
 * converges quickly.
 *
+* Both solvers search two branches that meet at the preferred position, which
+* has already missed the overshooting search target and so sits between the
+* passing regions. Each branch therefore reaches only its own side: a result
+* sits where its `branch` / `flipped` say, and keeps the overshoot that absorbs
+* formatting rounding. The WCAG gray seed is only the initial branch's first
+* probe, never a bound, so a chromatic color still lands on its own crossing
+* nearest the preferred tone. When no searched side meets the floor but the
+* preferred position itself clears the bare target (it sits on a bound, or its
+* side was never searched), the preferred position is the answer, met; the
+* tone solver labels it `'preferred'`, as it does a met result from a starting
+* side whose only position is the preferred tone. With no direction given, a
+* solver starts toward the end that scores higher, and a float-noise gap
+* between the two ends is a tie that starts darker / lower.
+*
 * Public API: `findToneForContrast`, `findValueForMixContrast`,
-* `resolveMinContrast`, `resolveContrastForMode`, `resolveContrastForLevel`,
-* `apcaContrast`.
+* `resolveMinContrast`, `resolveApcaTarget`, `resolveContrastForMode`,
+* `resolveContrastForLevel`, `apcaContrast`, plus the `APCA_PRESETS`,
+* `APCA_HC_ENHANCEMENT` and `APCA_MAX_LC` constants.
 */
 /**
 * Luminance of a linear-sRGB color in the basis the metric expects: WCAG
@@ -1712,12 +1662,17 @@ const CACHE_SIZE = 512;
 const luminanceCache = /* @__PURE__ */ new Map();
 const cacheOrder = [];
 /**
+* Tones are rounded to `1 / TONE_STEPS` (0.0001) before measuring, so the tone
+* solver can't resolve a crossing more finely than that, whatever `epsilon`.
+*/
+const TONE_STEPS = 1e4;
+/**
 * Luminance of an OKHST color `(h, s, t)` with t in 0–1 (reference eps), in
 * the metric's luminance basis. The metric is part of the cache key because
 * WCAG and APCA derive different luminances from the same color.
 */
 function cachedLuminance(metric, h, s, t, pastel) {
-	const tRounded = Math.round(t * 1e4) / 1e4;
+	const tRounded = Math.round(t * TONE_STEPS) / TONE_STEPS;
 	const key = `${metric}|${h}|${s}|${tRounded}|${pastel}`;
 	const cached = luminanceCache.get(key);
 	if (cached !== void 0) return cached;
@@ -1745,69 +1700,65 @@ function metricScore(metric, yCandidate, yBase, polarity) {
 	return Math.abs(lc);
 }
 /**
-* Binary search one branch `[lo, hi]` for the position nearest to `anchor`
-* that meets `target`. The domain is whatever `lum` interprets (tone 0–1 or
-* mix parameter 0–1); the search is identical in both cases.
-*/
-function searchBranch(lum, lo, hi, yBase, metric, target, epsilon, maxIter, anchor, polarity) {
-	const scoreLo = metricScore(metric, lum(lo), yBase, polarity);
-	const scoreHi = metricScore(metric, lum(hi), yBase, polarity);
-	if (scoreLo < target && scoreHi < target) return scoreLo >= scoreHi ? {
-		pos: lo,
-		contrast: scoreLo,
-		met: false
-	} : {
-		pos: hi,
-		contrast: scoreHi,
-		met: false
+* Relative gap under which two scores count as equal when a solver picks its
+* starting side from the two ends of its range. Tone is WCAG-uniform, so a
+* gray base at tone 50 sits exactly as far from black as from white: without
+* a tolerance, float noise in the base (1e-16 is enough) decides which end
+* scores higher, and with it the side a color lands on.
+*/
+const SCORE_TIE_TOLERANCE = 1e-9;
+/** `a >= b`, with a gap inside {@link SCORE_TIE_TOLERANCE} counted as a tie. */
+function scoreAtLeast(a, b) {
+	return a >= b - SCORE_TIE_TOLERANCE * Math.max(1, Math.abs(b));
+}
+/**
+* Binary search one branch, from its `inner` bound out to its `outer` extreme,
+* for the position nearest `inner` that meets `target`. The domain is whatever
+* `lum` interprets (tone 0–1 or mix parameter 0–1); the search is identical in
+* both cases, and either end may be the numerically lower one.
+*
+* The score falls toward the base, so a branch's passing positions form one run
+* that reaches out to `outer`: the outer extreme is the most the branch can
+* reach. When even it falls short, the branch reports that extreme — never
+* `inner`, which borders the opposite branch: a near-miss there may sit on the
+* other side of the base, and returning it as this branch's answer would
+* mislabel its side and drop the overshoot.
+*
+* `probe`, when it lies strictly between `inner` and `outer`, is measured
+* before the bisection and only narrows the bracket — to its passing side or
+* its failing side — so the result is still the crossing nearest `inner`.
+*/
+function searchBranch(lum, inner, outer, yBase, metric, target, epsilon, maxIter, polarity, probe) {
+	const scoreOuter = metricScore(metric, lum(outer), yBase, polarity);
+	if (scoreOuter < target) return {
+		pos: outer,
+		contrast: scoreOuter
+	};
+	const scoreInner = metricScore(metric, lum(inner), yBase, polarity);
+	if (scoreInner >= target) return {
+		pos: inner,
+		contrast: scoreInner
 	};
-	let low = lo;
-	let high = hi;
+	let fail = inner;
+	let pass = outer;
+	if (probe !== void 0 && (probe - inner) * (outer - probe) > 0) if (metricScore(metric, lum(probe), yBase, polarity) >= target) pass = probe;
+	else fail = probe;
 	for (let i = 0; i < maxIter; i++) {
-		if (high - low < epsilon) break;
-		const mid = (low + high) / 2;
-		if (metricScore(metric, lum(mid), yBase, polarity) >= target) if (mid < anchor) low = mid;
-		else high = mid;
-		else if (mid < anchor) high = mid;
-		else low = mid;
+		if (Math.abs(pass - fail) < epsilon) break;
+		const mid = (fail + pass) / 2;
+		if (metricScore(metric, lum(mid), yBase, polarity) >= target) pass = mid;
+		else fail = mid;
 	}
-	const scoreLow = metricScore(metric, lum(low), yBase, polarity);
-	const scoreHigh = metricScore(metric, lum(high), yBase, polarity);
-	const lowPasses = scoreLow >= target;
-	const highPasses = scoreHigh >= target;
-	if (lowPasses && highPasses) return Math.abs(low - anchor) <= Math.abs(high - anchor) ? {
-		pos: low,
-		contrast: scoreLow,
-		met: true
-	} : {
-		pos: high,
-		contrast: scoreHigh,
-		met: true
-	};
-	if (lowPasses) return {
-		pos: low,
-		contrast: scoreLow,
-		met: true
-	};
-	if (highPasses) return {
-		pos: high,
-		contrast: scoreHigh,
-		met: true
-	};
-	return scoreLow >= scoreHigh ? {
-		pos: low,
-		contrast: scoreLow,
-		met: false
-	} : {
-		pos: high,
-		contrast: scoreHigh,
-		met: false
+	return {
+		pos: pass,
+		contrast: metricScore(metric, lum(pass), yBase, polarity)
 	};
 }
 /**
 * Closed-form WCAG tone seed: the gray tone whose luminance produces exactly
-* the target ratio against the base, on the requested side. Used to bias the
-* preferred tone before the search so chromatic refinement starts close.
+* the target ratio against the base, on the requested side. The initial
+* branch measures it first so chromatic refinement starts from a tight
+* bracket; it is a probe, never a bound.
 */
 function wcagToneSeed(yBase, target, darker) {
 	const yTarget = darker ? (yBase + .05) / target - .05 : target * (yBase + .05) - .05;
@@ -1815,154 +1766,1276 @@ function wcagToneSeed(yBase, target, darker) {
 	return Math.max(0, Math.min(1, toneFromY(yClamped, REF_EPS) / 100));
 }
 function solveNearestContrast(opts) {
-	const { lum, yBase, metric, target, searchTarget, lo, hi, searchAnchor, distanceAnchor, epsilon, maxIterations, flip, preferInitial, initialIsLower, polarity } = opts;
-	const runBranch = (lower) => lower ? searchBranch(lum, lo, searchAnchor, yBase, metric, searchTarget, epsilon, maxIterations, searchAnchor, polarity) : searchBranch(lum, searchAnchor, hi, yBase, metric, searchTarget, epsilon, maxIterations, searchAnchor, polarity);
-	const initialResult = runBranch(initialIsLower);
-	initialResult.met = initialResult.contrast >= target;
-	if (initialResult.met && !flip) return {
-		...initialResult,
-		lower: initialIsLower
+	const { lum, yBase, metric, target, searchTarget, lo, hi, searchAnchor, preferred, epsilon, resolution, maxIterations, flip, preferInitial, initialIsLower, polarity } = opts;
+	const boundary = clamp(preferred, lo, hi);
+	const runBranch = (lower, probe) => {
+		const result = searchBranch(lum, boundary, lower ? lo : hi, yBase, metric, searchTarget, epsilon, maxIterations, polarity, probe);
+		return {
+			...result,
+			met: result.contrast >= target,
+			lower
+		};
+	};
+	const initial = runBranch(initialIsLower, searchAnchor);
+	if (!flip) return initial;
+	if (!(initialIsLower ? preferred < hi : preferred > lo)) return initial;
+	const opposite = {
+		...runBranch(!initialIsLower),
+		flipped: true
+	};
+	if (initial.met && opposite.met) {
+		if (preferInitial) return initial;
+		return Math.abs(initial.pos - preferred) <= Math.abs(opposite.pos - preferred) + 2 * resolution ? initial : opposite;
+	}
+	return opposite.met && !initial.met ? opposite : initial;
+}
+/**
+* Find the tone that satisfies a contrast floor against a base color,
+* staying as close to `preferredTone` as possible. A searched result keeps the
+* overshoot (1% for WCAG, 0.5 Lc for APCA). When no searched side reaches the
+* floor, the result pins to the initial direction's extreme, unmet — unless
+* `preferredTone` itself clears the bare target, which is then kept as met
+* (`branch: 'preferred'`, the same label a met result gets when the starting
+* side's only position is `preferredTone`).
+*/
+function findToneForContrast(options) {
+	const { hue, saturation, preferredTone, baseLinearRgb, contrast, toneRange = [0, 1], epsilon = 1e-4, maxIterations = 18, pastel = false } = options;
+	const { metric, target, polarity } = contrast;
+	const searchTarget = metric === "wcag" ? target * 1.01 : target + .5;
+	const yBase = metricLuminance(metric, baseLinearRgb);
+	const lum = (t) => cachedLuminance(metric, hue, saturation, t, pastel);
+	const scorePref = metricScore(metric, lum(preferredTone), yBase, polarity);
+	if (scorePref >= searchTarget) return {
+		tone: preferredTone,
+		contrast: scorePref,
+		met: true,
+		branch: "preferred"
+	};
+	const [minT, maxT] = toneRange;
+	const canDarker = preferredTone > minT;
+	const canLighter = preferredTone < maxT;
+	let initialIsDarker;
+	if (options.initialDirection !== void 0) initialIsDarker = options.initialDirection === "darker";
+	else if (canDarker && !canLighter) initialIsDarker = true;
+	else if (!canDarker && canLighter) initialIsDarker = false;
+	else if (!canDarker && !canLighter) return {
+		tone: preferredTone,
+		contrast: scorePref,
+		met: scorePref >= target,
+		branch: "preferred"
+	};
+	else initialIsDarker = scoreAtLeast(metricScore(metric, lum(minT), yBase, polarity), metricScore(metric, lum(maxT), yBase, polarity));
+	const solved = solveNearestContrast({
+		lum,
+		yBase,
+		metric,
+		target,
+		searchTarget,
+		lo: minT,
+		hi: maxT,
+		searchAnchor: metric === "wcag" ? wcagToneSeed(yBase, target, initialIsDarker) : void 0,
+		preferred: preferredTone,
+		epsilon,
+		resolution: Math.max(epsilon, 1 / TONE_STEPS),
+		maxIterations,
+		flip: options.flip ?? false,
+		preferInitial: options.preferInitial ?? false,
+		initialIsLower: initialIsDarker,
+		polarity
+	});
+	if (solved.met ? solved.pos === preferredTone : scorePref >= target) return {
+		tone: preferredTone,
+		contrast: scorePref,
+		met: true,
+		branch: "preferred"
+	};
+	return {
+		tone: solved.pos,
+		contrast: solved.contrast,
+		met: solved.met,
+		branch: solved.lower ? "darker" : "lighter",
+		...solved.flipped ? { flipped: true } : {}
+	};
+}
+/**
+* Find the mix parameter (ratio or opacity) that satisfies a contrast floor
+* against a base color, staying as close to `preferredValue` as possible.
+* Misses pin to the initial direction's end like the tone solver, and a
+* `preferredValue` that clears the bare target is kept as met when no searched
+* side reaches the floor (a value of 1 has no room toward the target).
+*/
+function findValueForMixContrast(options) {
+	const { preferredValue, baseLinearRgb, contrast, luminanceAtValue, epsilon = 1e-4, maxIterations = 20 } = options;
+	const { metric, target, polarity } = contrast;
+	const searchTarget = metric === "wcag" ? target * 1.01 : target + .5;
+	const yBase = metricLuminance(metric, baseLinearRgb);
+	const scorePref = metricScore(metric, luminanceAtValue(preferredValue), yBase, polarity);
+	if (scorePref >= searchTarget) return {
+		value: preferredValue,
+		contrast: scorePref,
+		met: true
+	};
+	const canLower = preferredValue > 0;
+	const canUpper = preferredValue < 1;
+	let initialIsLower;
+	if (canLower && !canUpper) initialIsLower = true;
+	else if (!canLower && canUpper) initialIsLower = false;
+	else if (!canLower && !canUpper) return {
+		value: preferredValue,
+		contrast: scorePref,
+		met: scorePref >= target
+	};
+	else initialIsLower = scoreAtLeast(metricScore(metric, luminanceAtValue(0), yBase, polarity), metricScore(metric, luminanceAtValue(1), yBase, polarity));
+	const solved = solveNearestContrast({
+		lum: luminanceAtValue,
+		yBase,
+		metric,
+		target,
+		searchTarget,
+		lo: 0,
+		hi: 1,
+		preferred: preferredValue,
+		epsilon,
+		resolution: epsilon,
+		maxIterations,
+		flip: options.flip ?? false,
+		preferInitial: false,
+		initialIsLower,
+		polarity
+	});
+	if (!solved.met && scorePref >= target) return {
+		value: preferredValue,
+		contrast: scorePref,
+		met: true
+	};
+	return {
+		value: solved.pos,
+		contrast: solved.contrast,
+		met: solved.met,
+		...solved.flipped ? { flipped: true } : {}
+	};
+}
+
+//#endregion
+//#region src/warnings.ts
+/**
+* Resolve-time warning dispatcher: unmet contrast floors (regular colors and
+* mixes), chromatic contrast drift, out-of-reach shadow / glow steps (SDR, and
+* HDR glows whose headroom cap falls short), and a glow `headroom` clamped to
+* its 2-stop maximum. A validator that checks more fields after a clamp queues
+* that warning (`DeferredWarnings`) and sends it with `flushWarnings` only once
+* the whole input has passed.
+*
+* Tokens memoize their resolution, but a long-lived process (e.g. a dev
+* server with HMR) can re-resolve the same theme many times. The cache
+* here dedupes warnings within a session with a soft cap to keep noise
+* bounded.
+*/
+const CONTRAST_WARN_CACHE_LIMIT = 256;
+const contrastWarnCache = /* @__PURE__ */ new Set();
+/**
+* Slack factor below the requested target before we emit a warning.
+* The contrast solver overshoots to absorb rounding noise, so an actual
+* value within ~2x that overshoot is effectively a pass.
+*/
+const CONTRAST_WARN_SLACK_WCAG = .98;
+/** APCA Lc is on a 0–106 scale; allow a small absolute slack. */
+const CONTRAST_WARN_SLACK_APCA = 1.5;
+function schemeLabel(isDark, isHighContrast) {
+	if (isDark && isHighContrast) return "darkContrast";
+	if (isDark) return "dark";
+	if (isHighContrast) return "lightContrast";
+	return "light";
+}
+function metricLabel(c) {
+	return c.metric === "apca" ? `APCA Lc ${c.target.toFixed(1)}` : `WCAG ${c.target.toFixed(2)}`;
+}
+function dedupe(key) {
+	if (contrastWarnCache.has(key)) return true;
+	if (contrastWarnCache.size >= CONTRAST_WARN_CACHE_LIMIT) contrastWarnCache.clear();
+	contrastWarnCache.add(key);
+	return false;
+}
+/**
+* Whether `actual` is short of the floor by more than the slack. The solver
+* aims slightly past the target, so a smaller shortfall is rounding noise.
+*/
+function missesFloor(contrast, actual) {
+	return actual < (contrast.metric === "apca" ? contrast.target - CONTRAST_WARN_SLACK_APCA : contrast.target * CONTRAST_WARN_SLACK_WCAG);
+}
+function contrastKey(kind, name, scheme, contrast, actual) {
+	return `${kind}|${name}|${scheme}|${contrast.metric}|${contrast.target.toFixed(2)}|${actual.toFixed(2)}`;
+}
+/** Warn when the solver could not reach the requested contrast floor. */
+function warnContrastUnmet(name, isDark, isHighContrast, contrast, actual) {
+	if (!missesFloor(contrast, actual)) return;
+	const scheme = schemeLabel(isDark, isHighContrast);
+	if (dedupe(contrastKey("unmet", name, scheme, contrast, actual))) return;
+	console.warn(`glaze: color "${name}" cannot meet ${metricLabel(contrast)} in ${scheme} scheme (got ${actual.toFixed(2)}). Try widening the tone window, lowering the contrast target, or picking a base color further from this color's tone.`);
+}
+/**
+* Warn when a mix's ratio / opacity search could not reach its contrast floor
+* against the mix's `base`. An unmet mix means even the pure target falls
+* short, so the fix is the target color or the floor, not a tone window.
+* `actual` is the contrast of the value the mix settled at.
+*/
+function warnMixContrastUnmet(name, isDark, isHighContrast, contrast, actual) {
+	if (!missesFloor(contrast, actual)) return;
+	const scheme = schemeLabel(isDark, isHighContrast);
+	if (dedupe(contrastKey("unmet-mix", name, scheme, contrast, actual))) return;
+	console.warn(`glaze: mix "${name}" cannot meet ${metricLabel(contrast)} against its base in ${scheme} scheme (got ${actual.toFixed(2)}). Even the pure target falls short; try lowering the contrast target or mixing toward a color further from the base.`);
+}
+/**
+* Verification (the drift check in docs/okhst.mdx): a chromatic swatch
+* inherits the gray tone's lightness but drifts in real luminance, so a
+* contrast-floored color may land slightly under the contrast its tone
+* implies. Emit an advisory warning when the actual measured contrast
+* drifts below the target. The caller skips achromatic variants and ones the
+* solver already reported through `warnContrastUnmet`.
+*/
+function warnContrastDrift(name, isDark, isHighContrast, contrast, yColor, yBase) {
+	const actual = contrast.metric === "apca" ? Math.abs(contrast.polarity === "bg" ? apcaContrast(yBase, yColor) : apcaContrast(yColor, yBase)) : contrastRatioFromLuminance(yColor, yBase);
+	if (!missesFloor(contrast, actual)) return;
+	const scheme = schemeLabel(isDark, isHighContrast);
+	if (dedupe(contrastKey("drift", name, scheme, contrast, actual))) return;
+	console.warn(`glaze: color "${name}" drifts below ${metricLabel(contrast)} in ${scheme} scheme (measured ${actual.toFixed(2)}). Chromatic luminance differs from the gray tone; nudge the tone or saturation if the floor matters.`);
+}
+/** Tone slack before an out-of-reach shadow / glow step is worth a warning. */
+const LIGHTING_WARN_SLACK = .05;
+/**
+* Warn when a `shadow` / `glow` step is out of reach of its pigment — a glow
+* on white, a deep shadow on near-black — so the composite pins to the
+* pigment's strongest and lands short. `name` is omitted for the standalone
+* `glaze.shadow()` / `glaze.glow()` factories, which have no scheme either.
+*/
+function warnLightingUnreachable(kind, name, scheme, step, reached) {
+	if (reached >= step - LIGHTING_WARN_SLACK) return;
+	const label = scheme ? schemeLabel(scheme.isDark, scheme.isHighContrast) : void 0;
+	if (dedupe(`lighting|${kind}|${name ?? ""}|${label ?? ""}|${step.toFixed(2)}|${reached.toFixed(2)}`)) return;
+	const subject = name === void 0 ? `glaze.${kind}()` : `${kind} "${name}"`;
+	const where = label === void 0 ? "" : ` in ${label} scheme`;
+	const extreme = kind === "shadow" ? "black" : "white";
+	console.warn(`glaze: ${subject} cannot reach a ${step.toFixed(1)}-tone step${where} (reached ${reached.toFixed(1)} at full strength). Lower the intensity, move the surface away from ${extreme}, or raise a tuned-down \`reach\`.`);
+}
+/**
+* `1 stop`, `2 stops`, `1.5 stops`, `0.004 stops`: three significant digits,
+* so a small headroom never reads as `0 stops`.
+*/
+function stopsLabel(stops) {
+	const n = Number(stops.toPrecision(3));
+	return `${n} stop${n === 1 ? "" : "s"}`;
+}
+/**
+* Warn when an HDR glow's gain is capped by its `headroom` short of the step:
+* the brightest channel sits at `2^headroom` and the composite lands
+* `reached` tones above the surface instead of `step`. Replaces the SDR
+* shortfall warning for that variant — when the cap does not bind, HDR covers
+* the step and neither warning fires. `name` / `scheme` are omitted for the
+* standalone `glaze.glow()`.
+*/
+function warnHdrUnreachable(name, scheme, step, reached, headroom) {
+	if (reached >= step - LIGHTING_WARN_SLACK) return;
+	const label = scheme ? schemeLabel(scheme.isDark, scheme.isHighContrast) : void 0;
+	if (dedupe(`hdr|${name ?? ""}|${label ?? ""}|${step.toFixed(2)}|${reached.toFixed(2)}|${headroom}`)) return;
+	const subject = name === void 0 ? "glaze.glow()" : `glow "${name}"`;
+	const where = label === void 0 ? "" : ` in ${label} scheme`;
+	const advice = headroom >= MAX_HEADROOM ? `Lower the intensity; \`headroom\` is already at its ${MAX_HEADROOM}-stop maximum.` : "Lower the intensity or raise `headroom`.";
+	console.warn(`glaze: ${subject} cannot reach a ${step.toFixed(1)}-tone step${where} even with ${stopsLabel(headroom)} of headroom (reached ${reached.toFixed(1)}). ${advice}`);
+}
+/**
+* Report a shadow / glow solve that lands short. A glow with an HDR value
+* (the author opted into headroom) warns only when the headroom cap leaves
+* the step short (`warnHdrUnreachable`); everything else gets the SDR
+* shortfall warning (`warnLightingUnreachable`), unchanged at headroom 0.
+*/
+function warnLightingShortfall(kind, name, scheme, result, headroom) {
+	if (result.hdr) warnHdrUnreachable(name, scheme, result.step, result.hdr.reached, headroom);
+	else warnLightingUnreachable(kind, name, scheme, result.step, result.reached);
+}
+/** Send the queued warnings, in the order they were found. */
+function flushWarnings(deferred) {
+	for (const warn of deferred) warn();
+}
+/**
+* Warn, once per field and value, that a glow `headroom` above the maximum was
+* clamped. The likely cause is a ratio typed where stops were meant (`4` for
+* "4× white", which is 2 stops), so the message spells out the unit.
+*/
+function warnHeadroomClamped(where, value) {
+	if (dedupe(`headroom|${where}|${value}`)) return;
+	console.warn(`glaze: ${where}.headroom ${value} is above the ${MAX_HEADROOM}-stop maximum; using ${MAX_HEADROOM}. Headroom counts stops (doublings of SDR white's luminance), not a ratio: 1 stop is 2× white, 2 stops 4×.`);
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Glaze global configuration singleton.
+*
+* `configure()` mutates the singleton; every other module reads it via
+* `getConfig()` at call time so changes take effect for subsequent
+* resolves. Per-instance overrides (themes / color tokens) stay sparse —
+* omitted fields fall through to the live global at resolve time.
+* Authoring exports freeze the effective merge at export call time.
+*
+* `pastel` is instance-only (theme / token override or per-color def),
+* never set via `configure()`.
+*
+* Numeric fields are validated where they enter — `configure()` for the
+* global, `mergeConfig()` (i.e. at resolve) for per-instance overrides:
+* `contrastLevel` clamps to 0–100, `darkDesaturation` to 0–1, and tone windows
+* are checked and clamped by `normalizeToneWindow`; a non-finite value throws.
+* Both entry points treat only `undefined` as "keep" for a tone window, so a
+* `null` throws in either. A glow's HDR `headroom` (`normalizeLightingTuning`,
+* shared with the per-color and standalone validators) must be a finite number
+* ≥ 0 and clamps to `MAX_HEADROOM` stops with a one-time warning; a `headroom`
+* on shadow tuning throws. Both entry points hold that warning back
+* (`DeferredWarnings`) until every field has passed, so a call that throws on
+* a later field doesn't spend it before the corrected retry applies the clamp.
+*
+* No config object is shared with a caller, in either direction. Going in,
+* `configure()` copies what it keeps and a theme or token copies its override
+* once where it stores it (`copyConfigOverride`, which reads each known field
+* by property access, so getters and proxies work). Coming out,
+* `snapshotConfig()` (`glaze.getConfig()`) and `theme.getConfig()`
+* (`copyResolvedConfig`) hand out deep copies, and `mergeConfig()` /
+* `freezeConfigForExport()` build fresh objects. So mutating a value passed in
+* or handed out can't change a resolve or an export.
+*/
+/**
+* Build a fresh defaults object. Called from module init and from
+* `resetConfig()` so the two paths can't drift.
+*
+* `pastel: false` is a fixed instance default — not globally configurable.
+*/
+function defaultConfig() {
+	return {
+		lightTone: {
+			lo: 10,
+			hi: 100,
+			eps: .05
+		},
+		darkTone: {
+			lo: 15,
+			hi: 95,
+			eps: .05
+		},
+		darkDesaturation: .1,
+		states: {
+			dark: "@media(prefers-color-scheme: dark)",
+			highContrast: "@media(prefers-contrast: more)",
+			hdr: "@media(dynamic-range: high)"
+		},
+		modes: {
+			dark: true,
+			highContrast: false,
+			hdr: false
+		},
+		autoFlip: true,
+		pastel: false,
+		inferRole: true,
+		contrastLevel: "auto"
+	};
+}
+/**
+* Validate an authored `contrastLevel`. Numbers clamp to 0–100 so a slider
+* can't produce an out-of-range level; a non-finite number throws rather than
+* silently reading as `'auto'`, which would turn a `NaN` slider value into an
+* invisible no-op.
+*/
+function normalizeContrastLevel(value) {
+	if (value === void 0 || value === "auto") return "auto";
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`glaze: contrastLevel must be a finite number 0–100 or 'auto' (got ${showValue(value)}).`);
+	return Math.max(0, Math.min(100, value));
+}
+/**
+* Validate an authored `darkDesaturation`, the way `normalizeContrastLevel`
+* treats a level. Numbers clamp to 0–1 — above 1 would zero every dark
+* saturation and a negative value would raise it — and a non-finite or
+* non-number value throws instead of producing `NaN` saturations.
+*/
+function normalizeDarkDesaturation(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`glaze: darkDesaturation must be a finite number 0–1 (got ${showValue(value)}).`);
+	return Math.max(0, Math.min(1, value));
+}
+/**
+* Validate an authored tone window (see `normalizeToneWindow`) and return it in
+* the form it was written — `false`, `[lo, hi]`, or `{ lo, hi, eps }` — with
+* the endpoints clamped to 0–100. Always a fresh value, so mutating the
+* caller's array or object later can't reach the config.
+*/
+function normalizeToneWindowInput(win, field) {
+	if (win === false) return false;
+	const { lo, hi, eps } = normalizeToneWindow(win, field);
+	return Array.isArray(win) ? [lo, hi] : {
+		lo,
+		hi,
+		eps
+	};
+}
+/**
+* Validate a glow's HDR `headroom` (stops above SDR white). A non-number,
+* non-finite, or negative value throws; one above `MAX_HEADROOM` clamps to it
+* with a one-time warning, since a ratio typed where stops were meant (`4` for
+* "4× white") is the likely cause. `where` names the tuning in messages
+* (`glowTuning`, `glow "x" tuning`, `glaze.glow() tuning`).
+*
+* With `deferred`, the clamp warning is queued there instead of sent, for a
+* caller that validates more fields after this one: it sends the queue only
+* once the whole input has passed (`flushWarnings`).
+*/
+function normalizeHeadroom(value, where, deferred) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`glaze: ${where}.headroom must be a finite number ≥ 0 — stops above SDR white (got ${showValue(value)}).`);
+	if (value > MAX_HEADROOM) {
+		const warn = () => warnHeadroomClamped(where, value);
+		if (deferred) deferred.push(warn);
+		else warn();
+		return MAX_HEADROOM;
+	}
+	return value;
+}
+/**
+* Validate and copy a lighting tuning: a detached copy (or `undefined`) with a
+* glow's `headroom` checked and clamped by `normalizeHeadroom`. A shadow has no
+* headroom — it darkens toward black, and nothing goes below black — so a
+* `headroom` on shadow tuning throws. Only `undefined` counts as unset.
+* `deferred` queues the clamp warning (see `normalizeHeadroom`).
+*/
+function normalizeLightingTuning(kind, tuning, where, deferred) {
+	if (tuning === void 0) return void 0;
+	const out = { ...tuning };
+	const headroom = tuning?.headroom;
+	if (headroom === void 0) return out;
+	if (kind === "shadow") throw new Error(`glaze: ${where}.headroom is not supported — a shadow darkens toward black, and nothing goes below black. Headroom is for glows (glowTuning or a glow's tuning).`);
+	out.headroom = normalizeHeadroom(headroom, where, deferred);
+	return out;
+}
+/**
+* Detached copy of a resolved config: windows, `states`, `modes` and tunings
+* included, with the same keys present. Hand-written rather than
+* `structuredClone` because `theme.getConfig()` uses it, and palettes call
+* that once per theme on every output; this is ~30× cheaper.
+*/
+function copyResolvedConfig(config) {
+	const copyWindow = (win) => win === false ? false : Array.isArray(win) ? [win[0], win[1]] : { ...win };
+	const out = {
+		...config,
+		lightTone: copyWindow(config.lightTone),
+		darkTone: copyWindow(config.darkTone),
+		states: { ...config.states },
+		modes: { ...config.modes }
+	};
+	if (config.shadowTuning) out.shadowTuning = { ...config.shadowTuning };
+	if (config.glowTuning) out.glowTuning = { ...config.glowTuning };
+	return out;
+}
+/**
+* Override window copy, unvalidated: an array is spread, an object is rebuilt
+* from `lo` / `hi` / `eps` read by property access (as `normalizeToneWindow`
+* reads it, so a getter-backed window still works), and anything else
+* (`false`, `null`, a bad scalar) passes through for `mergeConfig()` to judge.
+*/
+function copyWindowField(win) {
+	if (Array.isArray(win)) return [...win];
+	if (typeof win === "object" && win !== null) {
+		const { lo, hi, eps } = win;
+		return {
+			lo,
+			hi,
+			eps
+		};
+	}
+	return win;
+}
+/**
+* Override tuning copy, unvalidated: an object is spread (as `mergeConfig()`
+* copies it); anything else passes through.
+*/
+function copyTuningField(tuning) {
+	return typeof tuning === "object" && tuning !== null ? { ...tuning } : tuning;
+}
+const keepField = (value) => value;
+/**
+* How `copyConfigOverride` copies each field. A record over every
+* `GlazeConfigOverride` key, so a field added to the type doesn't compile
+* until it's listed here.
+*/
+const OVERRIDE_FIELD_COPY = {
+	lightTone: copyWindowField,
+	darkTone: copyWindowField,
+	darkDesaturation: keepField,
+	autoFlip: keepField,
+	contrastLevel: keepField,
+	pastel: keepField,
+	inferRole: keepField,
+	shadowTuning: copyTuningField,
+	glowTuning: copyTuningField
+};
+/**
+* Detached copy of a per-instance override, taken once where a theme or token
+* stores it so that resolve, `getConfig()`, `export()` and `extend()` all read
+* one object the caller can no longer reach. Every nested field
+* (`lightTone` / `darkTone` / `shadowTuning` / `glowTuning`) is copied one
+* level deep, which is all the nesting the type has. Nothing is validated
+* here — that still happens in `mergeConfig()` at resolve, as documented.
+*
+* Each known field is read by property access (`key in override`, then
+* `override[key]`) rather than spread, so a field `mergeConfig()` would see —
+* a class getter, an inherited field, a reactive proxy's trap — is copied too,
+* and a non-cloneable wrapper still works as an override. A non-object passes
+* through unchanged.
+*/
+function copyConfigOverride(override) {
+	if (typeof override !== "object" || override === null) return override;
+	const source = override;
+	const out = {};
+	for (const [key, copy] of Object.entries(OVERRIDE_FIELD_COPY)) if (key in source) out[key] = copy(source[key]);
+	return out;
+}
+let globalConfig = defaultConfig();
+/**
+* Monotonic counter incremented on every `configure()` / `resetConfig()`
+* call. Theme / palette caches read this to invalidate stale resolve
+* results when the config changes between exports.
+*/
+let configVersion = 0;
+/** Live reference to the current config. Mutated by `configure()` / `resetConfig()`. */
+function getConfig() {
+	return globalConfig;
+}
+function getConfigVersion() {
+	return configVersion;
+}
+/**
+* Public-facing snapshot used by `glaze.getConfig()`. A deep copy — nested
+* `states`, `modes`, object windows, and tunings included — so mutating it
+* can't change the live config behind `configure()`'s back (which would skip
+* the version bump and leave every cache stale).
+*/
+function snapshotConfig() {
+	return structuredClone(globalConfig);
+}
+/**
+* Merge a `GlazeConfig` into the global config. Fields are validated before
+* anything changes, so a call that throws leaves the config (and its version)
+* untouched — and sends no warning: a headroom clamp found on the way is sent
+* only once every field has passed, so the corrected retry still reports it.
+* A tone window is kept only when it's `undefined`, as in `mergeConfig()`: a
+* `null` (say, from a JSON config) throws the same error an instance override
+* with it does.
+*/
+function configure(config) {
+	const deferred = [];
+	const next = {
+		lightTone: normalizeToneWindowInput(config.lightTone !== void 0 ? config.lightTone : globalConfig.lightTone, "lightTone"),
+		darkTone: normalizeToneWindowInput(config.darkTone !== void 0 ? config.darkTone : globalConfig.darkTone, "darkTone"),
+		darkDesaturation: normalizeDarkDesaturation(config.darkDesaturation ?? globalConfig.darkDesaturation),
+		states: {
+			dark: config.states?.dark ?? globalConfig.states.dark,
+			highContrast: config.states?.highContrast ?? globalConfig.states.highContrast,
+			hdr: config.states?.hdr ?? globalConfig.states.hdr
+		},
+		modes: {
+			dark: config.modes?.dark ?? globalConfig.modes.dark,
+			highContrast: config.modes?.highContrast ?? globalConfig.modes.highContrast,
+			hdr: config.modes?.hdr ?? globalConfig.modes.hdr
+		},
+		shadowTuning: normalizeLightingTuning("shadow", config.shadowTuning ?? globalConfig.shadowTuning, "shadowTuning"),
+		glowTuning: normalizeLightingTuning("glow", config.glowTuning ?? globalConfig.glowTuning, "glowTuning", deferred),
+		autoFlip: config.autoFlip ?? globalConfig.autoFlip,
+		pastel: false,
+		inferRole: config.inferRole ?? globalConfig.inferRole,
+		contrastLevel: normalizeContrastLevel(config.contrastLevel ?? globalConfig.contrastLevel)
+	};
+	flushWarnings(deferred);
+	configVersion++;
+	globalConfig = next;
+}
+function resetConfig() {
+	configVersion++;
+	globalConfig = defaultConfig();
+}
+/**
+* Merge a per-instance config override over a base resolved config.
+* Only fields present in `override` are replaced; others fall through
+* from `base`. `false` for tone windows passes through as-is
+* (treated as the full range by `activeWindow()` in okhst.ts).
+*
+* This is where an instance's override is validated (at resolve), with the
+* same rules `configure()` applies to the global. The result is always a fresh
+* object that shares nothing with `base` or `override`, so an instance's
+* cached config can't alias the live global.
+*
+* `pastel` is instance-only: `override.pastel ?? false`, never inherited
+* from the global base. As in `configure()`, a headroom clamp warning is sent
+* only once every field has passed.
+*/
+function mergeConfig(base, override = {}) {
+	const deferred = [];
+	const merged = {
+		lightTone: normalizeToneWindowInput(override.lightTone !== void 0 ? override.lightTone : base.lightTone, "lightTone"),
+		darkTone: normalizeToneWindowInput(override.darkTone !== void 0 ? override.darkTone : base.darkTone, "darkTone"),
+		darkDesaturation: normalizeDarkDesaturation(override.darkDesaturation ?? base.darkDesaturation),
+		states: { ...base.states },
+		modes: { ...base.modes },
+		shadowTuning: normalizeLightingTuning("shadow", override.shadowTuning ?? base.shadowTuning, "shadowTuning"),
+		glowTuning: normalizeLightingTuning("glow", override.glowTuning ?? base.glowTuning, "glowTuning", deferred),
+		autoFlip: override.autoFlip ?? base.autoFlip,
+		pastel: override.pastel ?? false,
+		inferRole: override.inferRole ?? base.inferRole,
+		contrastLevel: normalizeContrastLevel(override.contrastLevel ?? base.contrastLevel)
+	};
+	flushWarnings(deferred);
+	return merged;
+}
+/**
+* Freeze `getConfig() ∪ instanceLocal ∪ exportArg` as a plain, resolve-relevant
+* override for authoring export, so restored snapshots pin these fields. Later
+* wins; nested objects (`shadowTuning` / `glowTuning`) replace wholesale.
+* `exportArg` is read through `copyConfigOverride`, like a stored override, so
+* its getters count too. `mergeConfig` already validates and copies every
+* field; the final `structuredClone` keeps the snapshot detached even if that
+* ever changes.
+*/
+function freezeConfigForExport(instanceLocal, exportArg) {
+	const effective = mergeConfig(getConfig(), {
+		...instanceLocal,
+		...copyConfigOverride(exportArg)
+	});
+	const out = {
+		lightTone: effective.lightTone,
+		darkTone: effective.darkTone,
+		darkDesaturation: effective.darkDesaturation,
+		autoFlip: effective.autoFlip,
+		pastel: effective.pastel,
+		inferRole: effective.inferRole
+	};
+	if (effective.shadowTuning !== void 0) out.shadowTuning = effective.shadowTuning;
+	if (effective.glowTuning !== void 0) out.glowTuning = effective.glowTuning;
+	const authoredLevel = exportArg?.contrastLevel ?? instanceLocal?.contrastLevel;
+	if (authoredLevel !== void 0) out.contrastLevel = normalizeContrastLevel(authoredLevel);
+	return structuredClone(out);
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* Current authoring-export schema version. Bump when the export shape
+* changes in a non-compatible way. Written on every `.export()` snapshot.
+*
+* - `1` — Glaze 2.x.
+* - `2` — Glaze 3: `shadow` `intensity` / `fg` / `tuning` changed meaning and
+*   `glow` was added. Version-1 theme snapshots that carry shadow defs or a
+*   `shadowTuning` are rejected on restore.
+*/
+const GLAZE_EXPORT_VERSION = 2;
+
+//#endregion
+//#region src/serialize.ts
+/**
+* Authoring-export helpers: schema version, type guards, and restore
+* validation shared by `themeFrom` / `colorFrom` / `paletteFrom`.
+*/
+function isPlainObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+/**
+* Reject unknown / invalid schema versions. Missing `version` is allowed
+* (legacy snapshots). Present versions must be an integer in
+* `1..=GLAZE_EXPORT_VERSION`.
+*/
+function assertExportVersion(data, factory) {
+	if (data.version === void 0) return;
+	if (typeof data.version !== "number" || !Number.isInteger(data.version) || data.version < 1) throw new Error(`${factory}: invalid "version" field — expected an integer >= 1 (got ${JSON.stringify(data.version)}).`);
+	if (data.version > GLAZE_EXPORT_VERSION) throw new Error(`${factory}: unsupported export version ${data.version} (this library supports version ${GLAZE_EXPORT_VERSION}). Upgrade @tenphi/glaze to load this snapshot.`);
+}
+/**
+* Reject a version-1 (Glaze 2) theme snapshot that carries shadow colors or a
+* `shadowTuning`. Glaze 3 changed what shadow `intensity`, `fg` and tuning
+* mean, so restoring one would silently re-render every shadow differently.
+* Version-1 snapshots without shadows load as before. `fallbackVersion` is the
+* enclosing palette's version, for a theme entry that carries none of its own.
+*/
+function assertNoLegacyShadows(data, factory, fallbackVersion) {
+	if ((data.version ?? fallbackVersion) !== 1) return;
+	const colors = isPlainObject(data.colors) ? data.colors : {};
+	const shadows = Object.keys(colors).filter((name) => isPlainObject(colors[name]) && colors[name].type === "shadow");
+	const hasTuning = isPlainObject(data.config) && data.config.shadowTuning !== void 0;
+	if (shadows.length === 0 && !hasTuning) return;
+	const what = shadows.length > 0 ? `shadow colors (${shadows.map((n) => JSON.stringify(n)).join(", ")})` : "a \"shadowTuning\" config";
+	throw new Error(`${factory}: this snapshot is export version 1 (Glaze 2) and contains ${what}. Glaze 3 changed what shadow "intensity", "fg" and tuning mean, so it would restore with different shadows. Re-author them as described in docs/migration.md ("3.0 — shadows and glows") and export again.`);
+}
+/**
+* When `kind` is present, it must match the factory. Missing `kind` is
+* allowed for legacy snapshots.
+*/
+function assertExportKind(data, expected, factory) {
+	if (data.kind === void 0) return;
+	if (data.kind !== expected) throw new Error(`${factory}: expected kind "${expected}", got ${JSON.stringify(data.kind)}.`);
+}
+function hasThemeShape(data) {
+	return typeof data.hue === "number" && typeof data.saturation === "number" && !("form" in data) && !("themes" in data);
+}
+function hasColorTokenShape(data) {
+	return data.form === "value" || data.form === "structured";
+}
+function hasPaletteShape(data) {
+	return isPlainObject(data.themes) && !("form" in data) && typeof data.hue !== "number";
+}
+/** Type guard for theme authoring snapshots (prefers `kind`, falls back to shape). */
+function isThemeExport(data) {
+	if (!isPlainObject(data)) return false;
+	if (data.kind === "theme") return hasThemeShape(data);
+	if (data.kind !== void 0) return false;
+	return hasThemeShape(data);
+}
+/** Type guard for color-token authoring snapshots. */
+function isColorTokenExport(data) {
+	if (!isPlainObject(data)) return false;
+	if (data.kind === "color") return hasColorTokenShape(data);
+	if (data.kind !== void 0) return false;
+	return hasColorTokenShape(data);
+}
+/** Type guard for palette authoring snapshots. */
+function isPaletteExport(data) {
+	if (!isPlainObject(data)) return false;
+	if (data.kind === "palette") return hasPaletteShape(data);
+	if (data.kind !== void 0) return false;
+	return hasPaletteShape(data);
+}
+
+//#endregion
+//#region src/channels.ts
+/**
+* Hue channel planning for `splitHue` exports.
+*
+* Builds per-color hue var references and the `--*-hue` declarations backing
+* them for oklch CSS / Tasty output when every color is pastel.
+*
+* Hue is scheme-independent unless the theme or a color authors a dark hue,
+* so declarations are collected per scheme (`'light'` / `'dark'`) and the dark
+* set is emitted only when it actually differs — see `buildHueDeclarations`.
+* A color that authors a hue in *either* scheme gets its own var in both, so
+* the shared `var()` reference stays valid. Every scheme renders with the
+* light plan (`buildHuePlans`), so a color inline in light (achromatic there)
+* is inline everywhere and declares no var in any scheme. Numeric hue values
+* are rounded to 2 decimals, the precision of the hue in `oklch()` output.
+*
+* Also owns the `splitHue` guards the output methods run before planning:
+* `assertSplitHueFormat` (only `oklch()` takes a `var()` hue), and
+* `claimHueVars` / `claimValueProps`, which keep every custom property an
+* export declares to one owner — the theme var, a color's own hue var, and
+* (`css()` only) each color's value property share one namespace.
+*/
+const ACHROMATIC_EPSILON$1 = 1e-6;
+const SCHEMES$1 = ["light", "dark"];
+/**
+* A numeric hue as emitted in a declaration: 2 decimals, matching the hue of
+* `formatOklch`, so a `from` color doesn't leak `266.15797905637027`.
+*/
+function hueValue(h) {
+	return parseFloat(h.toFixed(2)).toString();
+}
+/**
+* Throw when `splitHue` is on and the format can't carry a `var()` hue. Only
+* `oklch()` has a hue slot a custom property can stand in for; silently
+* emitting inline colors instead would leave the hue vars the caller asked
+* for missing.
+*/
+function assertSplitHueFormat(splitHue, format) {
+	if (splitHue && format !== "oklch") throw new Error(`glaze: splitHue requires format 'oklch' (got '${format}'). Use format: 'oklch' or drop splitHue.`);
+}
+function cssProp(prefix, name, suffix) {
+	return `--${prefix}${name}${suffix}`;
+}
+function isAchromatic(v) {
+	return v.s <= ACHROMATIC_EPSILON$1;
+}
+/** Seed hue backing `--{baseName}-hue` in a given scheme. */
+function schemeSeedHue(ctx, scheme) {
+	return scheme === "dark" ? ctx.darkSeedHue ?? ctx.seedHue : ctx.seedHue;
+}
+function themeHuePlan(name, def, variant, ctx, scheme) {
+	if (def === void 0 || isLightingDef(def) || isMixDef(def) || isAchromatic(variant)) return {
+		hueVar: "",
+		inline: true,
+		declarations: []
+	};
+	const regDef = def;
+	const baseHueVar = `var(--${ctx.baseName}-hue)`;
+	const prop = cssProp(ctx.prefix, name, "-hue");
+	if ((regDef.mode ?? "auto") === "static" && schemeSeedHue(ctx, "dark") !== ctx.seedHue) return {
+		hueVar: `var(${prop})`,
+		inline: false,
+		declarations: [{
+			prop,
+			value: hueValue(variant.h)
+		}]
+	};
+	if (regDef.hue === void 0 && regDef.darkHue === void 0 && regDef.from === void 0) return {
+		hueVar: baseHueVar,
+		inline: false,
+		declarations: []
+	};
+	const authored = scheme === "dark" ? regDef.darkHue ?? regDef.hue : regDef.hue;
+	if (authored === void 0) {
+		if (regDef.from !== void 0) return {
+			hueVar: `var(${prop})`,
+			inline: false,
+			declarations: [{
+				prop,
+				value: hueValue(variant.h)
+			}]
+		};
+		return {
+			hueVar: `var(${prop})`,
+			inline: false,
+			declarations: [{
+				prop,
+				value: baseHueVar
+			}]
+		};
+	}
+	const parsed = parseRelativeOrAbsolute(authored);
+	if (parsed.relative) {
+		const sign = parsed.value >= 0 ? "+" : "-";
+		const magnitude = hueValue(Math.abs(parsed.value));
+		const value = `calc(var(--${ctx.baseName}-hue) ${sign} ${magnitude})`;
+		return {
+			hueVar: `var(${prop})`,
+			inline: false,
+			declarations: [{
+				prop,
+				value
+			}]
+		};
+	}
+	const absHue = (parsed.value % 360 + 360) % 360;
+	return {
+		hueVar: `var(${prop})`,
+		inline: false,
+		declarations: [{
+			prop,
+			value: hueValue(absHue)
+		}]
+	};
+}
+function standaloneHuePlan(name, variant, ctx, scheme) {
+	if (isAchromatic(variant)) return {
+		hueVar: "",
+		inline: true,
+		declarations: []
+	};
+	const hue = scheme === "dark" ? variant.h : ctx.resolvedHue ?? variant.h;
+	const prop = cssProp(ctx.prefix, name, "-hue");
+	return {
+		hueVar: `var(${prop})`,
+		inline: false,
+		declarations: [{
+			prop,
+			value: hueValue(hue)
+		}]
+	};
+}
+function buildHuePlan(name, def, variant, ctx, scheme = "light") {
+	if (ctx.mode === "standalone") return standaloneHuePlan(name, variant, ctx, scheme);
+	return themeHuePlan(name, def, variant, ctx, scheme);
+}
+/**
+* The plan whose declarations `name` contributes in `scheme`, or `undefined`
+* when the color declares nothing.
+*
+* Rendering uses the light plan in every scheme (`buildHuePlans`), so a color
+* whose light plan is inline — achromatic in light, say — is a literal
+* `oklch()` everywhere. Its dark plan may still name a var (it has chroma
+* there), but nothing would read it: a dead declaration that, in an unprefixed
+* palette, could override another theme's live hue var.
+*/
+function declaringPlan(name, color, ctx, scheme) {
+	const def = ctx.defs[name];
+	const light = buildHuePlan(name, def, color.light, ctx);
+	if (light.inline) return void 0;
+	if (scheme === "light") return light;
+	return buildHuePlan(name, def, color.dark, ctx, scheme);
+}
+/** Collect unique hue declarations across all colors (theme + per-color). */
+function collectHueDeclarations(resolved, ctx, scheme) {
+	if (ctx.emitDeclarations === false) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const push = (decl) => {
+		if (seen.has(decl.prop)) return;
+		seen.add(decl.prop);
+		out.push(decl);
+	};
+	if (ctx.mode === "theme") push({
+		prop: `--${ctx.baseName}-hue`,
+		value: hueValue(schemeSeedHue(ctx, scheme))
+	});
+	for (const [name, color] of resolved) {
+		const plan = declaringPlan(name, color, ctx, scheme);
+		for (const decl of plan?.declarations ?? []) push(decl);
+	}
+	return out;
+}
+/**
+* Hue declarations for both schemes. `dark` is empty when it resolves to the
+* same hues as light — the common case, with no `darkHue` anywhere.
+*
+* When they differ, the **whole** dark set is returned rather than only the
+* entries whose text changed. A relative declaration reads
+* `calc(var(--theme-hue) + N)` in both schemes even though its resolved value
+* moves with the seed, and custom properties substitute `var()` at
+* computed-value time on the declaring element — so re-declaring
+* `--{baseName}-hue` alone would leave inherited per-color vars still holding
+* the light-substituted value.
+*/
+function buildHueDeclarations(resolved, ctx) {
+	const light = collectHueDeclarations(resolved, ctx, "light");
+	const dark = collectHueDeclarations(resolved, ctx, "dark");
+	return {
+		light,
+		dark: dark.length === light.length && dark.every((decl, i) => decl.prop === light[i].prop && decl.value === light[i].value) ? [] : dark
+	};
+}
+function buildHuePlans(resolved, ctx) {
+	const plans = /* @__PURE__ */ new Map();
+	for (const [name, color] of resolved) plans.set(name, buildHuePlan(name, ctx.defs[name], color.light, ctx));
+	return plans;
+}
+/**
+* Record `prop` as `owner`'s, or throw when someone else already holds it. A
+* repeat claim by the same owner is fine: that is the same declaration seen
+* again (a theme pass re-run with the same prefix).
+*/
+function claim(owners, prop, owner, labels) {
+	const held = owners.get(prop);
+	if (held === void 0) {
+		owners.set(prop, owner);
+		return;
+	}
+	if (held.label === owner.label) return;
+	const fix = held.value || owner.value ? labels.valueFix : labels.fix;
+	throw new Error(`glaze: splitHue would declare "${prop}" twice: for ${held.label} and for ${owner.label}. One would silently override the other. ${fix}`);
+}
+/**
+* Claim every hue var this pass declares in `owners` and throw when a name is
+* already held by someone else.
+*
+* Theme and per-color vars share one namespace: `--{baseName}-hue` and
+* `--{prefix}{color}-hue`. A color named after the theme var (`brand` with
+* `name: 'brand'`), or a palette color named after another theme under an
+* empty prefix, would declare the same property as the theme. Only one value
+* survives — the theme's, after `collectHueDeclarations` dedupes — so the
+* color would silently render at the wrong hue.
+*
+* Every declaration a rendered plan references is claimed, in both schemes: a
+* color's own var only when its light plan references it. That includes a
+* declaration `collectHueDeclarations` would drop as a duplicate (a chromatic
+* `brand` color under `name: 'brand'`), since the color would still read the
+* survivor's hue. A color achromatic in light is inline in every scheme and
+* declares nothing, so it can share a name with the theme var.
+*/
+function claimHueVars(resolved, ctx, owners, labels) {
+	if (ctx.emitDeclarations === false) return;
+	if (ctx.mode === "theme") {
+		const owner = {
+			label: labels.theme,
+			value: false
+		};
+		claim(owners, `--${ctx.baseName}-hue`, owner, labels);
+	}
+	for (const [name, color] of resolved) {
+		const owner = {
+			label: labels.color(name),
+			value: false
+		};
+		for (const scheme of SCHEMES$1) {
+			const plan = declaringPlan(name, color, ctx, scheme);
+			for (const decl of plan?.declarations ?? []) claim(owners, decl.prop, owner, labels);
+		}
+	}
+}
+/**
+* Claim each color's `css()` value property, `--{prefix}{color}{suffix}`, in
+* the same `owners` map as the hue vars.
+*
+* Value properties share the custom-property namespace with the hue vars, so
+* `suffix: '-hue'` — or `suffix: ''` with a color named `*-hue` — can land a
+* color's value on a hue var: its own, which makes a `var()` cycle, or one
+* another color or theme declares (in a palette, another theme's), which
+* hands every color reading it a color string where a hue belongs. Either way
+* the CSS is invalid at computed-value time.
+*
+* Unlike `claimHueVars` this runs on every pass, including one that declares
+* no hue vars (a palette's primary aliases): its value properties are emitted
+* all the same. Not for `tasty()`, whose `#name` colors compile to
+* `--name-color` and can't land on a `$…-hue` var.
+*/
+function claimValueProps(resolved, prefix, suffix, owners, labels) {
+	for (const name of resolved.keys()) {
+		const owner = {
+			label: labels.value(name),
+			value: true
+		};
+		claim(owners, cssProp(prefix, name, suffix), owner, labels);
+	}
+}
+
+//#endregion
+//#region src/color-value.ts
+/**
+* Parsing and validation for `GlazeColorValue` — the literal color forms.
+*
+* Hex, the CSS color functions Glaze emits, and the four value-object shapes all
+* land here and come out as OKHSL. Split out of `color-token.ts` so both
+* consumers can reach it without an import cycle: standalone `glaze.color()`
+* tokens build on it, and the resolver needs it for a theme color's `from`. It
+* depends on nothing but the color math, which is what keeps that true.
+*/
+/**
+* Matches the color functions Glaze itself emits (`rgb()`, `hsl()`, `okhsl()`,
+* `okhst()`, `oklch()`) plus their legacy alpha aliases (`rgba()`, `hsla()`).
+*
+* Only numeric components are supported; named colors (`red`) and
+* relative-color syntax (`from <color> ...`) are out of scope. Hue is read with
+* `parseFloat`, so a bare number or `deg` is degrees and any other angle unit
+* (`turn`, `rad`, `grad`) is misread as degrees.
+*/
+const COLOR_FN_RE = /^(rgba?|hsla?|okhsl|okhst|oklch)\(\s*([^)]*)\s*\)$/i;
+function parseNumberOrPercent(raw, percentScale) {
+	if (raw.endsWith("%")) return parseFloat(raw) / 100 * percentScale;
+	return parseFloat(raw);
+}
+/**
+* Split the body of a CSS color function into its components and detect
+* whether an alpha channel was present.
+*
+* Handles both modern slash syntax (`R G B / A` or `R, G, B / A`) and
+* legacy comma syntax (`R, G, B, A`). The alpha value itself is discarded
+* by the caller — standalone Glaze colors have no opacity field.
+*/
+function splitColorBody(body) {
+	const slashIdx = body.indexOf("/");
+	if (slashIdx !== -1) return {
+		components: body.slice(0, slashIdx).trim().split(/[\s,]+/).filter(Boolean),
+		hadAlpha: body.slice(slashIdx + 1).trim().length > 0
+	};
+	const components = body.split(/[\s,]+/).filter(Boolean);
+	if (components.length === 4) {
+		components.pop();
+		return {
+			components,
+			hadAlpha: true
+		};
+	}
+	return {
+		components,
+		hadAlpha: false
 	};
-	if (flip) {
-		const oppositeResult = (initialIsLower ? distanceAnchor < hi : distanceAnchor > lo) ? runBranch(!initialIsLower) : null;
-		if (oppositeResult) oppositeResult.met = oppositeResult.contrast >= target;
-		if (initialResult.met && oppositeResult?.met) {
-			if (preferInitial) return {
-				...initialResult,
-				lower: initialIsLower
+}
+function warnDroppedAlpha(input) {
+	console.warn(`glaze: alpha component dropped from "${input}" (standalone color has no opacity field).`);
+}
+function parseColorString(input) {
+	if (input.startsWith("#")) {
+		const parsed = parseHexAlpha(input);
+		if (!parsed) throw new Error(`glaze: invalid hex color "${input}".`);
+		if (parsed.alpha !== void 0) warnDroppedAlpha(input);
+		const [h, s, l] = srgbToOkhsl(parsed.rgb);
+		return {
+			h,
+			s,
+			l
+		};
+	}
+	const m = input.match(COLOR_FN_RE);
+	if (!m) throw new Error(`glaze: unsupported color string "${input}".`);
+	const fn = m[1].toLowerCase();
+	const { components, hadAlpha } = splitColorBody(m[2].trim());
+	if (hadAlpha) warnDroppedAlpha(input);
+	if (components.length !== 3) throw new Error(`glaze: expected 3 components in "${input}".`);
+	switch (fn) {
+		case "rgb":
+		case "rgba": {
+			const [h, s, l] = srgbToOkhsl([
+				parseNumberOrPercent(components[0], 255) / 255,
+				parseNumberOrPercent(components[1], 255) / 255,
+				parseNumberOrPercent(components[2], 255) / 255
+			]);
+			return {
+				h,
+				s,
+				l
 			};
-			return Math.abs(initialResult.pos - distanceAnchor) <= Math.abs(oppositeResult.pos - distanceAnchor) ? {
-				...initialResult,
-				lower: initialIsLower
-			} : {
-				...oppositeResult,
-				lower: !initialIsLower,
-				flipped: true
+		}
+		case "hsl":
+		case "hsla": {
+			const [oh, os, ol] = srgbToOkhsl(hslToSrgb(parseFloat(components[0]), parseNumberOrPercent(components[1], 1), parseNumberOrPercent(components[2], 1)));
+			return {
+				h: oh,
+				s: os,
+				l: ol
 			};
 		}
-		if (initialResult.met) return {
-			...initialResult,
-			lower: initialIsLower
+		case "okhsl": return {
+			h: parseFloat(components[0]),
+			s: parseNumberOrPercent(components[1], 1),
+			l: parseNumberOrPercent(components[2], 1)
 		};
-		if (oppositeResult?.met) return {
-			...oppositeResult,
-			lower: !initialIsLower,
-			flipped: true
+		case "okhst": return okhstToOkhsl({
+			h: parseFloat(components[0]),
+			s: parseNumberOrPercent(components[1], 1),
+			t: parseNumberOrPercent(components[2], 1)
+		});
+		case "oklch": {
+			const L = parseNumberOrPercent(components[0], 1);
+			const C = parseNumberOrPercent(components[1], .4);
+			const hRad = parseFloat(components[2]) * Math.PI / 180;
+			const [h, s, l] = oklabToOkhsl([
+				L,
+				C * Math.cos(hRad),
+				C * Math.sin(hRad)
+			]);
+			return {
+				h,
+				s,
+				l
+			};
+		}
+	}
+	throw new Error(`glaze: unsupported color function "${fn}".`);
+}
+/**
+* Validate a user-supplied `OkhslColor`. Catches the common 0-100 vs 0-1
+* confusion (the structured form uses 0-100, OKHSL objects use 0-1).
+*/
+function validateOkhslColor(value) {
+	const { h, s, l } = value;
+	if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(l)) throw new Error("glaze.color: OkhslColor h/s/l must be finite numbers.");
+	if (s > 1.5 || l > 1.5) throw new Error("glaze.color: OkhslColor s/l must be in 0–1 range. Did you mean the structured form { hue, saturation, tone } (which uses 0–100)?");
+}
+/** Validate a user-supplied `{ r, g, b }` object in 0–255. */
+function validateRgbColor(value) {
+	for (const key of [
+		"r",
+		"g",
+		"b"
+	]) {
+		const n = value[key];
+		if (!Number.isFinite(n) || n < 0 || n > 255) throw new Error(`glaze.color: RgbColor ${key} must be a finite number in 0–255 (got ${n}).`);
+	}
+}
+/** Validate a user-supplied `{ l, c, h }` OKLCh object. */
+function validateOklchColor(value) {
+	const { l, c, h } = value;
+	if (!Number.isFinite(l) || !Number.isFinite(c) || !Number.isFinite(h)) throw new Error("glaze.color: OklchColor l/c/h must be finite numbers.");
+	if (l > 1.5 || c > 1.5) throw new Error("glaze.color: OklchColor l/c must be in 0–1 range (matching oklch() strings).");
+}
+function oklchComponentsToOkhsl(l, c, hDeg) {
+	const hRad = hDeg * Math.PI / 180;
+	const [h, s, outL] = oklabToOkhsl([
+		l,
+		c * Math.cos(hRad),
+		c * Math.sin(hRad)
+	]);
+	return {
+		h,
+		s,
+		l: outL
+	};
+}
+function isRgbColorObject(value) {
+	return "r" in value && "g" in value && "b" in value;
+}
+function isOklchColorObject(value) {
+	return "c" in value && "l" in value && "h" in value;
+}
+function isOkhstColorObject(value) {
+	return "t" in value && "h" in value && "s" in value;
+}
+/** Validate a user-supplied `{ h, s, t }` OKHST object (s/t in 0–1). */
+function validateOkhstColor(value) {
+	const { h, s, t } = value;
+	if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(t)) throw new Error("glaze.color: OkhstColor h/s/t must be finite numbers.");
+	if (s > 1.5 || t > 1.5) throw new Error("glaze.color: OkhstColor s/t must be in 0–1 range. Did you mean the structured form { hue, saturation, tone } (which uses 0–100)?");
+}
+/**
+* Extract an OKHSL color from any `GlazeColorValue` form. Also used by
+* `glaze.shadow()` / `glaze.glow()` so all their inputs (hex, color
+* functions, OKHSL, literal objects) go through one parser.
+*/
+function extractOkhslFromValue(value) {
+	if (typeof value === "string") return parseColorString(value);
+	if (Array.isArray(value)) throw new Error("glaze.color: RGB tuple [r, g, b] is no longer supported — use { r, g, b } instead.");
+	if (isRgbColorObject(value)) {
+		validateRgbColor(value);
+		const [h, s, l] = srgbToOkhsl([
+			value.r / 255,
+			value.g / 255,
+			value.b / 255
+		]);
+		return {
+			h,
+			s,
+			l
 		};
 	}
-	const extreme = initialIsLower ? lo : hi;
-	return {
-		pos: extreme,
-		contrast: metricScore(metric, lum(extreme), yBase, polarity),
-		met: false,
-		lower: initialIsLower
-	};
+	if (isOklchColorObject(value)) {
+		validateOklchColor(value);
+		return oklchComponentsToOkhsl(value.l, value.c, value.h);
+	}
+	if (isOkhstColorObject(value)) {
+		validateOkhstColor(value);
+		return okhstToOkhsl(value);
+	}
+	validateOkhslColor(value);
+	return value;
 }
+
+//#endregion
+//#region src/format-guard.ts
+const NON_NATIVE_FORMATS = new Set(["okhsl", "okhst"]);
 /**
-* Find the tone that satisfies a contrast floor against a base color,
-* staying as close to `preferredTone` as possible.
+* Throw when a non-native Glaze color space is requested for an export that
+* emits raw CSS or non-Tasty token maps.
 */
-function findToneForContrast(options) {
-	const { hue, saturation, preferredTone, baseLinearRgb, contrast, toneRange = [0, 1], epsilon = 1e-4, maxIterations = 18, pastel = false } = options;
-	const { metric, target, polarity } = contrast;
-	const searchTarget = metric === "wcag" ? target * 1.01 : target + .5;
-	const yBase = metricLuminance(metric, baseLinearRgb);
-	const lum = (t) => cachedLuminance(metric, hue, saturation, t, pastel);
-	const scorePref = metricScore(metric, lum(preferredTone), yBase, polarity);
-	if (scorePref >= searchTarget) return {
-		tone: preferredTone,
-		contrast: scorePref,
-		met: true,
-		branch: "preferred"
-	};
-	const [minT, maxT] = toneRange;
-	const canDarker = preferredTone > minT;
-	const canLighter = preferredTone < maxT;
-	let initialIsDarker;
-	if (options.initialDirection !== void 0) initialIsDarker = options.initialDirection === "darker";
-	else if (canDarker && !canLighter) initialIsDarker = true;
-	else if (!canDarker && canLighter) initialIsDarker = false;
-	else if (!canDarker && !canLighter) return {
-		tone: preferredTone,
-		contrast: scorePref,
-		met: false,
-		branch: "preferred"
-	};
-	else initialIsDarker = metricScore(metric, lum(minT), yBase, polarity) >= metricScore(metric, lum(maxT), yBase, polarity);
-	const solved = solveNearestContrast({
-		lum,
-		yBase,
-		metric,
-		target,
-		searchTarget,
-		lo: minT,
-		hi: maxT,
-		searchAnchor: metric === "wcag" ? clamp(initialIsDarker ? Math.min(preferredTone, wcagToneSeed(yBase, target, true)) : Math.max(preferredTone, wcagToneSeed(yBase, target, false)), minT, maxT) : preferredTone,
-		distanceAnchor: preferredTone,
-		epsilon,
-		maxIterations,
-		flip: options.flip ?? false,
-		preferInitial: options.preferInitial ?? false,
-		initialIsLower: initialIsDarker,
-		polarity
-	});
-	return {
-		tone: solved.pos,
-		contrast: solved.contrast,
-		met: solved.met,
-		branch: solved.lower ? "darker" : "lighter",
-		...solved.flipped ? { flipped: true } : {}
-	};
+function assertNativeFormat(format, method) {
+	if (format !== void 0 && NON_NATIVE_FORMATS.has(format)) throw new Error(`glaze: ${format} output is only supported by tasty() (not a native CSS color space). Use tasty({ format: '${format}' }) or pick a native format (oklch|hsl|rgb) for ${method}().`);
 }
+const SCHEME_FIELDS = [
+	{
+		field: "light",
+		modes: () => true
+	},
+	{
+		field: "dark",
+		modes: (m) => m.dark
+	},
+	{
+		field: "lightContrast",
+		modes: (m) => m.highContrast
+	},
+	{
+		field: "darkContrast",
+		modes: (m) => m.dark && m.highContrast
+	}
+];
 /**
-* Find the mix parameter (ratio or opacity) that satisfies a contrast floor
-* against a base color, staying as close to `preferredValue` as possible.
+* Throw when `splitHue` is enabled but any exported color is not pastel.
+* Hue rotation is only clip-free when chroma is bounded by the hue-independent
+* safe chroma (`computeSafeChromaOKLCH`).
 */
-function findValueForMixContrast(options) {
-	const { preferredValue, baseLinearRgb, contrast, luminanceAtValue, epsilon = 1e-4, maxIterations = 20 } = options;
-	const { metric, target, polarity } = contrast;
-	const searchTarget = metric === "wcag" ? target * 1.01 : target + .5;
-	const yBase = metricLuminance(metric, baseLinearRgb);
-	const scorePref = metricScore(metric, luminanceAtValue(preferredValue), yBase, polarity);
-	if (scorePref >= searchTarget) return {
-		value: preferredValue,
-		contrast: scorePref,
-		met: true
-	};
-	const canLower = preferredValue > 0;
-	const canUpper = preferredValue < 1;
-	let initialIsLower;
-	if (canLower && !canUpper) initialIsLower = true;
-	else if (!canLower && canUpper) initialIsLower = false;
-	else if (!canLower && !canUpper) return {
-		value: preferredValue,
-		contrast: scorePref,
-		met: false
-	};
-	else initialIsLower = metricScore(metric, luminanceAtValue(0), yBase, polarity) >= metricScore(metric, luminanceAtValue(1), yBase, polarity);
-	const solved = solveNearestContrast({
-		lum: luminanceAtValue,
-		yBase,
-		metric,
-		target,
-		searchTarget,
-		lo: 0,
-		hi: 1,
-		searchAnchor: preferredValue,
-		distanceAnchor: preferredValue,
-		epsilon,
-		maxIterations,
-		flip: options.flip ?? false,
-		preferInitial: false,
-		initialIsLower,
-		polarity
-	});
-	return {
-		value: solved.pos,
-		contrast: solved.contrast,
-		met: solved.met,
-		...solved.flipped ? { flipped: true } : {}
-	};
+function assertAllPastel(resolved, modes) {
+	const nonPastel = [];
+	for (const [name, color] of resolved) for (const { field, modes: active } of SCHEME_FIELDS) {
+		if (!active(modes)) continue;
+		if (color[field].pastel !== true) {
+			if (!nonPastel.includes(name)) nonPastel.push(name);
+			break;
+		}
+	}
+	if (nonPastel.length === 0) return;
+	throw new Error(`glaze: splitHue requires every color to be pastel (hue rotation is only clip-free when chroma is bounded by the hue-independent safe chroma). Non-pastel: ${nonPastel.join(", ")}. Set pastel: true (per-theme, per-token, or per-color) or drop splitHue.`);
 }
 
 //#endregion
@@ -2073,87 +3146,18 @@ function oppositeRole(role) {
 	return "surface";
 }
 
-//#endregion
-//#region src/shadow.ts
-/**
-* Shadow color computation.
-*
-* Owns the shadow / mix def predicates, default tuning constants, the
-* tuning merge, and the actual `computeShadow` math (hue blend,
-* saturation cap, lightness clamp, alpha curve). The resolver consumes
-* this module per scheme variant.
-*/
-function isShadowDef(def) {
-	return def.type === "shadow";
-}
-function isMixDef(def) {
-	return def.type === "mix";
-}
-const DEFAULT_SHADOW_TUNING = {
-	saturationFactor: .18,
-	maxSaturation: .25,
-	lightnessFactor: .25,
-	lightnessBounds: [.05, .2],
-	minGapTarget: .05,
-	alphaMax: 1,
-	bgHueBlend: .2
-};
-function resolveShadowTuning(perColor, globalTuning) {
-	return {
-		...DEFAULT_SHADOW_TUNING,
-		...globalTuning,
-		...perColor,
-		lightnessBounds: perColor?.lightnessBounds ?? globalTuning?.lightnessBounds ?? DEFAULT_SHADOW_TUNING.lightnessBounds
-	};
-}
-function circularLerp(a, b, t) {
-	let diff = b - a;
-	if (diff > 180) diff -= 360;
-	else if (diff < -180) diff += 360;
-	return ((a + diff * t) % 360 + 360) % 360;
-}
-/**
-* Compute the canonical max-contrast reference t value for normalization.
-* Uses bg.l=1, fg.l=0, intensity=100 — the theoretical maximum.
-* This is a fixed constant per tuning configuration, ensuring uniform
-* scaling across all bg/fg pairs at low intensities.
-*/
-function computeRefT(tuning) {
-	const EPSILON = 1e-6;
-	let lShRef = clamp(tuning.lightnessFactor, tuning.lightnessBounds[0], tuning.lightnessBounds[1]);
-	lShRef = Math.max(Math.min(lShRef, 1 - tuning.minGapTarget), 0);
-	return 1 / Math.max(1 - lShRef, EPSILON);
-}
-function computeShadow(bg, fg, intensity, tuning) {
-	const EPSILON = 1e-6;
-	const clampedIntensity = clamp(intensity, 0, 100);
-	const contrastWeight = fg ? Math.abs(bg.l - fg.l) : 1;
-	const deltaL = clampedIntensity / 100 * contrastWeight;
-	const h = fg ? circularLerp(fg.h, bg.h, tuning.bgHueBlend) : bg.h;
-	const s = fg ? Math.min(fg.s * tuning.saturationFactor, tuning.maxSaturation) : 0;
-	let lSh = clamp(bg.l * tuning.lightnessFactor, tuning.lightnessBounds[0], tuning.lightnessBounds[1]);
-	lSh = Math.max(Math.min(lSh, bg.l - tuning.minGapTarget), 0);
-	const t = deltaL / Math.max(bg.l - lSh, EPSILON);
-	const tRef = computeRefT(tuning);
-	const norm = Math.tanh(tRef / tuning.alphaMax);
-	const alpha = Math.min(tuning.alphaMax * Math.tanh(t / tuning.alphaMax) / norm, tuning.alphaMax);
-	return {
-		h,
-		s,
-		l: lSh,
-		alpha
-	};
-}
-
 //#endregion
 //#region src/validation.ts
 /**
 * Color graph validation and topological sort.
 *
-* `validateColorDefs` rejects bad references (missing / shadow-referencing /
-* base/contrast/tone mismatches) and detects cycles before the
-* resolver runs. `topoSort` orders defs so each color is processed after
-* its base / bg / fg / target dependencies.
+* `validateColorDefs` rejects bad references (missing / shadow- or
+* glow-referencing / base/contrast/tone mismatches — a relative tone in either
+* entry of an HC pair needs a base) and bad per-color lighting tuning (a
+* `headroom` on a shadow; a glow `headroom` that is not a finite number ≥ 0,
+* with one above the maximum warned about — once every def has passed — and
+* clamped at resolve), and detects cycles before the resolver runs. `topoSort` orders defs so each color is
+* processed after its base / bg / fg / target dependencies.
 */
 /**
 * Does this color sit at an absolute tone — either authored, or carried by a
@@ -2166,6 +3170,16 @@ function hasAbsoluteTone(def) {
 	return isAbsoluteTone(def.tone);
 }
 /**
+* Does either entry of a `tone` measure from a base? `isAbsoluteTone` reads
+* only the normal entry — that is the root / dependent test — so the
+* high-contrast entry of a pair is checked on its own here: `[50, '+20']`
+* needs a base just as much as `'+20'` does.
+*/
+function hasRelativeTone(tone) {
+	if (tone === void 0) return false;
+	return !isAbsoluteTone(pairNormal(tone)) || !isAbsoluteTone(pairHC(tone));
+}
+/**
 * Reject a `contrast` pair whose two entries measure in different metrics.
 *
 * A WCAG ratio and an APCA Lc are different scales, so `[4.5, { apca: 75 }]`
@@ -2181,24 +3195,39 @@ function assertConsistentContrastMetric(name, contrast) {
 	if (normal === hc) return;
 	throw new Error(`glaze: color "${name}" has a "contrast" pair that switches metric (${normal} → ${hc}). A WCAG ratio and an APCA Lc are different scales; use one metric for both entries, e.g. { ${normal}: [normal, highContrast] }.`);
 }
+/**
+* `'shadow'` / `'glow'` when `ref` names a local translucent overlay — which
+* nothing may build on — else `undefined`.
+*/
+function overlayKindOf(defs, ref) {
+	const def = Object.hasOwn(defs, ref) ? defs[ref] : void 0;
+	return def !== void 0 && isLightingDef(def) ? def.type : void 0;
+}
 function validateColorDefs(defs, externalBases) {
 	const localNames = new Set(Object.keys(defs));
 	const allNames = new Set([...localNames, ...externalBases ? externalBases.keys() : []]);
+	const deferred = [];
 	for (const [name, def] of Object.entries(defs)) {
-		if (isShadowDef(def)) {
-			if (!allNames.has(def.bg)) throw new Error(`glaze: shadow "${name}" references non-existent bg "${def.bg}".`);
-			if (localNames.has(def.bg) && isShadowDef(defs[def.bg])) throw new Error(`glaze: shadow "${name}" bg "${def.bg}" references another shadow color.`);
-			if (def.fg !== void 0) {
-				if (!allNames.has(def.fg)) throw new Error(`glaze: shadow "${name}" references non-existent fg "${def.fg}".`);
-				if (localNames.has(def.fg) && isShadowDef(defs[def.fg])) throw new Error(`glaze: shadow "${name}" fg "${def.fg}" references another shadow color.`);
+		if (isLightingDef(def)) {
+			const kind = def.type;
+			for (const field of ["bg", "fg"]) {
+				const ref = def[field];
+				if (ref === void 0) continue;
+				if (!allNames.has(ref)) throw new Error(`glaze: ${kind} "${name}" references non-existent ${field} "${ref}".`);
+				const refKind = overlayKindOf(defs, ref);
+				if (refKind !== void 0) throw new Error(`glaze: ${kind} "${name}" ${field} "${ref}" references a ${refKind} color.`);
 			}
+			normalizeLightingTuning(kind, def.tuning, `${kind} "${name}" tuning`, deferred);
 			continue;
 		}
 		if (isMixDef(def)) {
 			if (!allNames.has(def.base)) throw new Error(`glaze: mix "${name}" references non-existent base "${def.base}".`);
 			if (!allNames.has(def.target)) throw new Error(`glaze: mix "${name}" references non-existent target "${def.target}".`);
-			if (localNames.has(def.base) && isShadowDef(defs[def.base])) throw new Error(`glaze: mix "${name}" base "${def.base}" references a shadow color.`);
-			if (localNames.has(def.target) && isShadowDef(defs[def.target])) throw new Error(`glaze: mix "${name}" target "${def.target}" references a shadow color.`);
+			for (const field of ["base", "target"]) {
+				const ref = def[field];
+				const refKind = overlayKindOf(defs, ref);
+				if (refKind !== void 0) throw new Error(`glaze: mix "${name}" ${field} "${ref}" references a ${refKind} color.`);
+			}
 			assertConsistentContrastMetric(name, def.contrast);
 			continue;
 		}
@@ -2210,9 +3239,10 @@ function validateColorDefs(defs, externalBases) {
 			throw new Error(`glaze: color "${name}" has an invalid "from" value. ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}
 		if (regDef.contrast !== void 0 && !regDef.base) throw new Error(`glaze: color "${name}" has "contrast" without "base".`);
-		if (regDef.tone !== void 0 && !isAbsoluteTone(regDef.tone) && !regDef.base) throw new Error(`glaze: color "${name}" has relative "tone" without "base".`);
+		if (hasRelativeTone(regDef.tone) && !regDef.base) throw new Error(`glaze: color "${name}" has relative "tone" without "base".`);
 		if (regDef.base && !allNames.has(regDef.base)) throw new Error(`glaze: color "${name}" references non-existent base "${regDef.base}".`);
-		if (regDef.base && localNames.has(regDef.base) && isShadowDef(defs[regDef.base])) throw new Error(`glaze: color "${name}" base "${regDef.base}" references a shadow color.`);
+		const baseKind = regDef.base && overlayKindOf(defs, regDef.base);
+		if (baseKind) throw new Error(`glaze: color "${name}" base "${regDef.base}" references a ${baseKind} color.`);
 		if (!hasAbsoluteTone(regDef) && regDef.base === void 0) throw new Error(`glaze: color "${name}" must have either absolute "tone" (root), "from" (a literal color), or "base" (dependent).`);
 		if (regDef.contrast !== void 0 && regDef.opacity !== void 0) console.warn(`glaze: color "${name}" has both "contrast" and "opacity". Opacity makes perceived tone unpredictable.`);
 	}
@@ -2224,7 +3254,7 @@ function validateColorDefs(defs, externalBases) {
 		if (visited.has(name)) return;
 		inStack.add(name);
 		const def = defs[name];
-		if (isShadowDef(def)) {
+		if (isLightingDef(def)) {
 			dfs(def.bg);
 			if (def.fg) dfs(def.fg);
 		} else if (isMixDef(def)) {
@@ -2238,6 +3268,7 @@ function validateColorDefs(defs, externalBases) {
 		visited.add(name);
 	}
 	for (const name of localNames) dfs(name);
+	flushWarnings(deferred);
 }
 function topoSort(defs) {
 	const result = [];
@@ -2247,76 +3278,20 @@ function topoSort(defs) {
 		visited.add(name);
 		const def = defs[name];
 		if (def === void 0) return;
-		if (isShadowDef(def)) {
+		if (isLightingDef(def)) {
 			visit(def.bg);
 			if (def.fg) visit(def.fg);
 		} else if (isMixDef(def)) {
 			visit(def.base);
 			visit(def.target);
 		} else {
-			const regDef = def;
-			if (regDef.base) visit(regDef.base);
-		}
-		result.push(name);
-	}
-	for (const name of Object.keys(defs)) visit(name);
-	return result;
-}
-
-//#endregion
-//#region src/warnings.ts
-/**
-* Contrast-warning dispatcher.
-*
-* Tokens memoize their resolution, but a long-lived process (e.g. a dev
-* server with HMR) can re-resolve the same theme many times. The cache
-* here dedupes warnings within a session with a soft cap to keep noise
-* bounded.
-*/
-const CONTRAST_WARN_CACHE_LIMIT = 256;
-const contrastWarnCache = /* @__PURE__ */ new Set();
-/**
-* Slack factor below the requested target before we emit a warning.
-* The contrast solver overshoots to absorb rounding noise, so an actual
-* value within ~2x that overshoot is effectively a pass.
-*/
-const CONTRAST_WARN_SLACK_WCAG = .98;
-/** APCA Lc is on a 0–106 scale; allow a small absolute slack. */
-const CONTRAST_WARN_SLACK_APCA = 1.5;
-function schemeLabel(isDark, isHighContrast) {
-	if (isDark && isHighContrast) return "darkContrast";
-	if (isDark) return "dark";
-	if (isHighContrast) return "lightContrast";
-	return "light";
-}
-function metricLabel(c) {
-	return c.metric === "apca" ? `APCA Lc ${c.target.toFixed(1)}` : `WCAG ${c.target.toFixed(2)}`;
-}
-function dedupe(key) {
-	if (contrastWarnCache.has(key)) return true;
-	if (contrastWarnCache.size >= CONTRAST_WARN_CACHE_LIMIT) contrastWarnCache.clear();
-	contrastWarnCache.add(key);
-	return false;
-}
-/** Warn when the solver could not reach the requested contrast floor. */
-function warnContrastUnmet(name, isDark, isHighContrast, contrast, actual) {
-	if (actual >= (contrast.metric === "apca" ? contrast.target - CONTRAST_WARN_SLACK_APCA : contrast.target * CONTRAST_WARN_SLACK_WCAG)) return;
-	const scheme = schemeLabel(isDark, isHighContrast);
-	if (dedupe(`unmet|${name}|${scheme}|${contrast.metric}|${contrast.target.toFixed(2)}|${actual.toFixed(2)}`)) return;
-	console.warn(`glaze: color "${name}" cannot meet ${metricLabel(contrast)} in ${scheme} scheme (got ${actual.toFixed(2)}). Try widening the tone window, lowering the contrast target, or picking a base color further from this color's tone.`);
-}
-/**
-* Verification (§10): a chromatic swatch inherits the gray tone's
-* lightness but drifts in real luminance, so a contrast-floored color may
-* land slightly under the contrast its tone implies. Emit an advisory
-* warning when the actual measured contrast drifts below the target.
-*/
-function warnContrastDrift(name, isDark, isHighContrast, contrast, yColor, yBase) {
-	const actual = contrast.metric === "apca" ? Math.abs(contrast.polarity === "bg" ? apcaContrast(yBase, yColor) : apcaContrast(yColor, yBase)) : contrastRatioFromLuminance(yColor, yBase);
-	if (actual >= (contrast.metric === "apca" ? contrast.target - CONTRAST_WARN_SLACK_APCA : contrast.target * CONTRAST_WARN_SLACK_WCAG)) return;
-	const scheme = schemeLabel(isDark, isHighContrast);
-	if (dedupe(`drift|${name}|${scheme}|${contrast.metric}|${contrast.target.toFixed(2)}|${actual.toFixed(2)}`)) return;
-	console.warn(`glaze: color "${name}" drifts below ${metricLabel(contrast)} in ${scheme} scheme (measured ${actual.toFixed(2)}). Chromatic luminance differs from the gray tone; nudge the tone or saturation if the floor matters.`);
+			const regDef = def;
+			if (regDef.base) visit(regDef.base);
+		}
+		result.push(name);
+	}
+	for (const name of Object.keys(defs)) visit(name);
+	return result;
 }
 
 //#endregion
@@ -2331,13 +3306,34 @@ function warnContrastDrift(name, isDark, isHighContrast, contrast, yColor, yBase
 * passes bypass the level entirely, so the high-contrast slots are the same
 * values `'auto'` resolves. At level 100 the normal passes already are the
 * high-contrast ones, so the solver drops to two passes (light → dark) and
-* mirrors the slots. Owns the per-scheme resolve helpers for regular, shadow,
-* and mix color defs.
+* mirrors the slots. Owns the per-scheme resolve helpers for regular, shadow /
+* glow, and mix color defs.
+*
+* In dark, an `auto` tone delta (`'+N'` / `'-N'`) steps from where its base
+* sits on the authored scale in that pass (`darkAnchor`, memoized per pass):
+* the authored tone for a base placed by a tone or a chain of deltas, or — for
+* a base whose dark tone is solved, mixed, or replayed (an `auto` extreme) —
+* its own dark tone taken back through the dark window. So a dark delta lands
+* where the same authored tone would, on every base that inverts in dark: the
+* dark window's scale times the delta at the reference dark eps (exact in high
+* contrast), along the dark window's own curve under a custom one. A `fixed` /
+* `static` base keeps its light-side position, so the inversion follows the
+* dependent's own mode. The flip is still decided on the base's light tone, so
+* dark mirrors the side light took, and a step that runs off the authored
+* scale from its anchor (past 0 or 100) stops at the dark window's edge — at
+* either end, for a base anchored at its own dark tone. A base a contrast floor
+* or an extreme pushed past the window is stepped from where it sits, and a
+* step pointing further out stops at the base (`stepFromAnchor`). External
+* `glaze.color()` bases supply their own anchor (`darkAnchorOf`).
 *
 * Variants are stored in OKHST: `h` / `s` are OKHSL hue/saturation and
 * `t` is the canonical contrast-uniform tone (0–1, reference eps). The
 * resolver works in tone for regular colors and converts to/from OKHSL
-* lightness only at the mix/shadow and luminance edges.
+* lightness only at the mix / shadow / glow and luminance edges. A glow whose
+* step crosses white with `headroom` above 0 also carries `hdr` — its opaque
+* base in OKHST plus an exposure in stops — and swaps the SDR shortfall
+* warning for one that fires only when the headroom cap falls short. HDR
+* values never feed another color: nothing may build on a glow.
 *
 * Every function receives a single `GlazeConfigResolved` so the full
 * per-instance config (including overrides) is available without
@@ -2396,7 +3392,7 @@ function resolveRoleInMap(name, def, defs, inferRole, roles) {
 	const cached = roles.get(name);
 	if (cached) return cached;
 	let role;
-	if (isShadowDef(def)) role = "surface";
+	if (isLightingDef(def)) role = "surface";
 	else if (isMixDef(def)) role = normalizeRole(def.role) ?? (inferRole ? inferRoleFromName(name) : void 0) ?? resolveBaseRoleInMap(def.base, defs, inferRole, roles) ?? "text";
 	else {
 		const regDef = def;
@@ -2414,7 +3410,7 @@ function resolveRoleInMap(name, def, defs, inferRole, roles) {
 *   4. `'text'` (foreground) default
 *
 * Memoized on `ctx.roles` so the four scheme passes share one resolution.
-* Shadows have no contrast participation and default to `'surface'`.
+* Shadows and glows have no contrast participation and default to `'surface'`.
 */
 function resolveRole(name, def, ctx) {
 	return resolveRoleInMap(name, def, ctx.defs, ctx.config.inferRole, ctx.roles);
@@ -2433,7 +3429,7 @@ function passTone(tone, isHighContrast, config) {
 	const f = contrastFraction(config);
 	return f === void 0 || isHighContrast ? parseToneValue(isHighContrast ? pairHC(tone) : pairNormal(tone)) : parseToneValueAt(tone, f);
 }
-/** The authored numeric pair for this pass (shadow `intensity`, mix `value`). */
+/** The authored numeric pair for this pass (shadow / glow `intensity`, mix `value`). */
 function passNumber(p, isHighContrast, config) {
 	const f = contrastFraction(config);
 	if (f === void 0 || isHighContrast) return isHighContrast ? pairHC(p) : pairNormal(p);
@@ -2544,6 +3540,154 @@ function resolveChannels(def, ctx, isDark) {
 		saturation: clamp(explicitDark ? raw : mapSaturationDark(raw, mode, ctx.config), 0, 1)
 	};
 }
+/**
+* Whether a light-side anchor reads the stored light tone in this pass: high
+* contrast or a level at 100 at the reference light eps, where the light window
+* bypasses to the full range and is the identity. Those passes have always
+* stepped dark deltas from the light tone, so reading it as stored keeps them
+* bit-identical (recomputing the authored tone differs by float noise, which
+* can flip a tie-broken contrast solve). A normal pass has always read the
+* authored tone as is, so it keeps doing so even where its window is the
+* identity too (`lightTone: false` / `[0, 100]`). Read off the theme's config,
+* not a color's: a `from` color drops its own light window.
+*/
+function readsStoredLightTone(isHighContrast, config) {
+	if (normalizeToneWindow(config.lightTone).eps !== REF_EPS) return false;
+	return isHighContrast || hcMirrorsNormal(config);
+}
+/**
+* Where a step of `delta` from `anchor` lands on the authored scale: clamped to
+* `0–100`, widened to reach an anchor past the dark window (a base a contrast
+* floor or an extreme's replay pushed there). A step back toward the scale then
+* moves by the full delta, and one that points further out stops at the anchor
+* — the base itself — instead of snapping back to the window's edge. Either
+* way a step stops at the window's edge or at its base, whichever is further
+* out, so the result moves continuously as the base crosses the edge.
+*/
+function stepFromAnchor(anchor, delta) {
+	return clamp(anchor + delta, Math.min(0, anchor), Math.max(100, anchor));
+}
+/**
+* Where a color sits on the authored `0–100` tone scale in one pass: the tone
+* its own dark variant is the inversion of. In dark, an `auto` tone delta steps
+* from its base's anchor, so the dark step is the dark window's scale times the
+* delta on every base that inverts in dark.
+*
+* - A color placed by a tone (a root, an absolute tone, a `from` value, an
+*   extreme with no base or in `fixed` / `static` mode) returns that tone as
+*   authored for the pass.
+* - A tone delta returns its base's anchor plus the delta (`stepFromAnchor`),
+*   flipped exactly as the light pass flipped it on the base's light tone, so a
+*   chain of deltas steps evenly. A color with no tone of its own returns its
+*   base's.
+* - A color whose dark tone is not the inversion of an authored tone — an
+*   `auto` contrast-solved color, an `auto` extreme on a base (which replays its
+*   light shift), a mix — returns its own dark tone taken back through the dark
+*   window (`unmapDarkTone`). That falls outside `0–100` when a solve pushed the
+*   color past the window; a step from it stays off the scale until it comes
+*   back (`stepFromAnchor`, `mapDarkToneUnclamped`), so it does not snap to the
+*   window's edge.
+* - A `fixed` / `static` contrast-solved color does not invert, so it keeps its
+*   light-side answer: its light tone taken back through the light window. A
+*   delta on it (or on any `fixed` / `static` tone) inverts per its own mode.
+* - An external base (a `glaze.color()` link) supplies its own anchor, read in
+*   its own resolve context (`ctx.externalAnchors`), when the anchor means the
+*   same thing here: the base is `fixed` / `static`, or its active dark window
+*   is this pass's. An `auto` base under another dark window — or one with no
+*   hook — is read back through this pass's dark window, so a `'+0'` lands on
+*   it and the step is this window's scale times the delta. Any other base
+*   without a hook keeps its light tone.
+*
+* In high contrast and at `contrastLevel: 100` at the reference light eps
+* (`readsStoredLightTone`), a light-side color's light tone *is* its authored
+* tone, so it is read as stored. That keeps those passes bit-identical to the
+* light-tone anchor they have always used, as a normal pass stays on the
+* authored tone it has always used.
+*
+* Memoized per resolve and pass on `ctx.anchors`, so a long chain of deltas
+* resolves in linear time without deep recursion: the dark passes run in topo
+* order, so a base's anchor is cached before its dependents ask for it.
+*/
+function darkAnchor(name, ctx, isHighContrast) {
+	const memo = ctx.anchors[isHighContrast ? 1 : 0];
+	const cached = memo.get(name);
+	if (cached) return cached;
+	const color = ctx.resolved.get(name);
+	const lightTone = getSchemeVariant(color, false, isHighContrast).t * 100;
+	const fromDark = (config) => ({
+		tone: unmapDarkTone(getSchemeVariant(color, true, isHighContrast).t * 100, "auto", isHighContrast, config),
+		lightSide: false
+	});
+	let anchor;
+	const def = ctx.defs[name];
+	if (def === void 0) {
+		const external = ctx.externalAnchors?.get(name)?.(isHighContrast);
+		if (color.mode === "auto" && (external === void 0 || !sameDarkWindow(isHighContrast, external.config, ctx.config))) anchor = fromDark(ctx.config);
+		else anchor = {
+			tone: external?.tone ?? lightTone,
+			lightSide: false
+		};
+	} else if (isMixDef(def) || isLightingDef(def)) anchor = fromDark(ctx.config);
+	else {
+		const regDef = def;
+		const mode = regDef.mode ?? "auto";
+		const config = configForColor(regDef, ctx.config);
+		const rawTone = regDef.tone ?? fromSeed(regDef)?.tone;
+		const parsed = rawTone === void 0 ? void 0 : passTone(rawTone, isHighContrast, config);
+		if (regDef.contrast !== void 0) anchor = mode === "auto" ? fromDark(config) : {
+			tone: unmapLightTone(lightTone, mode, isHighContrast, config),
+			lightSide: true
+		};
+		else if (parsed === void 0) anchor = darkAnchor(regDef.base, ctx, isHighContrast);
+		else if (parsed.kind === "relative") {
+			const base = darkAnchor(regDef.base, ctx, isHighContrast);
+			const baseLightTone = getSchemeVariant(ctx.resolved.get(regDef.base), false, isHighContrast).t * 100;
+			const flip = regDef.autoFlip ?? ctx.config.autoFlip;
+			anchor = {
+				tone: stepFromAnchor(base.tone, applyToneFlip(parsed.value, baseLightTone, flip)),
+				lightSide: base.lightSide
+			};
+		} else if (parsed.kind === "extreme" && regDef.base !== void 0 && mode === "auto") anchor = fromDark(config);
+		else anchor = {
+			tone: clamp(parsed.value, 0, 100),
+			lightSide: true
+		};
+	}
+	if (anchor.lightSide && readsStoredLightTone(isHighContrast, ctx.config)) anchor = {
+		tone: lightTone,
+		lightSide: true
+	};
+	memo.set(name, anchor);
+	return anchor;
+}
+/**
+* A resolved color's dark-delta anchor for one pass (see `darkAnchor`), read
+* after its resolve. This is what a `glaze.color()` token hands the resolver
+* (with its config, and cached per pass) when another token links to it as a
+* `base`, so the link steps from where the base sits under the base's own
+* windows and defs. Internal, not public API.
+*/
+function darkAnchorOf(name, isHighContrast, source) {
+	const resolved = new Map(source.externalBases);
+	for (const [key, color] of source.resolved) resolved.set(key, color);
+	return darkAnchor(name, {
+		defs: source.defs,
+		config: source.config,
+		resolved,
+		anchors: [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()],
+		externalAnchors: source.externalAnchors
+	}, isHighContrast).tone;
+}
+/**
+* Which side of its base a tone sits on (both 0–100), or `undefined` when they
+* coincide. A gap within float noise counts as coinciding: a `'+0'` on a base
+* whose dark tone was read back through the dark window lands a few ulps off
+* it, and a strict comparison would let that noise pick the color's side.
+*/
+function sideOfBase(tone, baseTone) {
+	if (Math.abs(tone - baseTone) < 1e-9) return void 0;
+	return tone < baseTone ? "darker" : "lighter";
+}
 function resolveDependentColor(name, def, ctx, isHighContrast, isDark, channels, polarity, effectivePastel) {
 	const baseName = def.base;
 	const baseResolved = ctx.resolved.get(baseName);
@@ -2563,7 +3707,9 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, channels,
 		const parsed = passTone(rawTone, isHighContrast, config);
 		if (parsed.kind === "relative") if (isDark && mode === "auto") {
 			const baseLightTone = getSchemeVariant(baseResolved, false, isHighContrast).t * 100;
-			preferredTone = mapToneForScheme(clamp(baseLightTone + applyToneFlip(parsed.value, baseLightTone, flip), 0, 100), "auto", true, isHighContrast, config);
+			const delta = applyToneFlip(parsed.value, baseLightTone, flip);
+			const anchor = darkAnchor(baseName, ctx, isHighContrast).tone;
+			preferredTone = mapDarkToneUnclamped(stepFromAnchor(anchor, delta), isHighContrast, config);
 		} else preferredTone = clamp(baseTone + applyToneFlip(parsed.value, baseTone, flip), 0, 100);
 		else {
 			isExtreme = parsed.kind === "extreme";
@@ -2577,9 +3723,7 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, channels,
 		const baseOkhsl = toOkhslVariant(baseVariant);
 		const baseLinearRgb = okhslToLinearSrgb(baseOkhsl.h, baseOkhsl.s, baseOkhsl.l, baseVariant.pastel ?? ctx.config.pastel);
 		const preferredRange = isExtreme ? [0, 1] : schemeToneRange(isDark, mode, isHighContrast, config);
-		let initialDirection;
-		if (preferredTone < baseTone) initialDirection = "darker";
-		else if (preferredTone > baseTone) initialDirection = "lighter";
+		let initialDirection = sideOfBase(preferredTone, baseTone);
 		const solve = {
 			hue: channels.hue,
 			saturation: channels.saturation,
@@ -2592,11 +3736,11 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, channels,
 		const level = isHighContrast ? void 0 : contrastFraction(config);
 		let preferInitial = false;
 		if (level !== void 0 && level > 0 && level < 1) {
-			initialDirection = findToneForContrast({
+			initialDirection = sideOfBase(findToneForContrast({
 				...solve,
 				contrast: resolveContrastForLevel(rawContrast, level < PAIR_SWITCH ? 0 : 100, polarity),
 				initialDirection
-			}).tone * 100 < baseTone ? "darker" : "lighter";
+			}).tone * 100, baseTone) ?? initialDirection;
 			preferInitial = true;
 		}
 		const result = findToneForContrast({
@@ -2605,13 +3749,16 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, channels,
 			initialDirection,
 			preferInitial
 		});
-		if (!result.met) warnContrastUnmet(name, isDark, isHighContrast, resolvedContrast, result.contrast);
+		if (!result.met) {
+			ctx.unmet.add(unmetKey(name, isDark, isHighContrast));
+			warnContrastUnmet(name, isDark, isHighContrast, resolvedContrast, result.contrast);
+		}
 		return result.tone * 100;
 	}
 	return clamp(preferredTone, 0, 100);
 }
 function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
-	if (isShadowDef(def)) return resolveShadowForScheme(def, ctx, isDark, isHighContrast);
+	if (isLightingDef(def)) return resolveLightingForScheme(name, def, ctx, isDark, isHighContrast);
 	if (isMixDef(def)) return resolveMixForScheme(name, def, ctx, isDark, isHighContrast);
 	const regDef = def;
 	const mode = regDef.mode ?? "auto";
@@ -2629,16 +3776,38 @@ function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
 		pastel
 	};
 }
-function resolveShadowForScheme(def, ctx, isDark, isHighContrast) {
+/**
+* Shadow / glow: solve the pigment opacity that lands this scheme's `bg`
+* exactly `intensity × k` tones darker / lighter. `bg` and `fg` are read per
+* scheme, so the object factor `k` adapts on its own in dark and high contrast.
+* A glow past white with `headroom` gets `hdr` (base in OKHST + exposure); the
+* same headroom applies in every scheme, high contrast included.
+*/
+function resolveLightingForScheme(name, def, ctx, isDark, isHighContrast) {
 	const bgVariant = toOkhslVariant(getSchemeVariant(ctx.resolved.get(def.bg), isDark, isHighContrast));
-	let fgVariant;
-	if (def.fg) fgVariant = toOkhslVariant(getSchemeVariant(ctx.resolved.get(def.fg), isDark, isHighContrast));
+	const fgVariant = def.fg ? toOkhslVariant(getSchemeVariant(ctx.resolved.get(def.fg), isDark, isHighContrast)) : void 0;
 	const intensity = passNumber(def.intensity, isHighContrast, ctx.config);
-	const tuning = resolveShadowTuning(def.tuning, ctx.config.shadowTuning);
-	return {
-		...toToneVariant(computeShadow(bgVariant, fgVariant, intensity, tuning)),
-		pastel: def.pastel ?? ctx.config.pastel
+	const tuning = resolveLightingTuning(def.tuning, def.type === "shadow" ? ctx.config.shadowTuning : ctx.config.glowTuning);
+	const pastel = def.pastel ?? ctx.config.pastel;
+	const result = computeLighting(def.type, {
+		...bgVariant,
+		pastel: bgVariant.pastel ?? ctx.config.pastel
+	}, fgVariant, intensity, tuning, pastel);
+	warnLightingShortfall(def.type, name, {
+		isDark,
+		isHighContrast
+	}, result, tuning.headroom);
+	const variant = {
+		...toToneVariant({
+			h: result.h,
+			s: result.s,
+			l: result.l,
+			alpha: result.alpha
+		}),
+		pastel
 	};
+	if (result.hdr) variant.hdr = toResolvedHdr(result.hdr);
+	return variant;
 }
 function okhslVariantToLinearRgb(v, pastel) {
 	return okhslToLinearSrgb(v.h, v.s, v.l, pastel);
@@ -2693,18 +3862,23 @@ function resolveMixForScheme(name, def, ctx, isDark, isHighContrast) {
 		const resolvedContrast = resolveContrastSpec(def.contrast, isHighContrast, ctx.config, polarity);
 		const metric = resolvedContrast.metric;
 		let luminanceAt;
-		if (blend === "transparent" || space === "srgb") luminanceAt = (v) => metricLuminance(metric, linearSrgbLerp(baseLinear, targetLinear, v));
+		if (blend === "transparent") {
+			const baseGamma = toDisplayGamma(baseLinear);
+			const targetGamma = toDisplayGamma(targetLinear);
+			luminanceAt = (v) => metricLuminance(metric, compositeOverGamma(baseGamma, targetGamma, v));
+		} else if (space === "srgb") luminanceAt = (v) => metricLuminance(metric, linearSrgbLerp(baseLinear, targetLinear, v));
 		else luminanceAt = (v) => {
 			return metricLuminance(metric, okhslToLinearSrgb(mixHue(baseVariant, targetVariant, v), baseVariant.s + (targetVariant.s - baseVariant.s) * v, baseVariant.l + (targetVariant.l - baseVariant.l) * v, pastel));
 		};
-		t = findValueForMixContrast({
+		const result = findValueForMixContrast({
 			preferredValue: t,
 			baseLinearRgb: baseLinear,
-			targetLinearRgb: targetLinear,
 			contrast: resolvedContrast,
 			luminanceAtValue: luminanceAt,
 			flip: ctx.config.autoFlip
-		}).value;
+		});
+		t = result.value;
+		if (!result.met) warnMixContrastUnmet(name, isDark, isHighContrast, resolvedContrast, result.contrast);
 	}
 	if (blend === "transparent") return {
 		...toToneVariant({
@@ -2730,7 +3904,7 @@ function resolveMixForScheme(name, def, ctx, isDark, isHighContrast) {
 	};
 }
 function defMode(def) {
-	if (isShadowDef(def) || isMixDef(def)) return void 0;
+	if (isLightingDef(def) || isMixDef(def)) return void 0;
 	return def.mode ?? "auto";
 }
 /**
@@ -2770,264 +3944,123 @@ function seedField(order, ctx, field, source) {
 		ctx.resolved.set(name, {
 			...existing,
 			[field]: source.get(name)
-		});
-	}
-}
-/**
-* After the passes, surface chromatic contrast drift (§10): a color
-* resolved with a `base` + `contrast` may land slightly under the contrast
-* its tone implies because chromatic luminance drifts from the gray tone.
-*
-* Under a manual `contrastLevel` the spec is resolved at the level, so the check
-* measures each normal variant against the target it was actually solved for. At
-* level 100 the high-contrast slots are mirrors and are skipped: the normal
-* schemes already carry that check, and repeating it would emit a byte-identical
-* advisory under a different scheme label, which dedupes as a separate key.
-*/
-function verifyContrastDrift(order, defs, result, config) {
-	const roles = /* @__PURE__ */ new Map();
-	for (const name of order) {
-		const def = defs[name];
-		if (isShadowDef(def) || isMixDef(def)) continue;
-		const regDef = def;
-		if (regDef.contrast === void 0 || !regDef.base) continue;
-		const color = result.get(name);
-		const base = result.get(regDef.base);
-		if (!color || !base) continue;
-		const polarity = roleToPolarity(resolveRoleInMap(name, def, defs, config.inferRole, roles));
-		const schemes = [
-			{
-				isDark: false,
-				isHighContrast: false,
-				field: "light"
-			},
-			{
-				isDark: false,
-				isHighContrast: true,
-				field: "lightContrast"
-			},
-			{
-				isDark: true,
-				isHighContrast: false,
-				field: "dark"
-			},
-			{
-				isDark: true,
-				isHighContrast: true,
-				field: "darkContrast"
-			}
-		];
-		const mirrored = hcMirrorsNormal(config);
-		for (const s of schemes) {
-			if (mirrored && s.isHighContrast) continue;
-			const spec = resolveContrastSpec(regDef.contrast, s.isHighContrast, config, polarity);
-			const cVariant = color[s.field];
-			const bVariant = base[s.field];
-			const cOkhsl = toOkhslVariant(cVariant);
-			const bOkhsl = toOkhslVariant(bVariant);
-			const cPastel = cVariant.pastel ?? config.pastel;
-			const bPastel = bVariant.pastel ?? config.pastel;
-			const yC = metricLuminance(spec.metric, okhslToLinearSrgb(cOkhsl.h, cOkhsl.s, cOkhsl.l, cPastel));
-			const yB = metricLuminance(spec.metric, okhslToLinearSrgb(bOkhsl.h, bOkhsl.s, bOkhsl.l, bPastel));
-			warnContrastDrift(name, s.isDark, s.isHighContrast, spec, yC, yB);
-		}
-	}
-}
-function resolveAllColors(seed, defs, config, externalBases) {
-	validateColorDefs(defs, externalBases);
-	const order = topoSort(defs);
-	const ctx = {
-		...seed,
-		defs,
-		resolved: /* @__PURE__ */ new Map(),
-		config,
-		roles: /* @__PURE__ */ new Map()
-	};
-	if (externalBases) for (const [name, color] of externalBases) ctx.resolved.set(name, color);
-	const mirrored = hcMirrorsNormal(config);
-	const lightMap = runPass(order, defs, ctx, false, false, "light");
-	let lightHCMap = lightMap;
-	if (!mirrored) {
-		seedField(order, ctx, "lightContrast", lightMap);
-		lightHCMap = runPass(order, defs, ctx, false, true, "lightContrast");
-	}
-	seedField(order, ctx, "dark", lightMap);
-	seedField(order, ctx, "darkContrast", lightHCMap);
-	const darkMap = runPass(order, defs, ctx, true, false, "dark");
-	let darkHCMap = darkMap;
-	if (!mirrored) {
-		seedField(order, ctx, "darkContrast", darkMap);
-		darkHCMap = runPass(order, defs, ctx, true, true, "darkContrast");
-	}
-	const result = /* @__PURE__ */ new Map();
-	for (const name of order) result.set(name, {
-		name,
-		light: lightMap.get(name),
-		dark: darkMap.get(name),
-		lightContrast: lightHCMap.get(name),
-		darkContrast: darkHCMap.get(name),
-		mode: defMode(defs[name])
-	});
-	verifyContrastDrift(order, defs, result, config);
-	return result;
-}
-
-//#endregion
-//#region src/channels.ts
-/**
-* Hue channel planning for `splitHue` exports.
-*
-* Builds per-color hue var references and the `--*-hue` declarations backing
-* them for oklch CSS / Tasty output when every color is pastel.
-*
-* Hue is scheme-independent unless the theme or a color authors a dark hue,
-* so declarations are collected per scheme (`'light'` / `'dark'`) and the dark
-* set is emitted only when it actually differs — see `buildHueDeclarations`.
-* A color that authors a hue in *either* scheme gets its own var in both, so
-* the shared `var()` reference stays valid.
-*/
-const ACHROMATIC_EPSILON = 1e-6;
-function cssProp(prefix, name, suffix) {
-	return `--${prefix}${name}${suffix}`;
-}
-function isAchromatic(v) {
-	return v.s <= ACHROMATIC_EPSILON;
-}
-/** Seed hue backing `--{baseName}-hue` in a given scheme. */
-function schemeSeedHue(ctx, scheme) {
-	return scheme === "dark" ? ctx.darkSeedHue ?? ctx.seedHue : ctx.seedHue;
-}
-function themeHuePlan(name, def, variant, ctx, scheme) {
-	if (def === void 0 || isShadowDef(def) || isMixDef(def) || isAchromatic(variant)) return {
-		hueVar: "",
-		inline: true,
-		declarations: []
-	};
-	const regDef = def;
-	const baseHueVar = `var(--${ctx.baseName}-hue)`;
-	const prop = cssProp(ctx.prefix, name, "-hue");
-	if ((regDef.mode ?? "auto") === "static" && schemeSeedHue(ctx, "dark") !== ctx.seedHue) return {
-		hueVar: `var(${prop})`,
-		inline: false,
-		declarations: [{
-			prop,
-			value: String(variant.h)
-		}]
-	};
-	if (regDef.hue === void 0 && regDef.darkHue === void 0 && regDef.from === void 0) return {
-		hueVar: baseHueVar,
-		inline: false,
-		declarations: []
-	};
-	const authored = scheme === "dark" ? regDef.darkHue ?? regDef.hue : regDef.hue;
-	if (authored === void 0) {
-		if (regDef.from !== void 0) return {
-			hueVar: `var(${prop})`,
-			inline: false,
-			declarations: [{
-				prop,
-				value: String(variant.h)
-			}]
-		};
-		return {
-			hueVar: `var(${prop})`,
-			inline: false,
-			declarations: [{
-				prop,
-				value: baseHueVar
-			}]
-		};
-	}
-	const parsed = parseRelativeOrAbsolute(authored);
-	if (parsed.relative) {
-		const sign = parsed.value >= 0 ? "+" : "-";
-		const magnitude = Math.abs(parsed.value);
-		const value = `calc(var(--${ctx.baseName}-hue) ${sign} ${magnitude})`;
-		return {
-			hueVar: `var(${prop})`,
-			inline: false,
-			declarations: [{
-				prop,
-				value
-			}]
-		};
-	}
-	const absHue = (parsed.value % 360 + 360) % 360;
-	return {
-		hueVar: `var(${prop})`,
-		inline: false,
-		declarations: [{
-			prop,
-			value: String(absHue)
-		}]
-	};
-}
-function standaloneHuePlan(name, variant, ctx, scheme) {
-	if (isAchromatic(variant)) return {
-		hueVar: "",
-		inline: true,
-		declarations: []
-	};
-	const hue = scheme === "dark" ? variant.h : ctx.resolvedHue ?? variant.h;
-	const prop = cssProp(ctx.prefix, name, "-hue");
-	return {
-		hueVar: `var(${prop})`,
-		inline: false,
-		declarations: [{
-			prop,
-			value: String(hue)
-		}]
-	};
-}
-function buildHuePlan(name, def, variant, ctx, scheme = "light") {
-	if (ctx.mode === "standalone") return standaloneHuePlan(name, variant, ctx, scheme);
-	return themeHuePlan(name, def, variant, ctx, scheme);
-}
-/** Collect unique hue declarations across all colors (theme + per-color). */
-function collectHueDeclarations(resolved, ctx, scheme) {
-	if (ctx.emitDeclarations === false) return [];
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	const push = (decl) => {
-		if (seen.has(decl.prop)) return;
-		seen.add(decl.prop);
-		out.push(decl);
-	};
-	if (ctx.mode === "theme") push({
-		prop: `--${ctx.baseName}-hue`,
-		value: String(schemeSeedHue(ctx, scheme))
-	});
-	for (const [name, color] of resolved) {
-		const def = ctx.defs[name];
-		const plan = buildHuePlan(name, def, scheme === "dark" ? color.dark : color.light, ctx, scheme);
-		for (const decl of plan.declarations) push(decl);
+		});
 	}
-	return out;
 }
+/** Key for `ResolveContext.unmet`: one color in one scheme. */
+function unmetKey(name, isDark, isHighContrast) {
+	return `${name}|${isDark ? "dark" : "light"}|${isHighContrast ? "hc" : ""}`;
+}
+/** Below this OKHSL saturation a variant is a gray: its tone is exact. */
+const ACHROMATIC_EPSILON = 1e-6;
 /**
-* Hue declarations for both schemes. `dark` is empty when it resolves to the
-* same hues as light — the common case, with no `darkHue` anywhere.
+* After the passes, surface chromatic contrast drift (the drift check in
+* docs/okhst.mdx): a color resolved with a `base` + `contrast` may land
+* slightly under the contrast its tone implies because chromatic luminance
+* drifts from the gray tone.
 *
-* When they differ, the **whole** dark set is returned rather than only the
-* entries whose text changed. A relative declaration reads
-* `calc(var(--theme-hue) + N)` in both schemes even though its resolved value
-* moves with the seed, and custom properties substitute `var()` at
-* computed-value time on the declaring element — so re-declaring
-* `--{baseName}-hue` alone would leave inherited per-color vars still holding
-* the light-substituted value.
+* Two kinds of variant are skipped. One the solver reported as unmet (`unmet`)
+* already got a "cannot meet" warning with the same measured value, and the
+* shortfall is an unreachable floor, not drift. An achromatic one (saturation
+* 0) has no chromatic luminance to drift, so the advisory's cause can't apply.
+*
+* Under a manual `contrastLevel` the spec is resolved at the level, so the check
+* measures each normal variant against the target it was actually solved for. At
+* level 100 the high-contrast slots are mirrors and are skipped: the normal
+* schemes already carry that check, and repeating it would emit a byte-identical
+* advisory under a different scheme label, which dedupes as a separate key.
 */
-function buildHueDeclarations(resolved, ctx) {
-	const light = collectHueDeclarations(resolved, ctx, "light");
-	const dark = collectHueDeclarations(resolved, ctx, "dark");
-	return {
-		light,
-		dark: dark.length === light.length && dark.every((decl, i) => decl.prop === light[i].prop && decl.value === light[i].value) ? [] : dark
-	};
+function verifyContrastDrift(order, defs, result, config, unmet) {
+	const roles = /* @__PURE__ */ new Map();
+	for (const name of order) {
+		const def = defs[name];
+		if (isLightingDef(def) || isMixDef(def)) continue;
+		const regDef = def;
+		if (regDef.contrast === void 0 || !regDef.base) continue;
+		const color = result.get(name);
+		const base = result.get(regDef.base);
+		if (!color || !base) continue;
+		const polarity = roleToPolarity(resolveRoleInMap(name, def, defs, config.inferRole, roles));
+		const schemes = [
+			{
+				isDark: false,
+				isHighContrast: false,
+				field: "light"
+			},
+			{
+				isDark: false,
+				isHighContrast: true,
+				field: "lightContrast"
+			},
+			{
+				isDark: true,
+				isHighContrast: false,
+				field: "dark"
+			},
+			{
+				isDark: true,
+				isHighContrast: true,
+				field: "darkContrast"
+			}
+		];
+		const mirrored = hcMirrorsNormal(config);
+		for (const s of schemes) {
+			if (mirrored && s.isHighContrast) continue;
+			if (unmet.has(unmetKey(name, s.isDark, s.isHighContrast))) continue;
+			const cVariant = color[s.field];
+			if (cVariant.s <= ACHROMATIC_EPSILON) continue;
+			const spec = resolveContrastSpec(regDef.contrast, s.isHighContrast, config, polarity);
+			const bVariant = base[s.field];
+			const cOkhsl = toOkhslVariant(cVariant);
+			const bOkhsl = toOkhslVariant(bVariant);
+			const cPastel = cVariant.pastel ?? config.pastel;
+			const bPastel = bVariant.pastel ?? config.pastel;
+			const yC = metricLuminance(spec.metric, okhslToLinearSrgb(cOkhsl.h, cOkhsl.s, cOkhsl.l, cPastel));
+			const yB = metricLuminance(spec.metric, okhslToLinearSrgb(bOkhsl.h, bOkhsl.s, bOkhsl.l, bPastel));
+			warnContrastDrift(name, s.isDark, s.isHighContrast, spec, yC, yB);
+		}
+	}
 }
-function buildHuePlans(resolved, ctx) {
-	const plans = /* @__PURE__ */ new Map();
-	for (const [name, color] of resolved) plans.set(name, buildHuePlan(name, ctx.defs[name], color.light, ctx));
-	return plans;
+function resolveAllColors(seed, defs, config, externalBases, externalAnchors) {
+	validateColorDefs(defs, externalBases);
+	const order = topoSort(defs);
+	const ctx = {
+		...seed,
+		defs,
+		resolved: /* @__PURE__ */ new Map(),
+		config,
+		roles: /* @__PURE__ */ new Map(),
+		unmet: /* @__PURE__ */ new Set(),
+		anchors: [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()],
+		externalAnchors
+	};
+	if (externalBases) for (const [name, color] of externalBases) ctx.resolved.set(name, color);
+	const mirrored = hcMirrorsNormal(config);
+	const lightMap = runPass(order, defs, ctx, false, false, "light");
+	let lightHCMap = lightMap;
+	if (!mirrored) {
+		seedField(order, ctx, "lightContrast", lightMap);
+		lightHCMap = runPass(order, defs, ctx, false, true, "lightContrast");
+	}
+	seedField(order, ctx, "dark", lightMap);
+	seedField(order, ctx, "darkContrast", lightHCMap);
+	const darkMap = runPass(order, defs, ctx, true, false, "dark");
+	let darkHCMap = darkMap;
+	if (!mirrored) {
+		seedField(order, ctx, "darkContrast", darkMap);
+		darkHCMap = runPass(order, defs, ctx, true, true, "darkContrast");
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (const name of order) result.set(name, {
+		name,
+		light: lightMap.get(name),
+		dark: darkMap.get(name),
+		lightContrast: lightHCMap.get(name),
+		darkContrast: darkHCMap.get(name),
+		mode: defMode(defs[name])
+	});
+	verifyContrastDrift(order, defs, result, config, ctx.unmet);
+	return result;
 }
 
 //#endregion
@@ -3036,7 +4069,8 @@ function buildHuePlans(resolved, ctx) {
 * Output formatting for resolved color maps.
 *
 * Owns the CSS-string formatter dispatch table (`okhsl` / `rgb` / `hsl` /
-* `oklch`) and the token-map shapes Glaze emits:
+* `oklch`), the HDR glow writer (`formatHdrVariant`, `color(srgb-linear …)`),
+* and the token-map shapes Glaze emits:
 * - `buildTokenMap` — Tasty style-to-state bindings (`#name` keys, state aliases).
 * - `buildFlatTokenMap` — `{ light, dark, ... }` per-variant maps.
 * - `buildJsonMap` — `{ name: { light, dark, ... } }` per-color JSON.
@@ -3044,7 +4078,66 @@ function buildHuePlans(resolved, ctx) {
 * - `buildDtcgMap` — W3C DTCG (2025.10) token documents, one per scheme.
 * - `buildDtcgResolver` — W3C DTCG Resolver-Module document (one modifier, a context per scheme).
 * - `buildTailwindMap` — Tailwind v4 `@theme` block + dark/HC overrides.
+*
+* The HDR tier (`variant.hdr`, a glow past SDR white) is emitted only with
+* `modes.hdr` (`css()`: its `hdr` option), and always as a literal
+* `color(srgb-linear R G B)` — whatever `format`, even under `splitHue`.
+* Without it every shape is byte-identical to SDR. Each shape carries it the
+* way its consumer composes values:
+* - Tasty: a sparse `hdr` state key after each SDR key that has one (`''`,
+*   hdr, dark, dark & hdr, hc, hc & hdr, dark & hc, dark & hc & hdr). Tasty
+*   gives later keys priority, so a dark key still beats the light HDR one.
+* - `json()`: sparse `lightHdr` / `darkHdr` / … keys per color.
+* - `tokens()` / `css()` / Tailwind: dense per-scheme HDR blocks — every
+*   color with an HDR value in any (emitted) scheme, re-declared with its SDR
+*   value where a scheme has none — so a cascade layering one HDR block over
+*   the SDR ones can't leak a light HDR value into dark.
+* - DTCG: `$value` stays SDR; the HDR value rides in
+*   `$extensions['me.tenphi.glaze'].hdr` of the scheme documents that have it.
+*/
+/** The four scheme variants, in emission order. */
+const SCHEMES = [
+	"light",
+	"dark",
+	"lightContrast",
+	"darkContrast"
+];
+function hdrKey(scheme) {
+	return `${scheme}Hdr`;
+}
+/** The scheme variants `modes` emits, in order. Light always. */
+function emittedSchemes(modes) {
+	const schemes = ["light"];
+	if (modes.dark) schemes.push("dark");
+	if (modes.highContrast) schemes.push("lightContrast");
+	if (modes.dark && modes.highContrast) schemes.push("darkContrast");
+	return schemes;
+}
+/**
+* Whether a color belongs in the dense HDR blocks: it has an HDR value in at
+* least one of `schemes`.
 */
+function hasHdrIn(color, schemes) {
+	return schemes.some((scheme) => color[scheme].hdr !== void 0);
+}
+/** Join per-scheme declaration lines into `css()` blocks. */
+function joinSchemeLines(lines) {
+	return {
+		light: lines.light.join("\n"),
+		dark: lines.dark.join("\n"),
+		lightContrast: lines.lightContrast.join("\n"),
+		darkContrast: lines.darkContrast.join("\n")
+	};
+}
+/** Fresh, empty per-scheme declaration line buckets. */
+function emptySchemeLines() {
+	return {
+		light: [],
+		dark: [],
+		lightContrast: [],
+		darkContrast: []
+	};
+}
 const formatters = {
 	okhsl: formatOkhsl,
 	rgb: formatRgb,
@@ -3067,6 +4160,18 @@ function formatVariant(v, format = "oklch", pastel = false) {
 	return `${base.slice(0, closing)} / ${fmt(v.alpha, 4)})`;
 }
 /**
+* Format a variant's HDR value (`variant.hdr`, set on a glow past white with
+* `headroom`) as `color(srgb-linear R G B)`, or `undefined` when it has none.
+* Always that form, whatever the SDR format: OKLCH lightness clamps at parse
+* time and `rgb()` / `hsl()` cannot pass white. Emitted as a literal, never
+* with a split hue.
+*/
+function formatHdrVariant(v, format = "srgb-linear") {
+	if (format !== "srgb-linear") throw new Error(`glaze: unknown HDR format ${JSON.stringify(format)}. Use 'srgb-linear'.`);
+	if (v.hdr === void 0) return void 0;
+	return formatSrgbLinear(hdrToLinearSrgb(v.hdr));
+}
+/**
 * Format a resolved variant as `oklch(L C <hueVar>)`, splicing a CSS hue var
 * for `splitHue` exports. Falls back to inline when the plan is inline.
 */
@@ -3110,7 +4215,8 @@ function resolveModes(override) {
 	const highContrast = override?.highContrast ?? cfg.modes.highContrast;
 	return {
 		dark: override?.dark ?? cfg.modes.dark,
-		highContrast: highContrast && !hcMirrorsNormal(cfg)
+		highContrast: highContrast && !hcMirrorsNormal(cfg),
+		hdr: override?.hdr ?? cfg.modes.hdr
 	};
 }
 function buildTokenMap(resolved, prefix, states, modes, format = "oklch", pastel = false, channelCtx) {
@@ -3135,45 +4241,82 @@ function buildTokenMap(resolved, prefix, states, modes, format = "oklch", pastel
 	}
 	return tokens;
 }
+/**
+* One color's Tasty state map. With `modes.hdr`, each SDR key whose variant
+* has an HDR value is followed by its `hdr` key (`states.hdr` alone after
+* `''`, `<key> & <hdr>` after the others), so the order is `''`, hdr, dark,
+* dark & hdr, hc, hc & hdr, dark & hc, dark & hc & hdr — only the HDR keys
+* that exist. Tasty gives later keys priority, so in a dark HDR context the
+* dark key (or its own HDR key) still beats the light HDR one.
+*/
 function buildTokenEntry(color, states, modes, format, pastel, huePlan) {
-	const entry = { "": formatColorValue(color.light, format, pastel, huePlan) };
-	if (modes.dark) entry[states.dark] = formatColorValue(color.dark, format, pastel, huePlan);
-	if (modes.highContrast) entry[states.highContrast] = formatColorValue(color.lightContrast, format, pastel, huePlan);
-	if (modes.dark && modes.highContrast) entry[`${states.dark} & ${states.highContrast}`] = formatColorValue(color.darkContrast, format, pastel, huePlan);
+	const entry = {};
+	const add = (key, v) => {
+		entry[key] = formatColorValue(v, format, pastel, huePlan);
+		if (modes.hdr && v.hdr !== void 0) {
+			const hdrState = states.hdr ?? getConfig().states.hdr;
+			entry[key === "" ? hdrState : `${key} & ${hdrState}`] = formatHdrVariant(v);
+		}
+	};
+	add("", color.light);
+	if (modes.dark) add(states.dark, color.dark);
+	if (modes.highContrast) add(states.highContrast, color.lightContrast);
+	if (modes.dark && modes.highContrast) add(`${states.dark} & ${states.highContrast}`, color.darkContrast);
 	return entry;
 }
+/**
+* Per-scheme flat maps (`{ light, dark, … }`), gated by `modes`. With
+* `modes.hdr` each emitted scheme gains a dense `<scheme>Hdr` map right after
+* it (`light`, `lightHdr`, `dark`, `darkHdr`, …): every color with an HDR
+* value in any emitted scheme, its SDR value where that scheme has none.
+*/
 function buildFlatTokenMap(resolved, prefix, modes, format = "oklch", pastel = false) {
-	const result = { light: {} };
-	if (modes.dark) result.dark = {};
-	if (modes.highContrast) result.lightContrast = {};
-	if (modes.dark && modes.highContrast) result.darkContrast = {};
+	const schemes = emittedSchemes(modes);
+	const result = {};
+	for (const scheme of schemes) {
+		result[scheme] = {};
+		if (modes.hdr) result[hdrKey(scheme)] = {};
+	}
 	for (const [name, color] of resolved) {
 		const key = `${prefix}${name}`;
-		result.light[key] = formatVariant(color.light, format, pastel);
-		if (modes.dark) result.dark[key] = formatVariant(color.dark, format, pastel);
-		if (modes.highContrast) result.lightContrast[key] = formatVariant(color.lightContrast, format, pastel);
-		if (modes.dark && modes.highContrast) result.darkContrast[key] = formatVariant(color.darkContrast, format, pastel);
+		const dense = modes.hdr && hasHdrIn(color, schemes);
+		for (const scheme of schemes) {
+			const v = color[scheme];
+			const sdr = formatVariant(v, format, pastel);
+			result[scheme][key] = sdr;
+			if (dense) result[hdrKey(scheme)][key] = formatHdrVariant(v) ?? sdr;
+		}
 	}
 	return result;
 }
+/**
+* Per-color JSON (`{ name: { light, dark, … } }`), gated by `modes`. With
+* `modes.hdr`, a variant with an HDR value adds a sparse `<scheme>Hdr` key
+* right after its SDR one (`light`, `lightHdr`, `dark`, …).
+*/
 function buildJsonMap(resolved, modes, format = "oklch", pastel = false) {
+	const schemes = emittedSchemes(modes);
 	const result = {};
 	for (const [name, color] of resolved) {
-		const entry = { light: formatVariant(color.light, format, pastel) };
-		if (modes.dark) entry.dark = formatVariant(color.dark, format, pastel);
-		if (modes.highContrast) entry.lightContrast = formatVariant(color.lightContrast, format, pastel);
-		if (modes.dark && modes.highContrast) entry.darkContrast = formatVariant(color.darkContrast, format, pastel);
+		const entry = {};
+		for (const scheme of schemes) {
+			const v = color[scheme];
+			entry[scheme] = formatVariant(v, format, pastel);
+			if (modes.hdr && v.hdr !== void 0) entry[hdrKey(scheme)] = formatHdrVariant(v);
+		}
 		result[name] = entry;
 	}
 	return result;
 }
-function buildCssMap(resolved, prefix, suffix, format, pastel = false, channelCtx) {
-	const lines = {
-		light: [],
-		dark: [],
-		lightContrast: [],
-		darkContrast: []
-	};
+/**
+* CSS custom-property declarations for all four schemes. With `hdr`, the
+* result gains dense `hdr` blocks: every color with an HDR value in any
+* scheme, re-declared in each block with that scheme's HDR value, or its
+* exact SDR declaration where the scheme has none.
+*/
+function buildCssMap(resolved, prefix, suffix, format, pastel = false, channelCtx, hdr = false) {
+	const lines = emptySchemeLines();
+	const hdrLines = hdr ? emptySchemeLines() : void 0;
 	const huePlans = channelCtx !== void 0 && format === "oklch" ? buildHuePlans(resolved, channelCtx) : void 0;
 	if (huePlans !== void 0 && channelCtx !== void 0) {
 		const hueDecls = buildHueDeclarations(resolved, channelCtx);
@@ -3186,17 +4329,17 @@ function buildCssMap(resolved, prefix, suffix, format, pastel = false, channelCt
 	for (const [name, color] of resolved) {
 		const prop = `--${prefix}${name}${suffix}`;
 		const plan = huePlans?.get(name);
-		lines.light.push(`${prop}: ${formatColorValue(color.light, format, pastel, plan)};`);
-		lines.dark.push(`${prop}: ${formatColorValue(color.dark, format, pastel, plan)};`);
-		lines.lightContrast.push(`${prop}: ${formatColorValue(color.lightContrast, format, pastel, plan)};`);
-		lines.darkContrast.push(`${prop}: ${formatColorValue(color.darkContrast, format, pastel, plan)};`);
+		const dense = hdrLines !== void 0 && hasHdrIn(color, SCHEMES);
+		for (const scheme of SCHEMES) {
+			const v = color[scheme];
+			const decl = `${prop}: ${formatColorValue(v, format, pastel, plan)};`;
+			lines[scheme].push(decl);
+			if (dense) hdrLines[scheme].push(v.hdr !== void 0 ? `${prop}: ${formatHdrVariant(v)};` : decl);
+		}
 	}
-	return {
-		light: lines.light.join("\n"),
-		dark: lines.dark.join("\n"),
-		lightContrast: lines.lightContrast.join("\n"),
-		darkContrast: lines.darkContrast.join("\n")
-	};
+	const result = joinSchemeLines(lines);
+	if (hdrLines !== void 0) result.hdr = joinSchemeLines(hdrLines);
+	return result;
 }
 function roundTo(value, decimals) {
 	return parseFloat(value.toFixed(decimals));
@@ -3226,8 +4369,14 @@ function dtcgColorValue(v, colorSpace = "srgb", pastel = false) {
 		if (alpha !== void 0) value.alpha = alpha;
 		return value;
 	}
-	const [r, g, b] = okhslToSrgb(v.h, v.s, l, effectivePastel);
-	const value = {
+	const value = dtcgSrgbValue(v.h, v.s, l, effectivePastel);
+	if (alpha !== void 0) value.alpha = alpha;
+	return value;
+}
+/** A DTCG sRGB color value (gamma components, 6 decimals, plus `hex`). */
+function dtcgSrgbValue(h, s, l, pastel) {
+	const [r, g, b] = okhslToSrgb(h, s, l, pastel);
+	return {
 		colorSpace: "srgb",
 		components: [
 			roundTo(r, 6),
@@ -3240,30 +4389,60 @@ function dtcgColorValue(v, colorSpace = "srgb", pastel = false) {
 			b
 		])
 	};
-	if (alpha !== void 0) value.alpha = alpha;
-	return value;
 }
-function dtcgToken(v, colorSpace, pastel) {
+/** The `$extensions` namespace Glaze writes into DTCG tokens. */
+const DTCG_EXTENSION_NAMESPACE = "me.tenphi.glaze";
+/**
+* The DTCG form of an HDR value: `exposure` in stops, the luminance `tone`
+* it lands (past 100 unless `headroom` caps a saturated base short of it), the
+* opaque `base` as a DTCG sRGB color (always sRGB, whatever `colorSpace`, and
+* never pastel — the base is standard OKHSL), and the HDR color as linear sRGB
+* components, the brightest above 1.
+*/
+function dtcgHdrValue(hdr) {
+	const linear = hdrToLinearSrgb(hdr);
+	const { h, s, l } = okhstToOkhsl(hdr);
 	return {
+		exposure: roundTo(hdr.exposure, 6),
+		tone: roundTo(toneFromY(relativeLuminanceFromLinearRgb(linear)), 4),
+		base: dtcgSrgbValue(h, s, l, false),
+		value: {
+			colorSpace: "srgb-linear",
+			components: [
+				roundTo(linear[0], 6),
+				roundTo(linear[1], 6),
+				roundTo(linear[2], 6)
+			]
+		}
+	};
+}
+function dtcgToken(v, colorSpace, pastel, hdr) {
+	const token = {
 		$type: "color",
 		$value: dtcgColorValue(v, colorSpace, pastel)
 	};
+	if (hdr && v.hdr !== void 0) token.$extensions = { [DTCG_EXTENSION_NAMESPACE]: { hdr: dtcgHdrValue(v.hdr) } };
+	return token;
 }
 /**
 * Build a `GlazeDtcgResult`: one spec-conformant DTCG token document per
-* scheme variant, gated by `modes`. Light is always present.
+* scheme variant, gated by `modes`. Light is always present. With
+* `modes.hdr`, a token whose variant has an HDR value carries it in
+* `$extensions['me.tenphi.glaze'].hdr` — only in that scheme's document;
+* `$value` stays SDR.
 */
 function buildDtcgMap(resolved, prefix, modes, colorSpace = "srgb", pastel = false) {
 	const light = {};
 	const dark = modes.dark ? {} : void 0;
 	const lightContrast = modes.highContrast ? {} : void 0;
 	const darkContrast = modes.dark && modes.highContrast ? {} : void 0;
+	const token = (v) => dtcgToken(v, colorSpace, pastel, modes.hdr);
 	for (const [name, color] of resolved) {
 		const key = `${prefix}${name}`;
-		light[key] = dtcgToken(color.light, colorSpace, pastel);
-		if (dark) dark[key] = dtcgToken(color.dark, colorSpace, pastel);
-		if (lightContrast) lightContrast[key] = dtcgToken(color.lightContrast, colorSpace, pastel);
-		if (darkContrast) darkContrast[key] = dtcgToken(color.darkContrast, colorSpace, pastel);
+		light[key] = token(color.light);
+		if (dark) dark[key] = token(color.dark);
+		if (lightContrast) lightContrast[key] = token(color.lightContrast);
+		if (darkContrast) darkContrast[key] = token(color.darkContrast);
 	}
 	return {
 		light,
@@ -3313,19 +4492,37 @@ function buildDtcgResolver(result, options) {
 		resolutionOrder: [{ $ref: `#/sets/${setName}` }, { $ref: `#/modifiers/${modifierName}` }]
 	};
 }
-function tailwindLinesFor(resolved, themePrefix, cssPrefix, format, pastel) {
-	const lines = {
+/** Default `hdrSelector` for `tailwind()`. */
+const DEFAULT_TAILWIND_HDR_SELECTOR = "@media (dynamic-range: high)";
+/** Fresh, empty Tailwind line buckets. */
+function emptyTailwindLines() {
+	return {
 		light: [],
 		dark: [],
 		lightContrast: [],
-		darkContrast: []
+		darkContrast: [],
+		lightHdr: [],
+		darkHdr: [],
+		lightContrastHdr: [],
+		darkContrastHdr: []
 	};
+}
+/** Append every bucket of `part` to `acc` (palette accumulation). */
+function mergeTailwindLines(acc, part) {
+	for (const key of Object.keys(acc)) acc[key].push(...part[key]);
+}
+function tailwindLinesFor(resolved, themePrefix, cssPrefix, format, pastel, modes) {
+	const lines = emptyTailwindLines();
+	const schemes = emittedSchemes(modes);
 	for (const [name, color] of resolved) {
 		const prop = `--${cssPrefix}${themePrefix}${name}`;
-		lines.light.push(`${prop}: ${formatVariant(color.light, format, pastel)};`);
-		lines.dark.push(`${prop}: ${formatVariant(color.dark, format, pastel)};`);
-		lines.lightContrast.push(`${prop}: ${formatVariant(color.lightContrast, format, pastel)};`);
-		lines.darkContrast.push(`${prop}: ${formatVariant(color.darkContrast, format, pastel)};`);
+		const dense = modes.hdr && hasHdrIn(color, schemes);
+		for (const scheme of SCHEMES) {
+			const v = color[scheme];
+			const decl = `${prop}: ${formatVariant(v, format, pastel)};`;
+			lines[scheme].push(decl);
+			if (dense) lines[hdrKey(scheme)].push(v.hdr !== void 0 ? `${prop}: ${formatHdrVariant(v)};` : decl);
+		}
 	}
 	return lines;
 }
@@ -3354,36 +4551,47 @@ function emitScoped(scopes, declarations) {
 * Render accumulated per-scheme declaration lines as a Tailwind v4 CSS string:
 * an `@theme` block (light baseline) plus dark / high-contrast overrides under
 * the configured selectors. Empty blocks are skipped.
+*
+* With `modes.hdr`, the dense HDR blocks follow every SDR block, in scheme
+* order: light under `hdrSelector`, dark under `darkSelector` + `hdrSelector`,
+* and so on. Each re-declares the same set of colors, so whichever scheme
+* block wins the cascade in an HDR context carries that scheme's values.
 */
-function emitTailwindCss(lines, modes, darkSelector, highContrastSelector) {
+function emitTailwindCss(lines, modes, darkSelector, highContrastSelector, hdrSelector = DEFAULT_TAILWIND_HDR_SELECTOR) {
 	const blocks = [];
+	const push = (block) => {
+		if (block) blocks.push(block);
+	};
 	if (lines.light.length > 0) blocks.push(emitRule("@theme", lines.light.join("\n")));
-	if (modes.dark) {
-		const dark = emitScoped([darkSelector], lines.dark);
-		if (dark) blocks.push(dark);
-	}
-	if (modes.highContrast) {
-		const hc = emitScoped([highContrastSelector], lines.lightContrast);
-		if (hc) blocks.push(hc);
-	}
-	if (modes.dark && modes.highContrast) {
-		const dhc = emitScoped([darkSelector, highContrastSelector], lines.darkContrast);
-		if (dhc) blocks.push(dhc);
+	if (modes.dark) push(emitScoped([darkSelector], lines.dark));
+	if (modes.highContrast) push(emitScoped([highContrastSelector], lines.lightContrast));
+	if (modes.dark && modes.highContrast) push(emitScoped([darkSelector, highContrastSelector], lines.darkContrast));
+	if (modes.hdr) {
+		push(emitScoped([hdrSelector], lines.lightHdr));
+		if (modes.dark) push(emitScoped([darkSelector, hdrSelector], lines.darkHdr));
+		if (modes.highContrast) push(emitScoped([highContrastSelector, hdrSelector], lines.lightContrastHdr));
+		if (modes.dark && modes.highContrast) push(emitScoped([
+			darkSelector,
+			highContrastSelector,
+			hdrSelector
+		], lines.darkContrastHdr));
 	}
 	return blocks.join("\n\n");
 }
 /**
 * Build per-scheme declaration lines for a single theme (used by
-* `theme.tailwind()` and as the palette `buildOne` step).
+* `theme.tailwind()` and as the palette `buildOne` step). `modes` decides
+* whether the HDR lines are filled and which schemes count toward the dense
+* set.
 */
-function buildTailwindLines(resolved, themePrefix, cssPrefix, format, pastel) {
-	return tailwindLinesFor(resolved, themePrefix, cssPrefix, format, pastel);
+function buildTailwindLines(resolved, themePrefix, cssPrefix, format, pastel, modes) {
+	return tailwindLinesFor(resolved, themePrefix, cssPrefix, format, pastel, modes);
 }
 /**
 * Build a complete Tailwind v4 CSS string for a single theme.
 */
-function buildTailwindMap(resolved, themePrefix, cssPrefix, modes, format, darkSelector, highContrastSelector, pastel = false) {
-	return emitTailwindCss(tailwindLinesFor(resolved, themePrefix, cssPrefix, format, pastel), modes, darkSelector, highContrastSelector);
+function buildTailwindMap(resolved, themePrefix, cssPrefix, modes, format, darkSelector, highContrastSelector, pastel = false, hdrSelector = DEFAULT_TAILWIND_HDR_SELECTOR) {
+	return emitTailwindCss(tailwindLinesFor(resolved, themePrefix, cssPrefix, format, pastel, modes), modes, darkSelector, highContrastSelector, hdrSelector);
 }
 
 //#endregion
@@ -3396,10 +4604,26 @@ function buildTailwindMap(resolved, themePrefix, cssPrefix, modes, format, darkS
 * `{ l, c, h }`), the structured-input validator, the two factory paths
 * (value vs structured), and the JSON-safe export / rehydration round-trip.
 *
-* Tokens store a sparse local config override only. Resolve merges the
-* live global config with that local override (invalidated on
-* `configure()`). Authoring `.export(override?)` freezes
-* `getConfig() ∪ local ∪ override` at call time.
+* Every token also registers an internal dark-delta anchor hook: a token that
+* links to it as `base` passes the hook to the resolver, so a `'+N'` link steps
+* in dark from where the base sits under the base's own windows (the resolver
+* reads an `auto` base under another dark window back through the link's own).
+* The hook's result is cached per pass with the token's resolve.
+*
+* A token's role is pinned here rather than left to the resolver's chain: an
+* explicit `role`, else `'text'`. The token is the foreground against its
+* anchor — its `base`, or the hidden seed holding its own input color — and
+* the user-supplied `name` is a debug label that never drives role inference.
+*
+* Tokens store a sparse local config override only, copied once at creation so
+* the caller's object can't reach it later. Resolve merges the live global
+* config with that local override (invalidated on `configure()`). Authoring
+* `.export(override?)` freezes `getConfig() ∪ local ∪ override` at call time.
+*
+* `css()` with `splitHue` claims the token's `--{name}-hue` and its value
+* property in one namespace, so `suffix: '-hue'` throws whenever the token
+* declares a hue var (it is chromatic in light), instead of emitting a value
+* that reads itself through `var()`.
 */
 /** Internal name of the user-facing standalone color in the synthesized def map. */
 const STANDALONE_VALUE = "value";
@@ -3415,12 +4639,13 @@ const RESERVED_STANDALONE_NAMES = new Set([
 ]);
 /**
 * Value-form local override: `lightTone` defaults to `false` (preserve
-* input tone). User override fields win.
+* input tone). User override fields win. Returns a detached copy.
 */
 function sparseValueFormLocal(userOverride) {
+	const own = copyConfigOverride(userOverride);
 	return {
-		...userOverride,
-		lightTone: userOverride?.lightTone !== void 0 ? userOverride.lightTone : false
+		...own,
+		lightTone: own?.lightTone !== void 0 ? own.lightTone : false
 	};
 }
 /**
@@ -3485,6 +4710,20 @@ function pinExtremeTone(tone) {
 	return Array.isArray(tone) ? [pin(tone[0]), pin(tone[1])] : pin(tone);
 }
 /**
+* The role the user-facing def resolves with: an explicit `role`, else
+* `'text'`.
+*
+* A token is the foreground against its anchor in both pairings — an
+* external `base` (which the resolver treats as a background) and the hidden
+* `STANDALONE_SEED` holding the token's own input color (marked `'surface'`
+* below). Pinning the role here, instead of leaving it to the resolver's
+* chain, also keeps the user-supplied `name` a pure debug label: it becomes
+* the def's key, so the resolver would otherwise infer a role from it.
+*/
+function standaloneRole(role) {
+	return normalizeRole(role) ?? "text";
+}
+/**
 * Build the `ColorMap` for a value-shorthand `glaze.color()` call.
 *
 * The user-facing color (`STANDALONE_VALUE`) defaults to `mode: 'auto'`
@@ -3505,7 +4744,7 @@ function buildStandaloneValueDefs(main, options) {
 	const relativeHue = typeof options?.hue === "string" ? options.hue : void 0;
 	const toneOption = options?.tone;
 	const hasExternalBase = options?.base !== void 0;
-	const needsSeedAnchor = !hasExternalBase && (options?.contrast !== void 0 || toneOption !== void 0 && !isAbsoluteTone(toneOption));
+	const needsSeedAnchor = !hasExternalBase && (options?.contrast !== void 0 || hasRelativeTone(toneOption));
 	if (options?.opacity !== void 0) validateStandaloneOpacity(options.opacity);
 	const userName = options?.name;
 	if (userName !== void 0) validateStandaloneName(userName);
@@ -3523,7 +4762,7 @@ function buildStandaloneValueDefs(main, options) {
 		autoFlip: options?.autoFlip,
 		opacity: options?.opacity,
 		pastel: options?.pastel,
-		role: options?.role,
+		role: standaloneRole(options?.role),
 		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
 	};
 	const defs = { [primary]: valueDef };
@@ -3531,7 +4770,8 @@ function buildStandaloneValueDefs(main, options) {
 		hue: main.h,
 		saturation: 1,
 		tone: seedTone,
-		mode: "static"
+		mode: "static",
+		role: "surface"
 	};
 	return {
 		seed: {
@@ -3543,7 +4783,22 @@ function buildStandaloneValueDefs(main, options) {
 		primary
 	};
 }
+/**
+* Each token's dark-delta anchor (internal, not public API). A token linking to
+* another as its `base` hands the resolver the base's hook, so a `'+N'` link
+* steps in dark from where the base sits on its own authored scale — read in the
+* base's own resolve context, under its windows and defs, and returned with the
+* base's config so the resolver can tell whether the link's dark window is the
+* same one.
+*/
+const darkAnchorHooks = /* @__PURE__ */ new WeakMap();
+function withDarkAnchor(hook, token) {
+	darkAnchorHooks.set(token, hook);
+	return token;
+}
 function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken, buildExport) {
+	const baseHook = baseToken && darkAnchorHooks.get(baseToken);
+	const externalAnchors = baseHook ? new Map([[STANDALONE_BASE, baseHook]]) : void 0;
 	let cache = null;
 	function getEffectiveConfig() {
 		const version = getConfigVersion();
@@ -3552,7 +4807,8 @@ function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken
 		cache = {
 			map: null,
 			version,
-			effectiveConfig
+			effectiveConfig,
+			anchors: []
 		};
 		return effectiveConfig;
 	}
@@ -3560,14 +4816,32 @@ function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken
 		const version = getConfigVersion();
 		if (cache && cache.version === version && cache.map) return cache.map;
 		const effectiveConfig = getEffectiveConfig();
-		const map = resolveAllColors(seed, defs, effectiveConfig, baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0);
+		const externalBases = baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0;
+		const map = resolveAllColors(seed, defs, effectiveConfig, externalBases, externalAnchors);
 		cache = {
 			map,
 			version,
-			effectiveConfig
+			effectiveConfig,
+			externalBases,
+			anchors: []
 		};
 		return map;
 	};
+	const darkAnchor = (isHighContrast) => {
+		const resolved = resolveOnce();
+		const { anchors, effectiveConfig, externalBases } = cache;
+		const pass = isHighContrast ? 1 : 0;
+		return anchors[pass] ??= {
+			tone: darkAnchorOf(primary, isHighContrast, {
+				defs,
+				config: effectiveConfig,
+				resolved,
+				externalBases,
+				externalAnchors
+			}),
+			config: effectiveConfig
+		};
+	};
 	const resolveStates = (options) => {
 		const cfg = getConfig();
 		return {
@@ -3578,7 +4852,7 @@ function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken
 	const tokenLike = (options) => {
 		return buildTokenMap(resolveOnce(), "", resolveStates(options), resolveModes(options?.modes), options?.format ?? "oklch", getEffectiveConfig().pastel)[`#${primary}`];
 	};
-	return {
+	return withDarkAnchor(darkAnchor, {
 		resolve() {
 			return resolveOnce().get(primary);
 		},
@@ -3592,10 +4866,12 @@ function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken
 		css(options) {
 			const format = options.format ?? "oklch";
 			assertNativeFormat(format, "css");
+			assertSplitHueFormat(options.splitHue, format);
+			const suffix = options.suffix ?? "-color";
 			const resolved = resolveOnce().get(primary);
 			const renamed = new Map([[options.name, resolved]]);
 			let channelCtx;
-			if (options.splitHue && format === "oklch") {
+			if (options.splitHue) {
 				assertAllPastel(renamed, resolveModes());
 				channelCtx = {
 					seedHue: seed.hue,
@@ -3605,8 +4881,19 @@ function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken
 					mode: "standalone",
 					resolvedHue: resolved.light.h
 				};
+				const owners = /* @__PURE__ */ new Map();
+				const fix = "Pass a `suffix` other than '-hue'.";
+				const labels = {
+					theme: `the hue of token "${options.name}"`,
+					color: (name) => `the hue of token "${name}"`,
+					value: (name) => `the value of token "${name}"`,
+					fix,
+					valueFix: fix
+				};
+				claimHueVars(renamed, channelCtx, owners, labels);
+				claimValueProps(renamed, "", suffix, owners, labels);
 			}
-			return buildCssMap(renamed, "", options.suffix ?? "-color", format, getEffectiveConfig().pastel, channelCtx);
+			return buildCssMap(renamed, "", suffix, format, getEffectiveConfig().pastel, channelCtx);
 		},
 		dtcg(options) {
 			const modes = resolveModes(options?.modes);
@@ -3634,7 +4921,7 @@ function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken
 		export(override) {
 			return buildExport(override);
 		}
-	};
+	});
 }
 /**
 * When a value/`from` color links to a base that was created via the
@@ -3691,15 +4978,16 @@ function createColorToken(input, configOverride) {
 		contrast: input.contrast,
 		opacity: input.opacity,
 		pastel: input.pastel,
-		role: input.role,
+		role: standaloneRole(input.role),
 		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
 	} };
 	if (needsSeedAnchor) defs[STANDALONE_SEED] = {
 		tone: pinExtremeTone(pairNormal(input.tone)),
 		saturation: 1,
-		mode: "static"
+		mode: "static",
+		role: "surface"
 	};
-	const localOverride = configOverride;
+	const localOverride = copyConfigOverride(configOverride);
 	return createColorTokenFromDefs({
 		hue: input.hue,
 		saturation: input.saturation,
@@ -3838,7 +5126,33 @@ function colorFromExport(data) {
 
 //#endregion
 //#region src/theme.ts
-function createTheme(seed, initialColors, configOverride) {
+/**
+* Theme factory.
+*
+* Wraps a hue/saturation seed, a mutable `ColorMap`, and an optional
+* per-theme `GlazeConfigOverride`. Exposes `tokens()` / `tasty()` /
+* `json()` / `css()` / `dtcg()` / `dtcgResolver()` / `tailwind()` / `resolve()` /
+* `export()` / `extend()`.
+*
+* The per-theme config override is **merged over the live global config at
+* resolve time** so the theme still reacts to later `configure()` calls
+* for fields it didn't override. The merged config is memoized by
+* `configVersion` to avoid rebuilding it on every export call. The override is
+* copied once when the theme is created and `getConfig()` hands out a deep copy
+* of the merged config, so mutating either object can't reach a resolve.
+*
+* Exports carry the HDR tier of glows (`variant.hdr`) only with `modes.hdr`
+* — `css()` reads its own `hdr` option, defaulting to the global mode — and
+* `tasty()` keys it with `states.hdr`; the shapes live in `formatters.ts`.
+*
+* `tasty()` / `css()` with `splitHue` run its guards before emitting: format
+* `'oklch'`, every color pastel, and no color whose own hue var would take the
+* theme var's name (`--{name}-hue`). `css()` also claims each color's value
+* property, so a `suffix` that lands one on a hue var (`'-hue'`, or `''` with a
+* color named `*-hue`) throws too.
+*/
+function createTheme(seed, initialColors, callerOverride) {
+	const configOverride = copyConfigOverride(callerOverride);
 	const { hue, saturation, darkHue, darkSaturation } = seed;
 	let colorDefs = initialColors ? { ...initialColors } : {};
 	let cache = null;
@@ -3868,18 +5182,38 @@ function createTheme(seed, initialColors, configOverride) {
 	function invalidate() {
 		cache = null;
 	}
-	function channelCtxFor(options, formatDefault, prefix) {
-		const format = options?.format ?? formatDefault;
-		if (!options?.splitHue || format !== "oklch") return void 0;
-		assertAllPastel(resolveCached(), resolveModes(options?.modes));
-		return {
+	/**
+	* `splitHue` context for `tasty()` / `css()`, or `undefined` without it.
+	* Throws on a non-oklch format, a non-pastel color, or a color whose own
+	* hue var would take the theme var's name. `css()` passes its `suffix` so
+	* each color's value property is claimed too: `--{color}{suffix}` must not
+	* land on a hue var.
+	*/
+	function channelCtxFor(options, format, modes, valueSuffix) {
+		if (!options?.splitHue) return void 0;
+		assertSplitHueFormat(options.splitHue, format);
+		const resolved = resolveCached();
+		assertAllPastel(resolved, modes);
+		const baseName = options.name ?? "theme";
+		const ctx = {
 			seedHue: hue,
 			darkSeedHue: darkHue,
-			baseName: options.name ?? "theme",
-			prefix,
+			baseName,
+			prefix: "",
 			defs: colorDefs,
 			mode: "theme"
 		};
+		const owners = /* @__PURE__ */ new Map();
+		const labels = {
+			theme: `the theme hue (name: '${baseName}')`,
+			color: (name) => `color "${name}"'s own hue`,
+			value: (name) => `color "${name}"'s value`,
+			fix: "Rename the color or pass a different `name`.",
+			valueFix: "Rename the color, or pass a different `suffix` or `name`."
+		};
+		claimHueVars(resolved, ctx, owners, labels);
+		if (valueSuffix !== void 0) claimValueProps(resolved, "", valueSuffix, owners, labels);
+		return ctx;
 	}
 	return {
 		get hue() {
@@ -3895,7 +5229,7 @@ function createTheme(seed, initialColors, configOverride) {
 			return darkSaturation;
 		},
 		getConfig() {
-			return getEffectiveConfig();
+			return copyResolvedConfig(getEffectiveConfig());
 		},
 		colors(defs) {
 			colorDefs = {
@@ -3950,7 +5284,7 @@ function createTheme(seed, initialColors, configOverride) {
 				...options.colors
 			} : { ...inheritedColors }, configOverride || options.config ? {
 				...configOverride ?? {},
-				...options.config ?? {}
+				...copyConfigOverride(options.config) ?? {}
 			} : void 0);
 		},
 		resolve() {
@@ -3966,11 +5300,12 @@ function createTheme(seed, initialColors, configOverride) {
 			const cfg = getEffectiveConfig();
 			const states = {
 				dark: options?.states?.dark ?? cfg.states.dark,
-				highContrast: options?.states?.highContrast ?? cfg.states.highContrast
+				highContrast: options?.states?.highContrast ?? cfg.states.highContrast,
+				hdr: options?.states?.hdr ?? cfg.states.hdr
 			};
 			const modes = resolveModes(options?.modes);
 			const format = options?.format ?? "oklch";
-			const channelCtx = channelCtxFor(options, "oklch", "");
+			const channelCtx = channelCtxFor(options, format, modes);
 			return buildTokenMap(resolveCached(), "", states, modes, format, cfg.pastel, channelCtx);
 		},
 		json(options) {
@@ -3982,8 +5317,10 @@ function createTheme(seed, initialColors, configOverride) {
 		css(options) {
 			const format = options?.format ?? "oklch";
 			assertNativeFormat(format, "css");
-			const channelCtx = channelCtxFor(options, "oklch", "");
-			return buildCssMap(resolveCached(), "", options?.suffix ?? "-color", format, getEffectiveConfig().pastel, channelCtx);
+			const suffix = options?.suffix ?? "-color";
+			const modes = resolveModes();
+			const channelCtx = channelCtxFor(options, format, modes, suffix);
+			return buildCssMap(resolveCached(), "", suffix, format, getEffectiveConfig().pastel, channelCtx, options?.hdr ?? modes.hdr);
 		},
 		dtcg(options) {
 			const modes = resolveModes(options?.modes);
@@ -3996,13 +5333,34 @@ function createTheme(seed, initialColors, configOverride) {
 			const format = options?.format ?? "oklch";
 			assertNativeFormat(format, "tailwind");
 			const modes = resolveModes(options?.modes);
-			return buildTailwindMap(resolveCached(), "", options?.namespace ?? "color-", modes, format, options?.darkSelector ?? ".dark", options?.highContrastSelector ?? ".high-contrast", getEffectiveConfig().pastel);
+			return buildTailwindMap(resolveCached(), "", options?.namespace ?? "color-", modes, format, options?.darkSelector ?? ".dark", options?.highContrastSelector ?? ".high-contrast", getEffectiveConfig().pastel, options?.hdrSelector ?? DEFAULT_TAILWIND_HDR_SELECTOR);
 		}
 	};
 }
 
 //#endregion
 //#region src/palette.ts
+/**
+* Palette factory.
+*
+* Composes multiple themes into a single token namespace with optional
+* theme-name prefixes and a "primary theme" that also surfaces an
+* unprefixed copy of its tokens. Six export methods (`tokens` / `tasty` /
+* `css` / `dtcg` / `dtcgResolver` / `tailwind`) share a `buildPaletteOutput`
+* driver that handles validation, per-theme iteration, prefix resolution,
+* collision filtering, and primary duplication; `json()` keys its output by
+* theme name instead, with no prefixes or collisions to resolve. The HDR
+* tier of glows (with `modes.hdr`, or `css({ hdr })`) is built from the same
+* filtered maps, so prefixes, the primary alias and collisions apply to it the
+* same way.
+* `tasty()` / `css()` with `splitHue` share one custom-property registry across
+* the passes of a call, so two themes declaring the same `--*-hue` throws — as
+* does a `css()` value property (primary aliases included) landing on a hue
+* var.
+*
+* Authoring round-trip: `palette.export()` / `createPaletteFromExport()`
+* (wired as `glaze.paletteFrom`).
+*/
 function resolvePrefix(options, themeName, defaultPrefix = false) {
 	const prefix = options?.prefix ?? defaultPrefix;
 	if (prefix === true) return `${themeName}-`;
@@ -4050,18 +5408,39 @@ function colorMapFromTheme(theme) {
 	}
 	return defs;
 }
-function channelCtxForTheme(theme, themeName, passPrefix, themedPrefix, splitHue, format, modes, filtered) {
-	if (!splitHue || format !== "oklch") return void 0;
+/**
+* `splitHue` context for one theme pass of `palette.tasty()` / `css()`, or
+* `undefined` without `splitHue` (the caller has already checked the format).
+* `hueOwners` is shared by every pass of one export call, so a property two
+* declarations would share — a color named after another theme under an empty
+* prefix, or (`css()`, which passes its `suffix`) a color's value property
+* landing on a hue var — throws instead of one silently overriding the other.
+* Value properties are claimed on the primary's alias pass too: it declares no
+* hue vars, but its unprefixed values are emitted all the same.
+*/
+function channelCtxForTheme(theme, themeName, passPrefix, themedPrefix, splitHue, modes, filtered, hueOwners, valueSuffix) {
+	if (!splitHue) return void 0;
 	assertAllPastel(filtered, modes);
-	return {
+	const aliasPass = passPrefix !== themedPrefix;
+	const ctx = {
 		seedHue: theme.hue,
 		darkSeedHue: theme.darkHue,
 		baseName: themeName,
 		prefix: themedPrefix,
 		defs: colorMapFromTheme(theme),
 		mode: "theme",
-		emitDeclarations: passPrefix === themedPrefix
+		emitDeclarations: !aliasPass
 	};
+	const labels = {
+		theme: `the hue of theme "${themeName}"`,
+		color: (name) => `color "${name}"'s own hue (theme "${themeName}")`,
+		value: (name) => aliasPass ? `the primary alias of color "${name}" (theme "${themeName}")` : `color "${name}"'s value (theme "${themeName}")`,
+		fix: "Rename the color or the theme, or give the theme a prefix that keeps its hue vars apart.",
+		valueFix: "Rename the color or the theme, or pass a different `suffix` or theme prefix."
+	};
+	claimHueVars(filtered, ctx, hueOwners, labels);
+	if (valueSuffix !== void 0) claimValueProps(filtered, passPrefix, valueSuffix, hueOwners, labels);
+	return ctx;
 }
 /**
 * Shared per-theme driver for `tokens` / `tasty` / `css`. `json` skips
@@ -4082,10 +5461,11 @@ function buildPaletteOutput(themes, paletteOptions, options, buildOne, merge, em
 	return acc;
 }
 /** Rebuild a theme from a `theme.export()` snapshot. */
-function createThemeFromExport(data, factory = "glaze.themeFrom") {
+function createThemeFromExport(data, factory = "glaze.themeFrom", fallbackVersion) {
 	if (data === null || typeof data !== "object") throw new Error(`${factory}: expected an object from theme.export(), got ${data === null ? "null" : typeof data}.`);
 	assertExportKind(data, "theme", factory);
 	assertExportVersion(data, factory);
+	assertNoLegacyShadows(data, factory, fallbackVersion);
 	if (typeof data.hue !== "number" || typeof data.saturation !== "number") throw new Error(`${factory}: expected numeric "hue" and "saturation" fields.`);
 	for (const field of ["darkHue", "darkSaturation"]) if (data[field] !== void 0 && typeof data[field] !== "number") throw new Error(`${factory}: expected "${field}" to be a number when present (got ${JSON.stringify(data[field])}).`);
 	return createTheme({
@@ -4104,7 +5484,7 @@ function createPaletteFromExport(data) {
 	assertExportVersion(data, "glaze.paletteFrom");
 	if (data.themes === null || typeof data.themes !== "object") throw new Error(`glaze.paletteFrom: expected a "themes" object map of theme exports.`);
 	const rebuilt = {};
-	for (const [name, themeExport] of Object.entries(data.themes)) rebuilt[name] = createThemeFromExport(themeExport, `glaze.paletteFrom (theme "${name}")`);
+	for (const [name, themeExport] of Object.entries(data.themes)) rebuilt[name] = createThemeFromExport(themeExport, `glaze.paletteFrom (theme "${name}")`, data.version);
 	return createPalette(rebuilt, { primary: data.primary });
 }
 function createPalette(themes, paletteOptions) {
@@ -4158,12 +5538,15 @@ function createPalette(themes, paletteOptions) {
 			const cfg = getConfig();
 			const states = {
 				dark: options?.states?.dark ?? cfg.states.dark,
-				highContrast: options?.states?.highContrast ?? cfg.states.highContrast
+				highContrast: options?.states?.highContrast ?? cfg.states.highContrast,
+				hdr: options?.states?.hdr ?? cfg.states.hdr
 			};
 			const modes = resolveModes(options?.modes);
 			const format = options?.format ?? "oklch";
+			assertSplitHueFormat(options?.splitHue, format);
+			const hueOwners = /* @__PURE__ */ new Map();
 			return buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix, pastel, themeName, theme) => {
-				return buildTokenMap(filtered, prefix, states, modes, format, pastel, channelCtxForTheme(theme, themeName, prefix, resolvePrefix(options, themeName, true), options?.splitHue, format, modes, filtered));
+				return buildTokenMap(filtered, prefix, states, modes, format, pastel, channelCtxForTheme(theme, themeName, prefix, resolvePrefix(options, themeName, true), options?.splitHue, modes, filtered, hueOwners));
 			}, (acc, part) => Object.assign(acc, part), () => ({}));
 		},
 		json(options) {
@@ -4178,28 +5561,24 @@ function createPalette(themes, paletteOptions) {
 			const suffix = options?.suffix ?? "-color";
 			const format = options?.format ?? "oklch";
 			assertNativeFormat(format, "css");
+			assertSplitHueFormat(options?.splitHue, format);
 			const modes = resolveModes();
+			const hdr = options?.hdr ?? modes.hdr;
+			const hueOwners = /* @__PURE__ */ new Map();
 			const lines = buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix, pastel, themeName, theme) => {
-				return buildCssMap(filtered, prefix, suffix, format, pastel, channelCtxForTheme(theme, themeName, prefix, resolvePrefix(options, themeName, true), options?.splitHue, format, modes, filtered));
+				return buildCssMap(filtered, prefix, suffix, format, pastel, channelCtxForTheme(theme, themeName, prefix, resolvePrefix(options, themeName, true), options?.splitHue, modes, filtered, hueOwners, suffix), hdr);
 			}, (acc, part) => {
-				for (const key of [
-					"light",
-					"dark",
-					"lightContrast",
-					"darkContrast"
-				]) if (part[key]) acc[key].push(part[key]);
+				for (const key of SCHEMES) {
+					if (part[key]) acc.sdr[key].push(part[key]);
+					if (part.hdr?.[key]) acc.hdr[key].push(part.hdr[key]);
+				}
 			}, () => ({
-				light: [],
-				dark: [],
-				lightContrast: [],
-				darkContrast: []
+				sdr: emptySchemeLines(),
+				hdr: emptySchemeLines()
 			}));
-			return {
-				light: lines.light.join("\n"),
-				dark: lines.dark.join("\n"),
-				lightContrast: lines.lightContrast.join("\n"),
-				darkContrast: lines.darkContrast.join("\n")
-			};
+			const result = joinSchemeLines(lines.sdr);
+			if (hdr) result.hdr = joinSchemeLines(lines.hdr);
+			return result;
 		},
 		dtcg(options) {
 			return buildDtcgResult(options);
@@ -4214,19 +5593,8 @@ function createPalette(themes, paletteOptions) {
 			assertNativeFormat(format, "tailwind");
 			const darkSelector = options?.darkSelector ?? ".dark";
 			const highContrastSelector = options?.highContrastSelector ?? ".high-contrast";
-			return emitTailwindCss(buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix, pastel, _themeName, _theme) => buildTailwindLines(filtered, prefix, cssPrefix, format, pastel), (acc, part) => {
-				for (const variant of [
-					"light",
-					"dark",
-					"lightContrast",
-					"darkContrast"
-				]) acc[variant].push(...part[variant]);
-			}, () => ({
-				light: [],
-				dark: [],
-				lightContrast: [],
-				darkContrast: []
-			})), modes, darkSelector, highContrastSelector);
+			const hdrSelector = options?.hdrSelector ?? DEFAULT_TAILWIND_HDR_SELECTOR;
+			return emitTailwindCss(buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix, pastel, _themeName, _theme) => buildTailwindLines(filtered, prefix, cssPrefix, format, pastel, modes), mergeTailwindLines, emptyTailwindLines), modes, darkSelector, highContrastSelector, hdrSelector);
 		}
 	};
 }
@@ -4241,42 +5609,18 @@ function createPalette(themes, paletteOptions) {
 * - `theme.ts` — single-theme factory
 * - `palette.ts` — multi-theme composition
 * - `color-token.ts` — standalone single-color tokens (`glaze.color`)
-* - `shadow.ts` — standalone shadow factory (`glaze.shadow`)
-* - `formatters.ts` — variant → string (`glaze.format`)
+* - `lighting.ts` — shadow / glow solver (`glaze.shadow`, `glaze.glow`,
+*   including a glow's HDR value)
+* - `formatters.ts` — variant → string (`glaze.format`, `glaze.formatHdr`)
 * - `config.ts` — global config singleton
 * - `serialize.ts` — authoring export type guards / version checks
 */
-/**
-* Create a single-hue glaze theme.
-*
-* An optional `config` override can be supplied to customize the resolve
-* behavior for this theme (tone windows, etc.). The
-* override is **merged over the live global config at resolve time** —
-* the theme still reacts to later `configure()` calls for fields it
-* didn't override.
-*
-* The object form also accepts `darkHue` / `darkSaturation` — a separate
-* seed pair for the dark and dark-high-contrast schemes. Both default to
-* their light counterparts, and an explicit `darkSaturation` opts the theme
-* out of the global `darkDesaturation` reduction.
-*
-* @example
-* ```ts
-* const primary = glaze(280, 80);
-* // or shorthand:
-* const primary = glaze({ hue: 280, saturation: 80 });
-* // with a retuned dark seed:
-* const primary = glaze({ hue: 280, saturation: 80, darkHue: 268, darkSaturation: 65 });
-* // with config override:
-* const raw = glaze(280, 80, { lightTone: false });
-* ```
-*/
-function glaze(hueOrOptions, saturation, config) {
+function glaze(hueOrOptions, saturationOrConfig, config) {
 	if (typeof hueOrOptions === "number") return createTheme({
 		hue: hueOrOptions,
-		saturation: saturation ?? 100
+		saturation: (typeof saturationOrConfig === "number" ? saturationOrConfig : void 0) ?? 100
 	}, void 0, config);
-	return createTheme(hueOrOptions, void 0, config);
+	return createTheme(hueOrOptions, void 0, typeof saturationOrConfig === "object" ? saturationOrConfig : config);
 }
 /** Configure global glaze settings. */
 glaze.configure = function configure$1(config) {
@@ -4347,42 +5691,77 @@ glaze.color = function color(input, config) {
 	if ("hue" in obj) return createColorToken(input, config);
 	return createColorTokenFromValue(input, void 0, config);
 };
-/**
-* Compute a shadow color from a bg/fg pair and intensity.
-*
-* Both `bg` and `fg` accept any `GlazeColorValue` form: hex (`#rgb` /
-* `#rrggbb` / `#rrggbbaa`), `rgb()` / `hsl()` / `okhsl()` / `oklch()`
-* strings, or `{ r, g, b }` / `{ h, s, l }` / `{ l, c, h }` objects.
-*/
-glaze.shadow = function shadow(input) {
+/** Shared body of `glaze.shadow()` / `glaze.glow()`. */
+function standaloneLighting(kind, input) {
 	const bg = extractOkhslFromValue(input.bg);
 	const fg = input.fg ? extractOkhslFromValue(input.fg) : void 0;
 	const cfg = getConfig();
-	const tuning = resolveShadowTuning(input.tuning, cfg.shadowTuning);
-	const result = computeShadow({
-		...bg,
-		alpha: 1
-	}, fg ? {
-		...fg,
-		alpha: 1
-	} : void 0, input.intensity, tuning);
+	const tuning = resolveLightingTuning(normalizeLightingTuning(kind, input.tuning, `glaze.${kind}() tuning`), kind === "shadow" ? cfg.shadowTuning : cfg.glowTuning);
+	const result = computeLighting(kind, bg, fg, input.intensity, tuning, false);
+	warnLightingShortfall(kind, void 0, void 0, result, tuning.headroom);
 	const { h, s, t } = okhslToOkhst({
 		h: result.h,
 		s: result.s,
 		l: result.l
 	});
-	return {
+	const variant = {
 		h,
 		s,
 		t,
 		alpha: result.alpha
 	};
+	if (result.hdr) variant.hdr = toResolvedHdr(result.hdr);
+	return variant;
+}
+/**
+* Compute a shadow over a surface: a translucent pigment whose opacity lands
+* `bg` exactly `intensity` tones darker once the browser composites it. The
+* optional object `fg` scales the step (a darker object casts a deeper
+* shadow).
+*
+* Both `bg` and `fg` accept any `GlazeColorValue` form: hex (`#rgb` /
+* `#rgba` / `#rrggbb` / `#rrggbbaa`), `rgb()` / `hsl()` / `okhsl()` /
+* `okhst()` / `oklch()` strings, or `{ r, g, b }` / `{ h, s, l }` /
+* `{ h, s, t }` / `{ l, c, h }` objects. Alpha components are dropped with
+* a warning. `GlazeColorValue` gives each form's component scales.
+*/
+glaze.shadow = function shadow(input) {
+	return standaloneLighting("shadow", input);
+};
+/**
+* Compute a glow over a surface — the mirror of `glaze.shadow()`: the
+* composite lands `bg` exactly `intensity` tones lighter, and a lighter
+* object `fg` glows stronger. Accepts the same inputs, plus `tuning.headroom`
+* (merged over the global `glowTuning`): when the step would pass SDR white,
+* the result carries `hdr` — an opaque exposure of the SDR result, formatted
+* by `glaze.formatHdr()` — unless the pigment cannot lift a non-white `bg` at
+* all (see `GlowTuning.headroom`).
+*/
+glaze.glow = function glow(input) {
+	return standaloneLighting("glow", input);
 };
 /** Format a resolved color variant as a CSS string. */
 glaze.format = function format(variant, colorFormat, pastel) {
 	return formatVariant(variant, colorFormat, pastel);
 };
 /**
+* Format a variant's HDR value — set on a glow whose step crosses SDR white
+* with `headroom` above 0 — as `color(srgb-linear R G B)`, with channels that
+* may exceed 1. Returns `undefined` for a variant without one. Only
+* `'srgb-linear'` is supported: OKLCH lightness clamps at parse time and
+* `rgb()` / `hsl()` cannot go past white.
+*
+* @example
+* ```ts
+* const v = glaze.glow({ bg: '#ffffff', intensity: 12, tuning: { headroom: 1 } });
+* glaze.format(v);    // SDR: 'oklch(1 0 0)'
+* glaze.formatHdr(v); // 'color(srgb-linear 1.4631 1.4631 1.4631)'
+* ```
+*/
+glaze.formatHdr = function formatHdr(variant, hdrFormat = "srgb-linear") {
+	return formatHdrVariant(variant, hdrFormat);
+};
+/**
 * Create a theme from a hex color string.
 * Extracts hue and saturation from the color.
 */
@@ -4458,6 +5837,7 @@ exports.APCA_PRESETS = APCA_PRESETS;
 exports.GLAZE_EXPORT_VERSION = GLAZE_EXPORT_VERSION;
 exports.REF_EPS = REF_EPS;
 exports.apcaContrast = apcaContrast;
+exports.apcaLuminanceFromLinearRgb = apcaLuminanceFromLinearRgb;
 exports.assertAllPastel = assertAllPastel;
 exports.assertNativeFormat = assertNativeFormat;
 exports.contrastRatioFromLuminance = contrastRatioFromLuminance;
@@ -4469,6 +5849,7 @@ exports.formatOkhsl = formatOkhsl;
 exports.formatOkhst = formatOkhst;
 exports.formatOklch = formatOklch;
 exports.formatRgb = formatRgb;
+exports.formatSrgbLinear = formatSrgbLinear;
 exports.fromTone = fromTone;
 exports.gamutClampedLuminance = gamutClampedLuminance;
 exports.glaze = glaze;