@tenphi/glaze 0.0.0-snapshot.4c063ef → 0.0.0-snapshot.60e8979

package/dist/index.cjs

@@ -81,8 +81,8 @@ const OKLab_to_linear_sRGB_coefficients = [
 		.73956515,
 		-.45954404,
 		.08285427,
-		.12541073,
-		-.14503204
+		.1254107,
+		.14503204
 	]],
 	[[.13110757611180954, 1.813339709266608], [
 		1.35733652,
@@ -254,10 +254,9 @@ const getCs = (L, a, b, cusp) => {
 	];
 };
 /**
-* Convert OKHSL (h: 0–360, s: 0–1, l: 0–1) to linear sRGB.
-* Channels may exceed [0, 1] near gamut boundaries — caller must clamp if needed.
+* Convert OKHSL (h: 0–360, s: 0–1, l: 0–1) to OKLab [L, a, b].
 */
-function okhslToLinearSrgb(h, s, l) {
+function okhslToOklab(h, s, l) {
 	const L = toeInv(l);
 	let a = 0;
 	let b = 0;
@@ -284,11 +283,18 @@ function okhslToLinearSrgb(h, s, l) {
 		a = c * a_;
 		b = c * b_;
 	}
-	return OKLabToLinearSRGB([
+	return [
 		L,
 		a,
 		b
-	]);
+	];
+}
+/**
+* Convert OKHSL (h: 0–360, s: 0–1, l: 0–1) to linear sRGB.
+* Channels may exceed [0, 1] near gamut boundaries — caller must clamp if needed.
+*/
+function okhslToLinearSrgb(h, s, l) {
+	return OKLabToLinearSRGB(okhslToOklab(h, s, l));
 }
 /**
 * Compute relative luminance Y from linear sRGB channels.
@@ -327,40 +333,15 @@ function okhslToSrgb(h, s, l) {
 	];
 }
 /**
-* Convert OKHSL (h: 0–360, s: 0–1, l: 0–1) to OKLab [L, a, b].
+* Compute WCAG 2 relative luminance from linear sRGB, matching the browser
+* rendering pipeline: gamma-encode, clamp to sRGB gamut [0,1], then linearize.
+* This avoids over/under-estimating luminance for out-of-gamut OKHSL colors.
 */
-function okhslToOklab(h, s, l) {
-	const L = toeInv(l);
-	let a = 0;
-	let b = 0;
-	const hNorm = constrainAngle(h) / 360;
-	if (L !== 0 && L !== 1 && s !== 0) {
-		const a_ = Math.cos(TAU * hNorm);
-		const b_ = Math.sin(TAU * hNorm);
-		const [c0, cMid, cMax] = getCs(L, a_, b_, findCuspOKLCH(a_, b_));
-		const mid = .8;
-		const midInv = 1.25;
-		let t, k0, k1, k2;
-		if (s < mid) {
-			t = midInv * s;
-			k0 = 0;
-			k1 = mid * c0;
-			k2 = 1 - k1 / cMid;
-		} else {
-			t = 5 * (s - .8);
-			k0 = cMid;
-			k1 = .2 * cMid ** 2 * 1.25 ** 2 / c0;
-			k2 = 1 - k1 / (cMax - cMid);
-		}
-		const c = k0 + t * k1 / (1 - k2 * t);
-		a = c * a_;
-		b = c * b_;
-	}
-	return [
-		L,
-		a,
-		b
-	];
+function gamutClampedLuminance(linearRgb) {
+	const r = sRGBGammaToLinear(Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[0]))));
+	const g = sRGBGammaToLinear(Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[1]))));
+	const b = sRGBGammaToLinear(Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[2]))));
+	return .2126 * r + .7152 * g + .0722 * b;
 }
 const linearSrgbToOklab = (rgb) => {
 	return transform(cbrt3(transform(rgb, linear_sRGB_to_LMS_M)), LMS_to_OKLab_M);
@@ -449,15 +430,16 @@ function fmt$1(value, decimals) {
 * h: 0–360, s: 0–100, l: 0–100 (percentage scale for s and l).
 */
 function formatOkhsl(h, s, l) {
-	return `okhsl(${fmt$1(h, 1)} ${fmt$1(s, 1)}% ${fmt$1(l, 1)}%)`;
+	return `okhsl(${fmt$1(h, 2)} ${fmt$1(s, 2)}% ${fmt$1(l, 2)}%)`;
 }
 /**
-* Format OKHSL values as a CSS `rgb(R G B)` string with rounded integer values.
+* Format OKHSL values as a CSS `rgb(R G B)` string.
+* Uses 2 decimal places to avoid 8-bit quantization contrast loss.
 * h: 0–360, s: 0–100, l: 0–100 (percentage scale for s and l).
 */
 function formatRgb(h, s, l) {
 	const [r, g, b] = okhslToSrgb(h, s / 100, l / 100);
-	return `rgb(${Math.round(r * 255)} ${Math.round(g * 255)} ${Math.round(b * 255)})`;
+	return `rgb(${parseFloat((r * 255).toFixed(2))} ${parseFloat((g * 255).toFixed(2))} ${parseFloat((b * 255).toFixed(2))})`;
 }
 /**
 * Format OKHSL values as a CSS `hsl(H S% L%)` string.
@@ -477,7 +459,7 @@ function formatHsl(h, s, l) {
 		else if (max === g) hh = ((b - r) / delta + 2) * 60;
 		else hh = ((r - g) / delta + 4) * 60;
 	}
-	return `hsl(${fmt$1(hh, 1)} ${fmt$1(ss * 100, 1)}% ${fmt$1(ll * 100, 1)}%)`;
+	return `hsl(${fmt$1(hh, 2)} ${fmt$1(ss * 100, 2)}% ${fmt$1(ll * 100, 2)}%)`;
 }
 /**
 * Format OKHSL values as a CSS `oklch(L C H)` string.
@@ -488,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
@@ -518,7 +500,7 @@ function cachedLuminance(h, s, l) {
 	const key = `${h}|${s}|${lRounded}`;
 	const cached = luminanceCache.get(key);
 	if (cached !== void 0) return cached;
-	const y = relativeLuminanceFromLinearRgb(okhslToLinearSrgb(h, s, lRounded));
+	const y = gamutClampedLuminance(okhslToLinearSrgb(h, s, lRounded));
 	if (luminanceCache.size >= CACHE_SIZE) {
 		const evict = cacheOrder.shift();
 		luminanceCache.delete(evict);
@@ -638,17 +620,20 @@ 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 yBase = relativeLuminanceFromLinearRgb(baseLinearRgb);
+	const searchTarget = target * 1.007;
+	const yBase = gamutClampedLuminance(baseLinearRgb);
 	const crPref = contrastRatioFromLuminance(cachedLuminance(hue, saturation, preferredLightness), yBase);
-	if (crPref >= target) return {
+	if (crPref >= searchTarget) return {
 		lightness: preferredLightness,
 		contrast: crPref,
 		met: true,
 		branch: "preferred"
 	};
 	const [minL, maxL] = lightnessRange;
-	const darkerResult = preferredLightness > minL ? searchBranch(hue, saturation, minL, preferredLightness, yBase, target, epsilon, maxIterations, preferredLightness) : null;
-	const lighterResult = preferredLightness < maxL ? searchBranch(hue, saturation, preferredLightness, maxL, yBase, target, epsilon, maxIterations, preferredLightness) : null;
+	const darkerResult = preferredLightness > minL ? searchBranch(hue, saturation, minL, preferredLightness, yBase, searchTarget, epsilon, maxIterations, preferredLightness) : null;
+	const lighterResult = preferredLightness < maxL ? searchBranch(hue, saturation, preferredLightness, maxL, yBase, searchTarget, epsilon, maxIterations, preferredLightness) : null;
+	if (darkerResult) darkerResult.met = darkerResult.contrast >= target;
+	if (lighterResult) lighterResult.met = lighterResult.contrast >= target;
 	const darkerPasses = darkerResult?.met ?? false;
 	const lighterPasses = lighterResult?.met ?? false;
 	if (darkerPasses && lighterPasses) {
@@ -687,6 +672,135 @@ function findLightnessForContrast(options) {
 	candidates.sort((a, b) => b.contrast - a.contrast);
 	return candidates[0];
 }
+/**
+* Binary-search one branch [lo, hi] for the nearest passing mix value
+* to `preferred`.
+*/
+function searchMixBranch(lo, hi, yBase, target, epsilon, maxIter, preferred, luminanceAt) {
+	const crLo = contrastRatioFromLuminance(luminanceAt(lo), yBase);
+	const crHi = contrastRatioFromLuminance(luminanceAt(hi), yBase);
+	if (crLo < target && crHi < target) {
+		if (crLo >= crHi) return {
+			lightness: lo,
+			contrast: crLo,
+			met: false
+		};
+		return {
+			lightness: hi,
+			contrast: crHi,
+			met: false
+		};
+	}
+	let low = lo;
+	let high = hi;
+	for (let i = 0; i < maxIter; i++) {
+		if (high - low < epsilon) break;
+		const mid = (low + high) / 2;
+		if (contrastRatioFromLuminance(luminanceAt(mid), yBase) >= target) if (mid < preferred) low = mid;
+		else high = mid;
+		else if (mid < preferred) high = mid;
+		else low = mid;
+	}
+	const crLow = contrastRatioFromLuminance(luminanceAt(low), yBase);
+	const crHigh = contrastRatioFromLuminance(luminanceAt(high), yBase);
+	const lowPasses = crLow >= target;
+	const highPasses = crHigh >= target;
+	if (lowPasses && highPasses) {
+		if (Math.abs(low - preferred) <= Math.abs(high - preferred)) return {
+			lightness: low,
+			contrast: crLow,
+			met: true
+		};
+		return {
+			lightness: high,
+			contrast: crHigh,
+			met: true
+		};
+	}
+	if (lowPasses) return {
+		lightness: low,
+		contrast: crLow,
+		met: true
+	};
+	if (highPasses) return {
+		lightness: high,
+		contrast: crHigh,
+		met: true
+	};
+	return crLow >= crHigh ? {
+		lightness: low,
+		contrast: crLow,
+		met: false
+	} : {
+		lightness: high,
+		contrast: crHigh,
+		met: false
+	};
+}
+/**
+* Find the mix parameter (ratio or opacity) that satisfies a WCAG 2 contrast
+* target against a base color, staying as close to `preferredValue` as possible.
+*/
+function findValueForMixContrast(options) {
+	const { preferredValue, baseLinearRgb, contrast: contrastInput, luminanceAtValue, epsilon = 1e-4, maxIterations = 20 } = options;
+	const target = resolveMinContrast(contrastInput);
+	const searchTarget = target * 1.01;
+	const yBase = gamutClampedLuminance(baseLinearRgb);
+	const crPref = contrastRatioFromLuminance(luminanceAtValue(preferredValue), yBase);
+	if (crPref >= searchTarget) return {
+		value: preferredValue,
+		contrast: crPref,
+		met: true
+	};
+	const darkerResult = preferredValue > 0 ? searchMixBranch(0, preferredValue, yBase, searchTarget, epsilon, maxIterations, preferredValue, luminanceAtValue) : null;
+	const lighterResult = preferredValue < 1 ? searchMixBranch(preferredValue, 1, yBase, searchTarget, epsilon, maxIterations, preferredValue, luminanceAtValue) : null;
+	if (darkerResult) darkerResult.met = darkerResult.contrast >= target;
+	if (lighterResult) lighterResult.met = lighterResult.contrast >= target;
+	const darkerPasses = darkerResult?.met ?? false;
+	const lighterPasses = lighterResult?.met ?? false;
+	if (darkerPasses && lighterPasses) {
+		if (Math.abs(darkerResult.lightness - preferredValue) <= Math.abs(lighterResult.lightness - preferredValue)) return {
+			value: darkerResult.lightness,
+			contrast: darkerResult.contrast,
+			met: true
+		};
+		return {
+			value: lighterResult.lightness,
+			contrast: lighterResult.contrast,
+			met: true
+		};
+	}
+	if (darkerPasses) return {
+		value: darkerResult.lightness,
+		contrast: darkerResult.contrast,
+		met: true
+	};
+	if (lighterPasses) return {
+		value: lighterResult.lightness,
+		contrast: lighterResult.contrast,
+		met: true
+	};
+	const candidates = [];
+	if (darkerResult) candidates.push({
+		...darkerResult,
+		branch: "lower"
+	});
+	if (lighterResult) candidates.push({
+		...lighterResult,
+		branch: "upper"
+	});
+	if (candidates.length === 0) return {
+		value: preferredValue,
+		contrast: crPref,
+		met: false
+	};
+	candidates.sort((a, b) => b.contrast - a.contrast);
+	return {
+		value: candidates[0].lightness,
+		contrast: candidates[0].contrast,
+		met: candidates[0].met
+	};
+}
 
 //#endregion
 //#region src/glaze.ts
@@ -700,6 +814,7 @@ let globalConfig = {
 	lightLightness: [10, 100],
 	darkLightness: [15, 95],
 	darkDesaturation: .1,
+	darkCurve: .5,
 	states: {
 		dark: "@dark",
 		highContrast: "@high-contrast"
@@ -718,6 +833,9 @@ function pairHC(p) {
 function isShadowDef(def) {
 	return def.type === "shadow";
 }
+function isMixDef(def) {
+	return def.type === "mix";
+}
 const DEFAULT_SHADOW_TUNING = {
 	saturationFactor: .18,
 	maxSaturation: .25,
@@ -785,10 +903,16 @@ function validateColorDefs(defs) {
 			}
 			continue;
 		}
+		if (isMixDef(def)) {
+			if (!names.has(def.base)) throw new Error(`glaze: mix "${name}" references non-existent base "${def.base}".`);
+			if (!names.has(def.target)) throw new Error(`glaze: mix "${name}" references non-existent target "${def.target}".`);
+			if (isShadowDef(defs[def.base])) throw new Error(`glaze: mix "${name}" base "${def.base}" references a shadow color.`);
+			if (isShadowDef(defs[def.target])) throw new Error(`glaze: mix "${name}" target "${def.target}" references a shadow color.`);
+			continue;
+		}
 		const regDef = def;
 		if (regDef.contrast !== void 0 && !regDef.base) throw new Error(`glaze: color "${name}" has "contrast" without "base".`);
 		if (regDef.lightness !== void 0 && !isAbsoluteLightness(regDef.lightness) && !regDef.base) throw new Error(`glaze: color "${name}" has relative "lightness" without "base".`);
-		if (isAbsoluteLightness(regDef.lightness) && regDef.base !== void 0) console.warn(`glaze: color "${name}" has absolute "lightness" and "base". Absolute lightness takes precedence.`);
 		if (regDef.base && !names.has(regDef.base)) throw new Error(`glaze: color "${name}" references non-existent base "${regDef.base}".`);
 		if (regDef.base && isShadowDef(defs[regDef.base])) throw new Error(`glaze: color "${name}" base "${regDef.base}" references a shadow color.`);
 		if (!isAbsoluteLightness(regDef.lightness) && regDef.base === void 0) throw new Error(`glaze: color "${name}" must have either absolute "lightness" (root) or "base" (dependent).`);
@@ -804,6 +928,9 @@ function validateColorDefs(defs) {
 		if (isShadowDef(def)) {
 			dfs(def.bg);
 			if (def.fg) dfs(def.fg);
+		} else if (isMixDef(def)) {
+			dfs(def.base);
+			dfs(def.target);
 		} else {
 			const regDef = def;
 			if (regDef.base) dfs(regDef.base);
@@ -823,6 +950,9 @@ function topoSort(defs) {
 		if (isShadowDef(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);
@@ -832,21 +962,44 @@ function topoSort(defs) {
 	for (const name of Object.keys(defs)) visit(name);
 	return result;
 }
-function mapLightnessLight(l, mode) {
+function lightnessWindow(isHighContrast, kind) {
+	if (isHighContrast) return [0, 100];
+	return kind === "dark" ? globalConfig.darkLightness : globalConfig.lightLightness;
+}
+function mapLightnessLight(l, mode, isHighContrast) {
 	if (mode === "static") return l;
-	const [lo, hi] = globalConfig.lightLightness;
+	const [lo, hi] = lightnessWindow(isHighContrast, "light");
 	return l * (hi - lo) / 100 + lo;
 }
-function mapLightnessDark(l, mode) {
+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 [lo, hi] = globalConfig.darkLightness;
-	if (mode === "fixed") return l * (hi - lo) / 100 + lo;
-	return (100 - l) * (hi - lo) / 100 + lo;
+	const beta = isHighContrast ? pairHC(globalConfig.darkCurve) : pairNormal(globalConfig.darkCurve);
+	const [darkLo, darkHi] = lightnessWindow(isHighContrast, "dark");
+	if (mode === "fixed") return l * (darkHi - darkLo) / 100 + darkLo;
+	const [lightLo, lightHi] = lightnessWindow(isHighContrast, "light");
+	const t = (lightHi - (l * (lightHi - lightLo) / 100 + lightLo)) / (lightHi - lightLo);
+	return darkLo + (darkHi - darkLo) * mobiusCurve(t, beta);
+}
+function lightMappedToDark(lightL, isHighContrast) {
+	const beta = isHighContrast ? pairHC(globalConfig.darkCurve) : pairNormal(globalConfig.darkCurve);
+	const [lightLo, lightHi] = lightnessWindow(isHighContrast, "light");
+	const [darkLo, darkHi] = lightnessWindow(isHighContrast, "dark");
+	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;
 	return s * (1 - globalConfig.darkDesaturation);
 }
+function schemeLightnessRange(isDark, mode, isHighContrast) {
+	if (mode === "static") return [0, 1];
+	const [lo, hi] = lightnessWindow(isHighContrast, isDark ? "dark" : "light");
+	return [lo / 100, hi / 100];
+}
 function clamp(v, min, max) {
 	return Math.max(min, Math.min(max, v));
 }
@@ -903,24 +1056,26 @@ 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);
-		} else if (isDark) preferredL = mapLightnessDark(parsed.value, mode);
-		else preferredL = clamp(parsed.value, 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);
 	}
 	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 windowRange = schemeLightnessRange(isDark, mode, isHighContrast);
 		return {
 			l: findLightnessForContrast({
 				hue: effectiveHue,
 				saturation: effectiveSat,
-				preferredLightness: preferredL / 100,
+				preferredLightness: clamp(preferredL / 100, windowRange[0], windowRange[1]),
 				baseLinearRgb,
-				contrast: minCr
+				contrast: minCr,
+				lightnessRange: [0, 1]
 			}).lightness * 100,
 			satFactor
 		};
@@ -938,6 +1093,7 @@ function getSchemeVariant(color, isDark, isHighContrast) {
 }
 function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
 	if (isShadowDef(def)) return resolveShadowForScheme(def, ctx, isDark, isHighContrast);
+	if (isMixDef(def)) return resolveMixForScheme(def, ctx, isDark, isHighContrast);
 	const regDef = def;
 	const mode = regDef.mode ?? "auto";
 	const isRoot = isAbsoluteLightness(regDef.lightness) && !regDef.base;
@@ -956,13 +1112,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;
@@ -983,6 +1139,83 @@ function resolveShadowForScheme(def, ctx, isDark, isHighContrast) {
 	const tuning = resolveShadowTuning(def.tuning);
 	return computeShadow(bgVariant, fgVariant, intensity, tuning);
 }
+function variantToLinearRgb(v) {
+	return okhslToLinearSrgb(v.h, v.s, v.l);
+}
+/**
+* Resolve hue for OKHSL mixing, handling achromatic colors.
+* When one color has no saturation, its hue is meaningless —
+* use the hue from the color that has saturation (matches CSS
+* color-mix "missing component" behavior).
+*/
+function mixHue(base, target, t) {
+	const SAT_EPSILON = 1e-6;
+	const baseHasSat = base.s > SAT_EPSILON;
+	const targetHasSat = target.s > SAT_EPSILON;
+	if (baseHasSat && targetHasSat) return circularLerp(base.h, target.h, t);
+	if (targetHasSat) return target.h;
+	return base.h;
+}
+function linearSrgbLerp(base, target, t) {
+	return [
+		base[0] + (target[0] - base[0]) * t,
+		base[1] + (target[1] - base[1]) * t,
+		base[2] + (target[2] - base[2]) * t
+	];
+}
+function linearRgbToVariant(rgb) {
+	const [h, s, l] = srgbToOkhsl([
+		Math.max(0, Math.min(1, sRGBLinearToGamma(rgb[0]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(rgb[1]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(rgb[2])))
+	]);
+	return {
+		h,
+		s,
+		l,
+		alpha: 1
+	};
+}
+function resolveMixForScheme(def, ctx, isDark, isHighContrast) {
+	const baseResolved = ctx.resolved.get(def.base);
+	const targetResolved = ctx.resolved.get(def.target);
+	const baseVariant = getSchemeVariant(baseResolved, isDark, isHighContrast);
+	const targetVariant = getSchemeVariant(targetResolved, isDark, isHighContrast);
+	let t = clamp(isHighContrast ? pairHC(def.value) : pairNormal(def.value), 0, 100) / 100;
+	const blend = def.blend ?? "opaque";
+	const space = def.space ?? "okhsl";
+	const baseLinear = variantToLinearRgb(baseVariant);
+	const targetLinear = variantToLinearRgb(targetVariant);
+	if (def.contrast !== void 0) {
+		const minCr = isHighContrast ? pairHC(def.contrast) : pairNormal(def.contrast);
+		let luminanceAt;
+		if (blend === "transparent") luminanceAt = (v) => gamutClampedLuminance(linearSrgbLerp(baseLinear, targetLinear, v));
+		else if (space === "srgb") luminanceAt = (v) => gamutClampedLuminance(linearSrgbLerp(baseLinear, targetLinear, v));
+		else luminanceAt = (v) => {
+			return gamutClampedLuminance(okhslToLinearSrgb(mixHue(baseVariant, targetVariant, v), baseVariant.s + (targetVariant.s - baseVariant.s) * v, baseVariant.l + (targetVariant.l - baseVariant.l) * v));
+		};
+		t = findValueForMixContrast({
+			preferredValue: t,
+			baseLinearRgb: baseLinear,
+			targetLinearRgb: targetLinear,
+			contrast: minCr,
+			luminanceAtValue: luminanceAt
+		}).value;
+	}
+	if (blend === "transparent") return {
+		h: targetVariant.h,
+		s: targetVariant.s,
+		l: targetVariant.l,
+		alpha: clamp(t, 0, 1)
+	};
+	if (space === "srgb") return linearRgbToVariant(linearSrgbLerp(baseLinear, targetLinear, t));
+	return {
+		h: mixHue(baseVariant, targetVariant, t),
+		s: clamp(baseVariant.s + (targetVariant.s - baseVariant.s) * t, 0, 1),
+		l: clamp(baseVariant.l + (targetVariant.l - baseVariant.l) * t, 0, 1),
+		alpha: 1
+	};
+}
 function resolveAllColors(hue, saturation, defs) {
 	validateColorDefs(defs);
 	const order = topoSort(defs);
@@ -993,7 +1226,8 @@ function resolveAllColors(hue, saturation, defs) {
 		resolved: /* @__PURE__ */ new Map()
 	};
 	function defMode(def) {
-		return isShadowDef(def) ? void 0 : def.mode ?? "auto";
+		if (isShadowDef(def) || isMixDef(def)) return void 0;
+		return def.mode ?? "auto";
 	}
 	const lightMap = /* @__PURE__ */ new Map();
 	for (const name of order) {
@@ -1206,35 +1440,88 @@ function createTheme(hue, saturation, initialColors) {
 		}
 	};
 }
-function resolvePrefix(options, themeName) {
-	if (options?.prefix === true) return `${themeName}-`;
-	if (typeof options?.prefix === "object" && options.prefix !== null) return options.prefix[themeName] ?? `${themeName}-`;
+function resolvePrefix(options, themeName, defaultPrefix = false) {
+	const prefix = options?.prefix ?? defaultPrefix;
+	if (prefix === true) return `${themeName}-`;
+	if (typeof prefix === "object" && prefix !== null) return prefix[themeName] ?? `${themeName}-`;
 	return "";
 }
-function createPalette(themes) {
+function validatePrimaryTheme(primary, themes) {
+	if (primary !== void 0 && !(primary in themes)) {
+		const available = Object.keys(themes).join(", ");
+		throw new Error(`glaze: primary theme "${primary}" not found in palette. Available: ${available}.`);
+	}
+}
+/**
+* Resolve the effective primary for an export call.
+* `false` disables, a string overrides, `undefined` inherits from palette.
+*/
+function resolveEffectivePrimary(exportPrimary, palettePrimary) {
+	if (exportPrimary === false) return void 0;
+	return exportPrimary ?? palettePrimary;
+}
+/**
+* Filter a resolved color map, skipping keys already in `seen`.
+* Warns on collision and keeps the first-written value (first-write-wins).
+* Returns a new map containing only non-colliding entries.
+*/
+function filterCollisions(resolved, prefix, seen, themeName, isPrimary) {
+	const filtered = /* @__PURE__ */ new Map();
+	const label = isPrimary ? `${themeName} (primary)` : themeName;
+	for (const [name, color] of resolved) {
+		const key = `${prefix}${name}`;
+		if (seen.has(key)) {
+			console.warn(`glaze: token "${key}" from theme "${label}" collides with theme "${seen.get(key)}" — skipping.`);
+			continue;
+		}
+		seen.set(key, label);
+		filtered.set(name, color);
+	}
+	return filtered;
+}
+function createPalette(themes, paletteOptions) {
+	validatePrimaryTheme(paletteOptions?.primary, themes);
 	return {
 		tokens(options) {
+			const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+			if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
 			const modes = resolveModes(options?.modes);
 			const allTokens = {};
+			const seen = /* @__PURE__ */ new Map();
 			for (const [themeName, theme] of Object.entries(themes)) {
-				const tokens = buildFlatTokenMap(theme.resolve(), resolvePrefix(options, themeName), modes, options?.format);
+				const resolved = theme.resolve();
+				const prefix = resolvePrefix(options, themeName, true);
+				const tokens = buildFlatTokenMap(filterCollisions(resolved, prefix, seen, themeName), prefix, modes, options?.format);
 				for (const variant of Object.keys(tokens)) {
 					if (!allTokens[variant]) allTokens[variant] = {};
 					Object.assign(allTokens[variant], tokens[variant]);
 				}
+				if (themeName === effectivePrimary) {
+					const unprefixed = buildFlatTokenMap(filterCollisions(resolved, "", seen, themeName, true), "", modes, options?.format);
+					for (const variant of Object.keys(unprefixed)) Object.assign(allTokens[variant], unprefixed[variant]);
+				}
 			}
 			return allTokens;
 		},
 		tasty(options) {
+			const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+			if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
 			const states = {
 				dark: options?.states?.dark ?? globalConfig.states.dark,
 				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
 			};
 			const modes = resolveModes(options?.modes);
 			const allTokens = {};
+			const seen = /* @__PURE__ */ new Map();
 			for (const [themeName, theme] of Object.entries(themes)) {
-				const tokens = buildTokenMap(theme.resolve(), resolvePrefix(options, themeName), states, modes, options?.format);
+				const resolved = theme.resolve();
+				const prefix = resolvePrefix(options, themeName, true);
+				const tokens = buildTokenMap(filterCollisions(resolved, prefix, seen, themeName), prefix, states, modes, options?.format);
 				Object.assign(allTokens, tokens);
+				if (themeName === effectivePrimary) {
+					const unprefixed = buildTokenMap(filterCollisions(resolved, "", seen, themeName, true), "", states, modes, options?.format);
+					Object.assign(allTokens, unprefixed);
+				}
 			}
 			return allTokens;
 		},
@@ -1245,6 +1532,8 @@ function createPalette(themes) {
 			return result;
 		},
 		css(options) {
+			const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+			if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
 			const suffix = options?.suffix ?? "-color";
 			const format = options?.format ?? "rgb";
 			const allLines = {
@@ -1253,14 +1542,26 @@ function createPalette(themes) {
 				lightContrast: [],
 				darkContrast: []
 			};
+			const seen = /* @__PURE__ */ new Map();
 			for (const [themeName, theme] of Object.entries(themes)) {
-				const css = buildCssMap(theme.resolve(), resolvePrefix(options, themeName), suffix, format);
+				const resolved = theme.resolve();
+				const prefix = resolvePrefix(options, themeName, true);
+				const css = buildCssMap(filterCollisions(resolved, prefix, seen, themeName), prefix, suffix, format);
 				for (const key of [
 					"light",
 					"dark",
 					"lightContrast",
 					"darkContrast"
 				]) if (css[key]) allLines[key].push(css[key]);
+				if (themeName === effectivePrimary) {
+					const unprefixed = buildCssMap(filterCollisions(resolved, "", seen, themeName, true), "", suffix, format);
+					for (const key of [
+						"light",
+						"dark",
+						"lightContrast",
+						"darkContrast"
+					]) if (unprefixed[key]) allLines[key].push(unprefixed[key]);
+				}
 			}
 			return {
 				light: allLines.light.join("\n"),
@@ -1320,6 +1621,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
@@ -1334,8 +1636,8 @@ glaze.configure = function configure(config) {
 /**
 * Compose multiple themes into a palette.
 */
-glaze.palette = function palette(themes) {
-	return createPalette(themes);
+glaze.palette = function palette(themes, options) {
+	return createPalette(themes, options);
 };
 /**
 * Create a theme from a serialized export.
@@ -1419,6 +1721,7 @@ glaze.resetConfig = function resetConfig() {
 		lightLightness: [10, 100],
 		darkLightness: [15, 95],
 		darkDesaturation: .1,
+		darkCurve: .5,
 		states: {
 			dark: "@dark",
 			highContrast: "@high-contrast"
@@ -1433,10 +1736,12 @@ glaze.resetConfig = function resetConfig() {
 //#endregion
 exports.contrastRatioFromLuminance = contrastRatioFromLuminance;
 exports.findLightnessForContrast = findLightnessForContrast;
+exports.findValueForMixContrast = findValueForMixContrast;
 exports.formatHsl = formatHsl;
 exports.formatOkhsl = formatOkhsl;
 exports.formatOklch = formatOklch;
 exports.formatRgb = formatRgb;
+exports.gamutClampedLuminance = gamutClampedLuminance;
 exports.glaze = glaze;
 exports.okhslToLinearSrgb = okhslToLinearSrgb;
 exports.okhslToOklab = okhslToOklab;