@tenphi/glaze 0.0.0-snapshot.4c063ef → 0.0.0-snapshot.4e8eab7

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,44 +333,24 @@ 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);
 };
+/**
+* Convert OKLab to OKHSL.
+* Input: [L, a, b] where L: 0–1, a/b: roughly -0.5 to 0.5.
+* Returns [h, s, l] where h: 0–360, s: 0–1, l: 0–1.
+*/
 const oklabToOkhsl = (lab) => {
 	const L = lab[0];
 	const a = lab[1];
@@ -375,6 +361,12 @@ const oklabToOkhsl = (lab) => {
 		0,
 		toe(L)
 	];
+	const L_EXTREME_EPSILON = 1e-6;
+	if (L >= 1 - L_EXTREME_EPSILON || L <= L_EXTREME_EPSILON) return [
+		0,
+		0,
+		toe(L)
+	];
 	const a_ = a / C;
 	const b_ = b / C;
 	let h = Math.atan2(b, a) * (180 / Math.PI);
@@ -412,32 +404,108 @@ function srgbToOkhsl(rgb) {
 	]));
 }
 /**
+* Convert CSS HSL (sRGB-based) to gamma-encoded sRGB [r, g, b] in 0–1 range.
+* h: 0–360, s: 0–1, l: 0–1.
+*
+* Note: CSS HSL is not the same as OKHSL — it's HSL in the sRGB color space.
+* Use this when parsing `hsl(...)` strings before passing to `srgbToOkhsl`.
+*/
+function hslToSrgb(h, s, l) {
+	const hh = (h % 360 + 360) % 360 / 360;
+	const ss = clampVal(s, 0, 1);
+	const ll = clampVal(l, 0, 1);
+	if (ss === 0) return [
+		ll,
+		ll,
+		ll
+	];
+	const q = ll < .5 ? ll * (1 + ss) : ll + ss - ll * ss;
+	const p = 2 * ll - q;
+	const hueToChannel = (t) => {
+		let tt = t;
+		if (tt < 0) tt += 1;
+		if (tt > 1) tt -= 1;
+		if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+		if (tt < 1 / 2) return q;
+		if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+		return p;
+	};
+	return [
+		hueToChannel(hh + 1 / 3),
+		hueToChannel(hh),
+		hueToChannel(hh - 1 / 3)
+	];
+}
+/**
 * 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.
+*
+* For 8-digit hex (`#rrggbbaa`) and 4-digit hex (`#rgba`) with alpha,
+* use {@link parseHexAlpha}.
 */
 function parseHex(hex) {
+	const result = parseHexAlpha(hex);
+	if (!result || result.alpha !== void 0) return null;
+	return result.rgb;
+}
+/**
+* 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.
+*/
+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 [
+		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 [
+		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;
 }
@@ -449,15 +517,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 +546,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 +557,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 +587,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 +707,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.01;
+	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 +759,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
@@ -696,10 +897,59 @@ function findLightnessForContrast(options) {
 * Generates robust light, dark, and high-contrast colors from a hue/saturation
 * seed, preserving contrast for UI pairs via explicit dependencies.
 */
+/** Internal name of the user-facing standalone color in the synthesized def map. */
+const STANDALONE_VALUE = "value";
+/** Internal name of the hidden static-anchor seed used for relative lightness / contrast. */
+const STANDALONE_SEED = "seed";
+/** Internal name of an externally-resolved `GlazeColorToken` injected as a base reference. */
+const STANDALONE_BASE = "externalBase";
+/**
+* Build the create-time scaling snapshot used when the caller did not
+* pass an explicit `scaling`. All windows are snapshotted from the
+* current `globalConfig` so later `glaze.configure()` calls don't
+* retroactively change the resolved variants of an already-created
+* token (matches the documented "frozen at create time" semantics).
+*
+* String value-shorthand inputs preserve their light lightness exactly
+* (`lightLightness: false`) and use an extended dark window
+* `[globalConfig.darkLightness[0], 100]` so a totally-black input can
+* Möbius-invert to totally-white in dark mode. Object / tuple /
+* structured inputs snapshot both windows from `globalConfig` verbatim
+* so they behave like an ordinary theme color (auto-adapted on both
+* sides).
+*/
+function defaultStandaloneScaling(isString) {
+	if (isString) {
+		const [darkLo] = globalConfig.darkLightness;
+		return {
+			lightLightness: false,
+			darkLightness: [darkLo, 100]
+		};
+	}
+	return {
+		lightLightness: globalConfig.lightLightness,
+		darkLightness: globalConfig.darkLightness
+	};
+}
+/** Reserved internal names that user-supplied `name` must not collide with. */
+const RESERVED_STANDALONE_NAMES = new Set([
+	STANDALONE_VALUE,
+	STANDALONE_SEED,
+	STANDALONE_BASE
+]);
+/**
+* Discriminate a `GlazeColorToken` from a raw `GlazeColorValue`.
+* Used to widen `base?` so it accepts either a token reference or a
+* raw value (auto-wrapped into `glaze.color(value)`).
+*/
+function isGlazeColorToken(candidate) {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && "resolve" in candidate && typeof candidate.resolve === "function";
+}
 let globalConfig = {
 	lightLightness: [10, 100],
 	darkLightness: [15, 95],
 	darkDesaturation: .1,
+	darkCurve: .5,
 	states: {
 		dark: "@dark",
 		highContrast: "@high-contrast"
@@ -715,9 +965,47 @@ function pairNormal(p) {
 function pairHC(p) {
 	return Array.isArray(p) ? p[1] : p;
 }
+/**
+* Dedupe contrast warnings within a single process. The cache survives
+* the lifetime of a token because tokens memoize their resolution; the
+* limit is a soft cap to keep noise bounded across long-lived sessions
+* (e.g. dev servers with HMR re-resolving themes repeatedly).
+*/
+const CONTRAST_WARN_CACHE_LIMIT = 256;
+const contrastWarnCache = /* @__PURE__ */ new Set();
+function schemeLabel(isDark, isHighContrast) {
+	if (isDark && isHighContrast) return "darkContrast";
+	if (isDark) return "dark";
+	if (isHighContrast) return "lightContrast";
+	return "light";
+}
+function formatContrastTarget(input, ratio) {
+	return typeof input === "string" ? `"${input}" (${ratio.toFixed(2)})` : ratio.toFixed(2);
+}
+/**
+* Slack factor below the requested target before we emit a warning.
+* The contrast solver already overshoots by `OVERSHOOT` (currently 1%)
+* to absorb rounding noise (`see findLightnessForContrast` in
+* `contrast-solver.ts`), so an `actual` ratio within ~2x that overshoot
+* is effectively a pass and not worth nagging the user about.
+*/
+const CONTRAST_WARN_SLACK = .98;
+function warnContrastUnmet(name, isDark, isHighContrast, target, actual) {
+	const targetRatio = resolveMinContrast(target);
+	if (actual >= targetRatio * CONTRAST_WARN_SLACK) return;
+	const scheme = schemeLabel(isDark, isHighContrast);
+	const key = `${name}|${scheme}|${targetRatio.toFixed(3)}|${actual.toFixed(2)}`;
+	if (contrastWarnCache.has(key)) return;
+	if (contrastWarnCache.size >= CONTRAST_WARN_CACHE_LIMIT) contrastWarnCache.clear();
+	contrastWarnCache.add(key);
+	console.warn(`glaze: color "${name}" cannot meet contrast ${formatContrastTarget(target, targetRatio)} in ${scheme} scheme (got ${actual.toFixed(2)}). Try widening the lightness window, lowering the contrast target, or picking a base color further from this color's lightness.`);
+}
 function isShadowDef(def) {
 	return def.type === "shadow";
 }
+function isMixDef(def) {
+	return def.type === "mix";
+}
 const DEFAULT_SHADOW_TUNING = {
 	saturationFactor: .18,
 	maxSaturation: .25,
@@ -773,30 +1061,38 @@ function computeShadow(bg, fg, intensity, tuning) {
 		alpha
 	};
 }
-function validateColorDefs(defs) {
-	const names = new Set(Object.keys(defs));
+function validateColorDefs(defs, externalBases) {
+	const localNames = new Set(Object.keys(defs));
+	const allNames = new Set([...localNames, ...externalBases ? externalBases.keys() : []]);
 	for (const [name, def] of Object.entries(defs)) {
 		if (isShadowDef(def)) {
-			if (!names.has(def.bg)) throw new Error(`glaze: shadow "${name}" references non-existent bg "${def.bg}".`);
-			if (isShadowDef(defs[def.bg])) throw new Error(`glaze: shadow "${name}" bg "${def.bg}" references another shadow color.`);
+			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 (!names.has(def.fg)) throw new Error(`glaze: shadow "${name}" references non-existent fg "${def.fg}".`);
-				if (isShadowDef(defs[def.fg])) throw new Error(`glaze: shadow "${name}" fg "${def.fg}" references another shadow color.`);
+				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.`);
 			}
 			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.`);
+			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 (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.`);
 		if (!isAbsoluteLightness(regDef.lightness) && regDef.base === void 0) throw new Error(`glaze: color "${name}" must have either absolute "lightness" (root) 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 lightness unpredictable.`);
 	}
 	const visited = /* @__PURE__ */ new Set();
 	const inStack = /* @__PURE__ */ new Set();
 	function dfs(name) {
+		if (!localNames.has(name)) return;
 		if (inStack.has(name)) throw new Error(`glaze: circular base reference detected involving "${name}".`);
 		if (visited.has(name)) return;
 		inStack.add(name);
@@ -804,6 +1100,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);
@@ -811,7 +1110,7 @@ function validateColorDefs(defs) {
 		inStack.delete(name);
 		visited.add(name);
 	}
-	for (const name of names) dfs(name);
+	for (const name of localNames) dfs(name);
 }
 function topoSort(defs) {
 	const result = [];
@@ -820,9 +1119,13 @@ function topoSort(defs) {
 		if (visited.has(name)) return;
 		visited.add(name);
 		const def = defs[name];
+		if (def === void 0) return;
 		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 +1135,55 @@ function topoSort(defs) {
 	for (const name of Object.keys(defs)) visit(name);
 	return result;
 }
-function mapLightnessLight(l, mode) {
+/**
+* Resolve the active lightness window for a scheme.
+* - HC variants always return `[0, 100]` (existing behavior, predates per-call overrides).
+* - Otherwise, per-call `scaling` (e.g. from `glaze.color()`'s third arg) wins;
+*   `false` is interpreted as `[0, 100]` (no remap). Falls back to `globalConfig.*Lightness`.
+*/
+function lightnessWindow(isHighContrast, kind, scaling) {
+	if (isHighContrast) return [0, 100];
+	if (scaling) {
+		const override = kind === "dark" ? scaling.darkLightness : scaling.lightLightness;
+		if (override === false) return [0, 100];
+		if (override !== void 0) return override;
+	}
+	return kind === "dark" ? globalConfig.darkLightness : globalConfig.lightLightness;
+}
+function mapLightnessLight(l, mode, isHighContrast, scaling) {
 	if (mode === "static") return l;
-	const [lo, hi] = globalConfig.lightLightness;
+	const [lo, hi] = lightnessWindow(isHighContrast, "light", scaling);
 	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, scaling) {
 	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", scaling);
+	if (mode === "fixed") return l * (darkHi - darkLo) / 100 + darkLo;
+	const [lightLo, lightHi] = lightnessWindow(isHighContrast, "light", scaling);
+	const t = (lightHi - (l * (lightHi - lightLo) / 100 + lightLo)) / (lightHi - lightLo);
+	return darkLo + (darkHi - darkLo) * mobiusCurve(t, beta);
+}
+function lightMappedToDark(lightL, isHighContrast, scaling) {
+	const beta = isHighContrast ? pairHC(globalConfig.darkCurve) : pairNormal(globalConfig.darkCurve);
+	const [lightLo, lightHi] = lightnessWindow(isHighContrast, "light", scaling);
+	const [darkLo, darkHi] = lightnessWindow(isHighContrast, "dark", scaling);
+	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, scaling) {
+	if (mode === "static") return [0, 1];
+	const [lo, hi] = lightnessWindow(isHighContrast, isDark ? "dark" : "light", scaling);
+	return [lo / 100, hi / 100];
+}
 function clamp(v, min, max) {
 	return Math.max(min, Math.min(max, v));
 }
@@ -903,25 +1240,29 @@ 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, ctx.scaling);
+			else preferredL = clamp(baseL + delta, 0, 100);
+		} else if (isDark) preferredL = mapLightnessDark(parsed.value, mode, isHighContrast, ctx.scaling);
+		else preferredL = mapLightnessLight(parsed.value, mode, isHighContrast, ctx.scaling);
 	}
 	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, ctx.scaling);
+		const result = findLightnessForContrast({
+			hue: effectiveHue,
+			saturation: effectiveSat,
+			preferredLightness: clamp(preferredL / 100, windowRange[0], windowRange[1]),
+			baseLinearRgb,
+			contrast: minCr,
+			lightnessRange: [0, 1]
+		});
+		if (!result.met) warnContrastUnmet(name, isDark, isHighContrast, minCr, result.contrast);
 		return {
-			l: findLightnessForContrast({
-				hue: effectiveHue,
-				saturation: effectiveSat,
-				preferredLightness: preferredL / 100,
-				baseLinearRgb,
-				contrast: minCr
-			}).lightness * 100,
+			l: result.lightness * 100,
 			satFactor
 		};
 	}
@@ -938,6 +1279,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 +1298,13 @@ function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
 	let finalL;
 	let finalSat;
 	if (isDark && isRoot) {
-		finalL = mapLightnessDark(lightL, mode);
+		finalL = mapLightnessDark(lightL, mode, isHighContrast, ctx.scaling);
 		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, ctx.scaling);
 		finalSat = satFactor * ctx.saturation / 100;
 	} else {
 		finalL = lightL;
@@ -983,17 +1325,97 @@ function resolveShadowForScheme(def, ctx, isDark, isHighContrast) {
 	const tuning = resolveShadowTuning(def.tuning);
 	return computeShadow(bgVariant, fgVariant, intensity, tuning);
 }
-function resolveAllColors(hue, saturation, defs) {
-	validateColorDefs(defs);
+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, scaling, externalBases) {
+	validateColorDefs(defs, externalBases);
 	const order = topoSort(defs);
 	const ctx = {
 		hue,
 		saturation,
 		defs,
-		resolved: /* @__PURE__ */ new Map()
+		resolved: /* @__PURE__ */ new Map(),
+		scaling
 	};
+	if (externalBases) for (const [name, color] of externalBases) ctx.resolved.set(name, color);
 	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) {
@@ -1181,10 +1603,14 @@ function createTheme(hue, saturation, initialColors) {
 			};
 		},
 		extend(options) {
-			return createTheme(options.hue ?? hue, options.saturation ?? saturation, options.colors ? {
-				...colorDefs,
+			const newHue = options.hue ?? hue;
+			const newSat = options.saturation ?? saturation;
+			const inheritedColors = {};
+			for (const [name, def] of Object.entries(colorDefs)) if (def.inherit !== false) inheritedColors[name] = def;
+			return createTheme(newHue, newSat, options.colors ? {
+				...inheritedColors,
 				...options.colors
-			} : { ...colorDefs });
+			} : { ...inheritedColors });
 		},
 		resolve() {
 			return resolveAllColors(hue, saturation, colorDefs);
@@ -1206,35 +1632,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 +1724,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 +1734,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"),
@@ -1271,34 +1764,409 @@ function createPalette(themes) {
 		}
 	};
 }
-function createColorToken(input) {
-	const defs = { __color__: {
-		lightness: input.lightness,
-		saturation: input.saturationFactor,
-		mode: input.mode
-	} };
+/**
+* Matches the CSS color functions Glaze itself emits (`rgb()`, `hsl()`,
+* `okhsl()`, `oklch()`) plus their legacy alpha aliases (`rgba()`, `hsla()`).
+*
+* 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|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
+	};
+}
+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
+			};
+		}
+		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 "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, lightness } (which uses 0–100)?");
+}
+/**
+* Validate a user-supplied `[r, g, b]` tuple in 0-255.
+*/
+function validateRgbTuple(value) {
+	for (const n of value) if (!Number.isFinite(n) || n < 0 || n > 255) throw new Error(`glaze.color: RGB tuple components must be finite numbers in 0–255 (got [${value.join(", ")}]).`);
+}
+/**
+* Validate a user-supplied `opacity` override on `glaze.color()`.
+* Must be a finite number in `0..=1`.
+*/
+function validateStandaloneOpacity(value) {
+	if (!Number.isFinite(value) || value < 0 || value > 1) throw new Error(`glaze.color: opacity must be a finite number in 0–1 (got ${value}).`);
+}
+/**
+* Validate a structured `GlazeColorInput`. Range-checks the `hue` /
+* `saturation` / `lightness` numerics (and any HC-pair second value)
+* before the resolver sees them so out-of-range or non-finite inputs
+* fail with a helpful, top-level error rather than producing a
+* NaN-laden token. `opacity` is checked here too so all input
+* validation lives in one place.
+*/
+function validateStructuredInput(input) {
+	if (!Number.isFinite(input.hue)) throw new Error(`glaze.color: structured hue must be a finite number (got ${input.hue}).`);
+	if (!Number.isFinite(input.saturation) || input.saturation < 0 || input.saturation > 100) throw new Error(`glaze.color: structured saturation must be a finite number in 0–100 (got ${input.saturation}).`);
+	const checkLightness = (value, label) => {
+		if (!Number.isFinite(value) || value < 0 || value > 100) throw new Error(`glaze.color: structured ${label} must be a finite number in 0–100 (got ${value}).`);
+	};
+	if (Array.isArray(input.lightness)) {
+		checkLightness(input.lightness[0], "lightness[normal]");
+		checkLightness(input.lightness[1], "lightness[hc]");
+	} else checkLightness(input.lightness, "lightness");
+	if (input.saturationFactor !== void 0) {
+		if (!Number.isFinite(input.saturationFactor) || input.saturationFactor < 0 || input.saturationFactor > 1) throw new Error(`glaze.color: structured saturationFactor must be a finite number in 0–1 (got ${input.saturationFactor}).`);
+	}
+	if (input.opacity !== void 0) validateStandaloneOpacity(input.opacity);
+}
+/**
+* Validate a user-supplied `name` override. Rejects empty / whitespace-only
+* strings and names colliding with `glaze`'s reserved internal sentinels.
+*/
+function validateStandaloneName(name) {
+	if (typeof name !== "string" || name.trim() === "") throw new Error("glaze.color: name must be a non-empty string. Omit `name` if you do not want to set a debug label.");
+	if (RESERVED_STANDALONE_NAMES.has(name)) {
+		const reserved = [...RESERVED_STANDALONE_NAMES].map((n) => `"${n}"`).join(", ");
+		throw new Error(`glaze.color: name "${name}" is reserved (used internally). Reserved names are: ${reserved}. Pick a different name.`);
+	}
+}
+/**
+* Extract an OKHSL color from any `GlazeColorValue` form. Also used by
+* `glaze.shadow()` so all shadow inputs (hex, color functions, OKHSL,
+* RGB tuple) go through one parser.
+*/
+function extractOkhslFromValue(value) {
+	if (typeof value === "string") return parseColorString(value);
+	if (Array.isArray(value)) {
+		const tuple = value;
+		validateRgbTuple(tuple);
+		const [r, g, b] = tuple;
+		const [h, s, l] = srgbToOkhsl([
+			r / 255,
+			g / 255,
+			b / 255
+		]);
+		return {
+			h,
+			s,
+			l
+		};
+	}
+	validateOkhslColor(value);
+	return value;
+}
+/**
+* Build the `ColorMap` for a value-shorthand `glaze.color()` call.
+*
+* The user-facing color (`STANDALONE_VALUE`) defaults to `mode: 'auto'`
+* across every value-shorthand form. String inputs pair with the
+* extended dark window so a totally-black input renders as totally-white
+* in dark mode; `OkhslColor` / RGB-tuple inputs auto-adapt into the
+* snapshotted `globalConfig.lightLightness` / `globalConfig.darkLightness`
+* windows.
+*
+* When the user requests `contrast` or relative `lightness`, a hidden
+* `STANDALONE_SEED` def is synthesized at `mode: 'static'`. That keeps
+* the seed pinned to the literal user-provided color across all four
+* variants, so the contrast solver always anchors against it.
+*/
+function buildStandaloneValueDefs(main, options) {
+	const seedHue = typeof options?.hue === "number" ? options.hue : main.h;
+	const seedSaturation = options?.saturation ?? main.s * 100;
+	const relativeHue = typeof options?.hue === "string" ? options.hue : void 0;
+	const lightnessOption = options?.lightness;
+	const hasExternalBase = options?.base !== void 0;
+	const needsSeedAnchor = !hasExternalBase && (options?.contrast !== void 0 || lightnessOption !== void 0 && !isAbsoluteLightness(lightnessOption));
+	if (options?.opacity !== void 0) validateStandaloneOpacity(options.opacity);
+	const userName = options?.name;
+	if (userName !== void 0) validateStandaloneName(userName);
+	const primary = userName ?? STANDALONE_VALUE;
+	const valueDef = {
+		hue: relativeHue,
+		saturation: options?.saturationFactor,
+		lightness: lightnessOption ?? main.l * 100,
+		contrast: options?.contrast,
+		mode: options?.mode ?? "auto",
+		opacity: options?.opacity,
+		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
+	};
+	const defs = { [primary]: valueDef };
+	if (needsSeedAnchor) defs[STANDALONE_SEED] = {
+		hue: main.h,
+		saturation: 1,
+		lightness: main.l * 100,
+		mode: "static"
+	};
+	return {
+		seedHue,
+		seedSaturation,
+		defs,
+		primary
+	};
+}
+function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, effectiveScaling, baseToken, exportData) {
+	let cached;
+	const resolveOnce = () => {
+		if (cached) return cached;
+		cached = resolveAllColors(seedHue, seedSaturation, defs, effectiveScaling, baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0);
+		return cached;
+	};
+	const resolveStates = (options) => ({
+		dark: options?.states?.dark ?? globalConfig.states.dark,
+		highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
+	});
+	const tokenLike = (options) => {
+		return buildTokenMap(resolveOnce(), "", resolveStates(options), resolveModes(options?.modes), options?.format)[`#${primary}`];
+	};
 	return {
 		resolve() {
-			return resolveAllColors(input.hue, input.saturation, defs).get("__color__");
+			return resolveOnce().get(primary);
 		},
-		token(options) {
-			return buildTokenMap(resolveAllColors(input.hue, input.saturation, defs), "", {
-				dark: options?.states?.dark ?? globalConfig.states.dark,
-				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
-			}, resolveModes(options?.modes), options?.format)["#__color__"];
+		token: tokenLike,
+		tasty: tokenLike,
+		json(options) {
+			return buildJsonMap(resolveOnce(), resolveModes(options?.modes), options?.format)[primary];
 		},
-		tasty(options) {
-			return buildTokenMap(resolveAllColors(input.hue, input.saturation, defs), "", {
-				dark: options?.states?.dark ?? globalConfig.states.dark,
-				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
-			}, resolveModes(options?.modes), options?.format)["#__color__"];
+		css(options) {
+			return buildCssMap(new Map([[options.name, resolveOnce().get(primary)]]), "", options.suffix ?? "-color", options.format ?? "rgb");
 		},
-		json(options) {
-			return buildJsonMap(resolveAllColors(input.hue, input.saturation, defs), resolveModes(options?.modes), options?.format)["__color__"];
-		}
+		export: exportData
 	};
 }
 /**
+* Resolve `base` (which may be a token reference or a raw color value)
+* into a `GlazeColorToken`. Raw values are auto-wrapped via
+* `glaze.color(value)` so they pick up the same auto-invert defaults as
+* an explicit wrap. Returns `undefined` when no base is provided.
+*/
+function resolveBaseToken(base) {
+	if (base === void 0) return void 0;
+	if (isGlazeColorToken(base)) return base;
+	return createColorTokenFromValue(base, void 0, void 0);
+}
+/**
+* Build a JSON-safe snapshot of `GlazeColorOverrides`. `base` is
+* recursively serialized when it was originally a token; raw values are
+* preserved as-is so `glaze.colorFrom(...)` round-trips them.
+*/
+function buildOverridesExport(options) {
+	const out = {};
+	if (options.hue !== void 0) out.hue = options.hue;
+	if (options.saturation !== void 0) out.saturation = options.saturation;
+	if (options.lightness !== void 0) out.lightness = options.lightness;
+	if (options.saturationFactor !== void 0) out.saturationFactor = options.saturationFactor;
+	if (options.mode !== void 0) out.mode = options.mode;
+	if (options.contrast !== void 0) out.contrast = options.contrast;
+	if (options.opacity !== void 0) out.opacity = options.opacity;
+	if (options.name !== void 0) out.name = options.name;
+	if (options.base !== void 0) out.base = isGlazeColorToken(options.base) ? options.base.export() : options.base;
+	return out;
+}
+function buildStructuredInputExport(input) {
+	const out = {
+		hue: input.hue,
+		saturation: input.saturation,
+		lightness: input.lightness
+	};
+	if (input.saturationFactor !== void 0) out.saturationFactor = input.saturationFactor;
+	if (input.mode !== void 0) out.mode = input.mode;
+	if (input.opacity !== void 0) out.opacity = input.opacity;
+	if (input.contrast !== void 0) out.contrast = input.contrast;
+	if (input.name !== void 0) out.name = input.name;
+	if (input.base !== void 0) out.base = isGlazeColorToken(input.base) ? input.base.export() : input.base;
+	return out;
+}
+function createColorToken(input, scaling) {
+	validateStructuredInput(input);
+	const userName = input.name;
+	if (userName !== void 0) validateStandaloneName(userName);
+	const primary = userName ?? STANDALONE_VALUE;
+	const baseToken = resolveBaseToken(input.base);
+	const hasExternalBase = baseToken !== void 0;
+	const needsSeedAnchor = !hasExternalBase && input.contrast !== void 0;
+	const defs = { [primary]: {
+		lightness: input.lightness,
+		saturation: input.saturationFactor,
+		mode: input.mode ?? "auto",
+		contrast: input.contrast,
+		opacity: input.opacity,
+		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
+	} };
+	if (needsSeedAnchor) defs[STANDALONE_SEED] = {
+		lightness: pairNormal(input.lightness),
+		saturation: 1,
+		mode: "static"
+	};
+	const effectiveScaling = scaling ?? defaultStandaloneScaling(false);
+	const exportData = () => ({
+		form: "structured",
+		input: buildStructuredInputExport(input),
+		scaling: effectiveScaling
+	});
+	return createColorTokenFromDefs(input.hue, input.saturation, defs, primary, effectiveScaling, baseToken, exportData);
+}
+function createColorTokenFromValue(value, options, scaling) {
+	const inputIsString = typeof value === "string";
+	const main = extractOkhslFromValue(value);
+	const baseToken = resolveBaseToken(options?.base);
+	const { seedHue, seedSaturation, defs, primary } = buildStandaloneValueDefs(main, options);
+	const effectiveScaling = scaling ?? defaultStandaloneScaling(inputIsString);
+	const exportData = () => ({
+		form: "value",
+		input: value,
+		...options !== void 0 ? { overrides: buildOverridesExport(options) } : {},
+		scaling: effectiveScaling
+	});
+	return createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, effectiveScaling, baseToken, exportData);
+}
+/**
+* Rehydrate a token from its `.export()` snapshot. Recursively rebuilds
+* any base dependency. Inverse of `GlazeColorToken.export()`.
+*/
+function colorFromExport(data) {
+	if (data === null || typeof data !== "object") throw new Error(`glaze.colorFrom: expected an object from token.export(), got ${data === null ? "null" : typeof data}.`);
+	if (data.form !== "value" && data.form !== "structured") throw new Error(`glaze.colorFrom: invalid "form" field — expected "value" or "structured" (got ${JSON.stringify(data.form)}).`);
+	if (data.input === void 0) throw new Error(`glaze.colorFrom: missing "input" field — expected the original ${data.form === "value" ? "GlazeColorValue" : "GlazeColorInput"}.`);
+	if (data.form === "value") {
+		const value = data.input;
+		return createColorTokenFromValue(value, data.overrides ? rehydrateOverrides(data.overrides) : void 0, data.scaling);
+	}
+	return createColorToken(rehydrateStructuredInput(data.input), data.scaling);
+}
+function rehydrateOverrides(data) {
+	const out = {};
+	if (data.hue !== void 0) out.hue = data.hue;
+	if (data.saturation !== void 0) out.saturation = data.saturation;
+	if (data.lightness !== void 0) out.lightness = data.lightness;
+	if (data.saturationFactor !== void 0) out.saturationFactor = data.saturationFactor;
+	if (data.mode !== void 0) out.mode = data.mode;
+	if (data.contrast !== void 0) out.contrast = data.contrast;
+	if (data.opacity !== void 0) out.opacity = data.opacity;
+	if (data.name !== void 0) out.name = data.name;
+	if (data.base !== void 0) out.base = isExportedToken(data.base) ? colorFromExport(data.base) : data.base;
+	return out;
+}
+function rehydrateStructuredInput(data) {
+	const out = {
+		hue: data.hue,
+		saturation: data.saturation,
+		lightness: data.lightness
+	};
+	if (data.saturationFactor !== void 0) out.saturationFactor = data.saturationFactor;
+	if (data.mode !== void 0) out.mode = data.mode;
+	if (data.opacity !== void 0) out.opacity = data.opacity;
+	if (data.contrast !== void 0) out.contrast = data.contrast;
+	if (data.name !== void 0) out.name = data.name;
+	if (data.base !== void 0) out.base = isExportedToken(data.base) ? colorFromExport(data.base) : data.base;
+	return out;
+}
+/**
+* Discriminate a `GlazeColorTokenExport` from a raw `GlazeColorValue`.
+* `GlazeColorTokenExport` always has a `form` field set to either
+* `'value'` or `'structured'`; raw values never do.
+*/
+function isExportedToken(candidate) {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && "form" in candidate && (candidate.form === "value" || candidate.form === "structured");
+}
+/**
 * Create a single-hue glaze theme.
 *
 * @example
@@ -1320,6 +2188,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 +2203,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.
@@ -1343,18 +2212,63 @@ glaze.palette = function palette(themes) {
 glaze.from = function from(data) {
 	return createTheme(data.hue, data.saturation, data.colors);
 };
+function isStructuredColorInput(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input) && "hue" in input && "lightness" in input;
+}
 /**
 * Create a standalone single-color token.
+*
+* Two overloads:
+* - `glaze.color(input, scaling?)` — structured form:
+*   `{ hue, saturation, lightness, ... }` plus an optional per-call
+*   lightness-window override.
+* - `glaze.color(value, overrides?, scaling?)` — value-shorthand: a hex
+*   string (3/6/8 digits), one of the CSS color functions Glaze itself
+*   emits (`rgb()`, `hsl()`, `okhsl()`, `oklch()`), an `OkhslColor`
+*   object `{ h, s, l }` (0–1 ranges), or an `[r, g, b]` (0–255) tuple.
+*
+* Defaults: every input form defaults to `mode: 'auto'` so colors
+* automatically adapt between light and dark like an ordinary theme
+* color. The scaling snapshot taken at create time differs by input
+* form:
+* - String value-shorthand: `{ lightLightness: false, darkLightness:
+*   [globalConfig.darkLightness[0], 100] }`. Light preserves the input
+*   exactly; dark Möbius-inverts up to 100, so `glaze.color('#000')`
+*   renders as `#fff` in dark mode (and `glaze.color('#fff')` falls to
+*   the dark `lo` floor).
+* - `OkhslColor` object / RGB-tuple / structured value-shorthand:
+*   `{ lightLightness: globalConfig.lightLightness, darkLightness:
+*   globalConfig.darkLightness }` — both windows come straight from
+*   `globalConfig`, so the resulting token behaves like a theme color.
+*
+* Pass `{ mode: 'fixed' }` to opt back into the legacy linear, non-
+* inverting mapping, or `{ mode: 'static' }` to pin the same lightness
+* across every variant.
+*
+* Relative `lightness: '+N'` and `contrast: <ratio>` are anchored to
+* the literal seed (the value passed in) by default, pinned at
+* `mode: 'static'` across all four variants. Pass `overrides.base` (a
+* `GlazeColorToken`) to anchor `contrast` and relative `lightness`
+* against another color's resolved variant per scheme instead. Relative
+* `hue: '+N'` always anchors to the seed.
+*
+* Alpha components in `rgba()` / `hsla()` / slash-alpha syntax and
+* 8-digit hex are parsed but dropped with a `console.warn`.
 */
-glaze.color = function color(input) {
-	return createColorToken(input);
+glaze.color = function color(input, arg2, arg3) {
+	if (isStructuredColorInput(input)) return createColorToken(input, arg2);
+	return createColorTokenFromValue(input, arg2, arg3);
 };
 /**
 * 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, `OkhslColor` objects, or `[r, g, b]` (0–255) tuples.
 */
 glaze.shadow = function shadow(input) {
-	const bg = parseOkhslInput(input.bg);
-	const fg = input.fg ? parseOkhslInput(input.fg) : void 0;
+	const bg = extractOkhslFromValue(input.bg);
+	const fg = input.fg ? extractOkhslFromValue(input.fg) : void 0;
 	const tuning = resolveShadowTuning(input.tuning);
 	return computeShadow({
 		...bg,
@@ -1370,19 +2284,6 @@ glaze.shadow = function shadow(input) {
 glaze.format = function format(variant, colorFormat) {
 	return formatVariant(variant, colorFormat);
 };
-function parseOkhslInput(input) {
-	if (typeof input === "string") {
-		const rgb = parseHex(input);
-		if (!rgb) throw new Error(`glaze: invalid hex color "${input}".`);
-		const [h, s, l] = srgbToOkhsl(rgb);
-		return {
-			h,
-			s,
-			l
-		};
-	}
-	return input;
-}
 /**
 * Create a theme from a hex color string.
 * Extracts hue and saturation from the color.
@@ -1406,6 +2307,26 @@ glaze.fromRgb = function fromRgb(r, g, b) {
 	return createTheme(h, s * 100);
 };
 /**
+* Rehydrate a `glaze.color()` token from a `.export()` snapshot.
+*
+* The snapshot is a plain JSON-safe object containing the original
+* input value, overrides (with any `base` token recursively serialized),
+* and the captured scaling. The reconstructed token is identical in
+* behavior to the original at the time of export.
+*
+* @example
+* ```ts
+* const text = glaze.color('#1a1a1a', { contrast: 'AA' });
+* const data = text.export();           // JSON-safe
+* localStorage.setItem('text', JSON.stringify(data));
+* // ...later...
+* const restored = glaze.colorFrom(JSON.parse(localStorage.getItem('text')!));
+* ```
+*/
+glaze.colorFrom = function colorFrom(data) {
+	return colorFromExport(data);
+};
+/**
 * Get the current global configuration (for testing/debugging).
 */
 glaze.getConfig = function getConfig() {
@@ -1419,6 +2340,7 @@ glaze.resetConfig = function resetConfig() {
 		lightLightness: [10, 100],
 		darkLightness: [15, 95],
 		darkDesaturation: .1,
+		darkCurve: .5,
 		states: {
 			dark: "@dark",
 			highContrast: "@high-contrast"
@@ -1433,15 +2355,20 @@ 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.hslToSrgb = hslToSrgb;
 exports.okhslToLinearSrgb = okhslToLinearSrgb;
 exports.okhslToOklab = okhslToOklab;
 exports.okhslToSrgb = okhslToSrgb;
+exports.oklabToOkhsl = oklabToOkhsl;
 exports.parseHex = parseHex;
+exports.parseHexAlpha = parseHexAlpha;
 exports.relativeLuminanceFromLinearRgb = relativeLuminanceFromLinearRgb;
 exports.resolveMinContrast = resolveMinContrast;
 exports.srgbToOkhsl = srgbToOkhsl;