@tenphi/glaze 0.0.0-snapshot.432b23c → 0.0.0-snapshot.575cb1c

package/README.md

@@ -194,6 +194,8 @@ A single value applies to both modes. All control is local and explicit.
 'muted':  { base: 'surface', lightness: ['-35', '-50'], contrast: ['AA-large', 'AA'] }
 ```
 
+**Full lightness spectrum in HC mode:** In high-contrast variants, the `lightLightness` and `darkLightness` window constraints are bypassed entirely. Colors can reach the full 0–100 lightness range, maximizing perceivable contrast. Normal (non-HC) variants continue to use the configured windows.
+
 ## Theme Color Management
 
 ### Adding Colors
@@ -601,7 +603,7 @@ Modes control how colors adapt across schemes:
 
 ```ts
 // Light: surface L=97, text lightness='-52' → L=45 (dark text on light bg)
-// Dark:  surface inverts to L≈14, sign flips → L=14+52=66
+// Dark:  surface inverts to L≈29 (power curve), sign flips → L=29+52=81
 //        contrast solver may push further (light text on dark bg)
 ```
 
@@ -625,7 +627,7 @@ const [lo, hi] = lightLightness; // default: [10, 100]
 const mappedL = (lightness * (hi - lo)) / 100 + lo;
 ```
 
-Both `auto` and `fixed` modes use the same linear formula. `static` mode bypasses the mapping entirely.
+Both `auto` and `fixed` modes use the same linear formula. `static` mode and high-contrast variants bypass the mapping entirely (identity: `mappedL = l`).
 
 | Color | Raw L | Mapped L (default [10, 100]) |
 |---|---|---|
@@ -637,24 +639,29 @@ Both `auto` and `fixed` modes use the same linear formula. `static` mode bypasse
 
 ### Lightness
 
-**`auto`** — inverted within the configured window:
+**`auto`** — inverted with a power curve within the configured window:
 
 ```ts
 const [lo, hi] = darkLightness; // default: [15, 95]
-const invertedL = ((100 - lightness) * (hi - lo)) / 100 + lo;
+const d = (100 - lightness) / 100;
+const invertedL = lo + (hi - lo) * Math.pow(d, darkCurve); // darkCurve default: 0.5
 ```
 
-**`fixed`** — mapped without inversion:
+The `darkCurve` exponent (default `0.5`) expands small light-theme deltas near white into larger usable deltas in dark mode. This preserves subtle surface hierarchy (e.g. L=97 vs L=95) that would otherwise collapse to near-identical dark values. Set `darkCurve: 1` for linear (legacy) behavior.
+
+**`fixed`** — mapped without inversion (not affected by `darkCurve`):
 
 ```ts
 const mappedL = (lightness * (hi - lo)) / 100 + lo;
 ```
 
-| Color | Light L | Auto (inverted) | Fixed (mapped) |
-|---|---|---|---|
-| surface (L=97) | 97 | 17.4 | 92.6 |
-| accent-fill (L=52) | 52 | 53.4 | 56.6 |
-| accent-text (L=100) | 100 | 15 | 95 |
+| Color | Light L | Auto (curve=0.5) | Auto (curve=1, linear) | Fixed (mapped) |
+|---|---|---|---|---|
+| surface (L=97) | 97 | 28.9 | 17.4 | 92.6 |
+| accent-fill (L=52) | 52 | 70.4 | 53.4 | 56.6 |
+| accent-text (L=100) | 100 | 15 | 15 | 95 |
+
+In high-contrast variants, the `darkLightness` window is bypassed. Auto uses pure inversion (`100 - L`), fixed uses identity (`L`). This allows HC colors to reach the full 0–100 range.
 
 ### Saturation
 
@@ -904,9 +911,10 @@ Resolution priority (highest first):
 
 ```ts
 glaze.configure({
-  lightLightness: [10, 100],   // Light scheme lightness window [lo, hi]
-  darkLightness: [15, 95],     // Dark scheme lightness window [lo, hi]
+  lightLightness: [10, 100],   // Light scheme lightness window [lo, hi] (bypassed in HC)
+  darkLightness: [15, 95],     // Dark scheme lightness window [lo, hi] (bypassed in HC)
   darkDesaturation: 0.1,       // Saturation reduction in dark scheme (0–1)
+  darkCurve: 0.5,              // Power-curve exponent for dark auto-inversion (0–1)
   states: {
     dark: '@dark',             // State alias for dark mode tokens
     highContrast: '@high-contrast',

package/dist/index.cjs

@@ -470,7 +470,7 @@ function formatOklch(h, s, l) {
 	const C = Math.sqrt(a * a + b * b);
 	let hh = Math.atan2(b, a) * (180 / Math.PI);
 	hh = constrainAngle(hh);
-	return `oklch(${fmt$1(L, 4)} ${fmt$1(C, 4)} ${fmt$1(hh, 1)})`;
+	return `oklch(${fmt$1(L, 4)} ${fmt$1(C, 4)} ${fmt$1(hh, 2)})`;
 }
 
 //#endregion
@@ -620,7 +620,7 @@ function coarseScan(h, s, lo, hi, yBase, target, epsilon, maxIter) {
 function findLightnessForContrast(options) {
 	const { hue, saturation, preferredLightness, baseLinearRgb, contrast: contrastInput, lightnessRange = [0, 1], epsilon = 1e-4, maxIterations = 14 } = options;
 	const target = resolveMinContrast(contrastInput);
-	const searchTarget = target * 1.005;
+	const searchTarget = target * 1.007;
 	const yBase = gamutClampedLuminance(baseLinearRgb);
 	const crPref = contrastRatioFromLuminance(cachedLuminance(hue, saturation, preferredLightness), yBase);
 	if (crPref >= searchTarget) return {
@@ -744,7 +744,7 @@ function searchMixBranch(lo, hi, yBase, target, epsilon, maxIter, preferred, lum
 function findValueForMixContrast(options) {
 	const { preferredValue, baseLinearRgb, contrast: contrastInput, luminanceAtValue, epsilon = 1e-4, maxIterations = 20 } = options;
 	const target = resolveMinContrast(contrastInput);
-	const searchTarget = target * 1.005;
+	const searchTarget = target * 1.01;
 	const yBase = gamutClampedLuminance(baseLinearRgb);
 	const crPref = contrastRatioFromLuminance(luminanceAtValue(preferredValue), yBase);
 	if (crPref >= searchTarget) return {
@@ -814,6 +814,7 @@ let globalConfig = {
 	lightLightness: [10, 100],
 	darkLightness: [15, 95],
 	darkDesaturation: .1,
+	darkCurve: .5,
 	states: {
 		dark: "@dark",
 		highContrast: "@high-contrast"
@@ -961,23 +962,26 @@ function topoSort(defs) {
 	for (const name of Object.keys(defs)) visit(name);
 	return result;
 }
-function mapLightnessLight(l, mode) {
-	if (mode === "static") return l;
+function mapLightnessLight(l, mode, isHighContrast) {
+	if (mode === "static" || isHighContrast) return l;
 	const [lo, hi] = globalConfig.lightLightness;
 	return l * (hi - lo) / 100 + lo;
 }
-function mapLightnessDark(l, mode) {
+function mapLightnessDark(l, mode, isHighContrast) {
 	if (mode === "static") return l;
-	const [lo, hi] = globalConfig.darkLightness;
-	if (mode === "fixed") return l * (hi - lo) / 100 + lo;
-	return (100 - l) * (hi - lo) / 100 + lo;
+	if (isHighContrast) return mode === "fixed" ? l : 100 - l;
+	const [darkLo, darkHi] = globalConfig.darkLightness;
+	if (mode === "fixed") return l * (darkHi - darkLo) / 100 + darkLo;
+	const [lightLo, lightHi] = globalConfig.lightLightness;
+	const t = (lightHi - (l * (lightHi - lightLo) / 100 + lightLo)) / (lightHi - lightLo);
+	return darkLo + (darkHi - darkLo) * Math.pow(t, globalConfig.darkCurve);
 }
 function mapSaturationDark(s, mode) {
 	if (mode === "static") return s;
 	return s * (1 - globalConfig.darkDesaturation);
 }
-function schemeLightnessRange(isDark, mode) {
-	if (mode === "static") return [0, 1];
+function schemeLightnessRange(isDark, mode, isHighContrast) {
+	if (mode === "static" || isHighContrast) return [0, 1];
 	const [lo, hi] = isDark ? globalConfig.darkLightness : globalConfig.lightLightness;
 	return [lo / 100, hi / 100];
 }
@@ -1040,23 +1044,23 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 			let delta = parsed.value;
 			if (isDark && mode === "auto") delta = -delta;
 			preferredL = clamp(baseL + delta, 0, 100);
-		} else if (isDark) preferredL = mapLightnessDark(parsed.value, mode);
-		else preferredL = mapLightnessLight(parsed.value, mode);
+		} else if (isDark) preferredL = mapLightnessDark(parsed.value, mode, isHighContrast);
+		else preferredL = mapLightnessLight(parsed.value, mode, isHighContrast);
 	}
 	const rawContrast = def.contrast;
 	if (rawContrast !== void 0) {
 		const minCr = isHighContrast ? pairHC(rawContrast) : pairNormal(rawContrast);
 		const effectiveSat = isDark ? mapSaturationDark(satFactor * ctx.saturation / 100, mode) : satFactor * ctx.saturation / 100;
 		const baseLinearRgb = okhslToLinearSrgb(baseVariant.h, baseVariant.s, baseVariant.l);
-		const lightnessRange = schemeLightnessRange(isDark, mode);
+		const windowRange = schemeLightnessRange(isDark, mode, isHighContrast);
 		return {
 			l: findLightnessForContrast({
 				hue: effectiveHue,
 				saturation: effectiveSat,
-				preferredLightness: clamp(preferredL / 100, lightnessRange[0], lightnessRange[1]),
+				preferredLightness: clamp(preferredL / 100, windowRange[0], windowRange[1]),
 				baseLinearRgb,
 				contrast: minCr,
-				lightnessRange
+				lightnessRange: [0, 1]
 			}).lightness * 100,
 			satFactor
 		};
@@ -1093,13 +1097,13 @@ function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
 	let finalL;
 	let finalSat;
 	if (isDark && isRoot) {
-		finalL = mapLightnessDark(lightL, mode);
+		finalL = mapLightnessDark(lightL, mode, isHighContrast);
 		finalSat = mapSaturationDark(satFactor * ctx.saturation / 100, mode);
 	} else if (isDark && !isRoot) {
 		finalL = lightL;
 		finalSat = mapSaturationDark(satFactor * ctx.saturation / 100, mode);
 	} else if (isRoot) {
-		finalL = mapLightnessLight(lightL, mode);
+		finalL = mapLightnessLight(lightL, mode, isHighContrast);
 		finalSat = satFactor * ctx.saturation / 100;
 	} else {
 		finalL = lightL;
@@ -1565,6 +1569,7 @@ glaze.configure = function configure(config) {
 		lightLightness: config.lightLightness ?? globalConfig.lightLightness,
 		darkLightness: config.darkLightness ?? globalConfig.darkLightness,
 		darkDesaturation: config.darkDesaturation ?? globalConfig.darkDesaturation,
+		darkCurve: config.darkCurve ?? globalConfig.darkCurve,
 		states: {
 			dark: config.states?.dark ?? globalConfig.states.dark,
 			highContrast: config.states?.highContrast ?? globalConfig.states.highContrast
@@ -1664,6 +1669,7 @@ glaze.resetConfig = function resetConfig() {
 		lightLightness: [10, 100],
 		darkLightness: [15, 95],
 		darkDesaturation: .1,
+		darkCurve: .5,
 		states: {
 			dark: "@dark",
 			highContrast: "@high-contrast"