@tenphi/glaze 0.0.0-snapshot.7e2a1da → 0.0.0-snapshot.881871d

package/README.md

@@ -603,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≈29 (power curve), sign flips → L=29+52=81
+// Dark:  surface inverts to L≈20 (Möbius curve), sign flips → L=20+52=72
 //        contrast solver may push further (light text on dark bg)
 ```
 
@@ -639,15 +639,15 @@ Both `auto` and `fixed` modes use the same linear formula. `static` mode and hig
 
 ### Lightness
 
-**`auto`** — inverted with a power curve within the configured window:
+**`auto`** — inverted with a Möbius transformation within the configured window:
 
 ```ts
 const [lo, hi] = darkLightness; // default: [15, 95]
-const d = (100 - lightness) / 100;
-const invertedL = lo + (hi - lo) * Math.pow(d, darkCurve); // darkCurve default: 0.5
+const t = (100 - lightness) / 100;
+const invertedL = lo + (hi - lo) * t / (t + darkCurve * (1 - t)); // darkCurve default: 0.5
 ```
 
-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.
+The `darkCurve` parameter (default `0.5`, range 0–1) controls how much the dark-mode inversion expands lightness deltas. Lower values produce stronger expansion; `1` gives linear (legacy) behavior. Unlike a power curve, the Möbius transformation provides **proportional expansion** — small and large deltas are scaled by similar ratios, preserving the visual hierarchy of the light theme.
 
 **`fixed`** — mapped without inversion (not affected by `darkCurve`):
 
@@ -657,11 +657,11 @@ const mappedL = (lightness * (hi - lo)) / 100 + lo;
 
 | 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 |
+| surface (L=97) | 97 | 19.7 | 17.4 | 92.6 |
+| accent-fill (L=52) | 52 | 66.9 | 53.4 | 56.6 |
 | accent-text (L=100) | 100 | 15 | 15 | 95 |
 
-In high-contrast variants, the `darkLightness` window is bypassed. Auto uses pure inversion (`100 - L`), fixed uses identity (`L`). This allows HC colors to reach the full 0–100 range.
+In high-contrast variants, the `darkLightness` window is bypassed. Auto uses the same Möbius curve over the full [0, 100] range. Fixed uses identity (`L`). This allows HC colors to reach the full 0–100 range.
 
 ### Saturation
 
@@ -914,7 +914,7 @@ glaze.configure({
   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)
+  darkCurve: 0.5,              // Möbius beta for dark auto-inversion (0–1, lower = more expansion)
   states: {
     dark: '@dark',             // State alias for dark mode tokens
     highContrast: '@high-contrast',

package/dist/index.cjs

@@ -967,18 +967,30 @@ function mapLightnessLight(l, mode, isHighContrast) {
 	const [lo, hi] = globalConfig.lightLightness;
 	return l * (hi - lo) / 100 + lo;
 }
+function mobiusCurve(t, beta) {
+	if (beta >= 1) return t;
+	return t / (t + beta * (1 - t));
+}
 function mapLightnessDark(l, mode, isHighContrast) {
 	if (mode === "static") return l;
+	const beta = globalConfig.darkCurve;
 	if (isHighContrast) {
 		if (mode === "fixed") return l;
-		const t = (100 - l) / 100;
-		return 100 * Math.pow(t, globalConfig.darkCurve);
+		return 100 * mobiusCurve((100 - l) / 100, beta);
 	}
 	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);
+	return darkLo + (darkHi - darkLo) * mobiusCurve(t, beta);
+}
+function lightMappedToDark(lightL, isHighContrast) {
+	const beta = globalConfig.darkCurve;
+	if (isHighContrast) return 100 * mobiusCurve((100 - lightL) / 100, beta);
+	const [lightLo, lightHi] = globalConfig.lightLightness;
+	const [darkLo, darkHi] = globalConfig.darkLightness;
+	const t = (lightHi - clamp(lightL, lightLo, lightHi)) / (lightHi - lightLo);
+	return darkLo + (darkHi - darkLo) * mobiusCurve(t, beta);
 }
 function mapSaturationDark(s, mode) {
 	if (mode === "static") return s;
@@ -1045,9 +1057,9 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 	else {
 		const parsed = parseRelativeOrAbsolute(isHighContrast ? pairHC(rawLightness) : pairNormal(rawLightness));
 		if (parsed.relative) {
-			let delta = parsed.value;
-			if (isDark && mode === "auto") delta = -delta;
-			preferredL = clamp(baseL + delta, 0, 100);
+			const delta = parsed.value;
+			if (isDark && mode === "auto") preferredL = lightMappedToDark(clamp(getSchemeVariant(baseResolved, false, isHighContrast).l * 100 + delta, 0, 100), isHighContrast);
+			else preferredL = clamp(baseL + delta, 0, 100);
 		} else if (isDark) preferredL = mapLightnessDark(parsed.value, mode, isHighContrast);
 		else preferredL = mapLightnessLight(parsed.value, mode, isHighContrast);
 	}