@tenphi/glaze 0.0.0-snapshot.4e8eab7 → 0.0.0-snapshot.52e0dd6

package/dist/index.cjs

@@ -560,6 +560,118 @@ function formatOklch(h, s, l) {
 	return `oklch(${fmt$1(L, 4)} ${fmt$1(C, 4)} ${fmt$1(hh, 2)})`;
 }
 
+//#endregion
+//#region src/config.ts
+/**
+* Build a fresh defaults object. Called from module init and from
+* `resetConfig()` so the two paths can't drift.
+*/
+function defaultConfig() {
+	return {
+		lightLightness: [10, 100],
+		darkLightness: [15, 95],
+		darkDesaturation: .1,
+		darkCurve: .5,
+		states: {
+			dark: "@dark",
+			highContrast: "@high-contrast"
+		},
+		modes: {
+			dark: true,
+			highContrast: false
+		},
+		autoFlip: true
+	};
+}
+let globalConfig = defaultConfig();
+/**
+* Monotonic counter incremented on every `configure()` / `resetConfig()`
+* call. Theme / palette caches read this to invalidate stale resolve
+* results when the config changes between exports.
+*/
+let configVersion = 0;
+/** Live reference to the current config. Mutated by `configure()` / `resetConfig()`. */
+function getConfig() {
+	return globalConfig;
+}
+function getConfigVersion() {
+	return configVersion;
+}
+/**
+* Public-facing snapshot used by `glaze.getConfig()`. Returns a shallow
+* copy so callers can't mutate the live config.
+*/
+function snapshotConfig() {
+	return { ...globalConfig };
+}
+function configure(config) {
+	configVersion++;
+	globalConfig = {
+		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
+		},
+		modes: {
+			dark: config.modes?.dark ?? globalConfig.modes.dark,
+			highContrast: config.modes?.highContrast ?? globalConfig.modes.highContrast
+		},
+		shadowTuning: config.shadowTuning ?? globalConfig.shadowTuning,
+		autoFlip: config.autoFlip ?? globalConfig.autoFlip
+	};
+}
+function resetConfig() {
+	configVersion++;
+	globalConfig = defaultConfig();
+}
+
+//#endregion
+//#region src/hc-pair.ts
+function pairNormal(p) {
+	return Array.isArray(p) ? p[0] : p;
+}
+function pairHC(p) {
+	return Array.isArray(p) ? p[1] : p;
+}
+function clamp(v, min, max) {
+	return Math.max(min, Math.min(max, v));
+}
+/**
+* Parse a value that can be absolute (number) or relative (signed string).
+* Returns the numeric value and whether it's relative.
+*/
+function parseRelativeOrAbsolute(value) {
+	if (typeof value === "number") return {
+		value,
+		relative: false
+	};
+	return {
+		value: parseFloat(value),
+		relative: true
+	};
+}
+/**
+* Compute the effective hue for a color, given the theme seed hue
+* and an optional per-color hue override.
+*/
+function resolveEffectiveHue(seedHue, defHue) {
+	if (defHue === void 0) return seedHue;
+	const parsed = parseRelativeOrAbsolute(defHue);
+	if (parsed.relative) return ((seedHue + parsed.value) % 360 + 360) % 360;
+	return (parsed.value % 360 + 360) % 360;
+}
+/**
+* Check whether a lightness value represents an absolute root definition
+* (i.e. a number, not a relative string).
+*/
+function isAbsoluteLightness(lightness) {
+	if (lightness === void 0) return false;
+	return typeof (Array.isArray(lightness) ? lightness[0] : lightness) === "number";
+}
+
 //#endregion
 //#region src/contrast-solver.ts
 /**
@@ -757,6 +869,25 @@ function findLightnessForContrast(options) {
 		branch: "preferred"
 	};
 	candidates.sort((a, b) => b.contrast - a.contrast);
+	if (candidates.length > 0 && options.flip) {
+		const best = candidates[0];
+		const center = (minL + maxL) / 2;
+		const flippedResult = findLightnessForContrast({
+			hue,
+			saturation,
+			preferredLightness: Math.max(minL, Math.min(maxL, 2 * center - best.lightness)),
+			baseLinearRgb,
+			contrast: contrastInput,
+			lightnessRange: [minL, maxL],
+			epsilon,
+			maxIterations
+		});
+		if (flippedResult.met) return {
+			...flippedResult,
+			branch: flippedResult.branch,
+			flipped: true
+		};
+	}
 	return candidates[0];
 }
 /**
@@ -829,7 +960,7 @@ function searchMixBranch(lo, hi, yBase, target, epsilon, maxIter, preferred, lum
 * 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 { preferredValue, baseLinearRgb, targetLinearRgb, contrast: contrastInput, luminanceAtValue, epsilon = 1e-4, maxIterations = 20 } = options;
 	const target = resolveMinContrast(contrastInput);
 	const searchTarget = target * 1.01;
 	const yBase = gamutClampedLuminance(baseLinearRgb);
@@ -882,6 +1013,22 @@ function findValueForMixContrast(options) {
 		met: false
 	};
 	candidates.sort((a, b) => b.contrast - a.contrast);
+	if (candidates.length > 0 && options.flip) {
+		const best = candidates[0];
+		const flippedResult = findValueForMixContrast({
+			preferredValue: Math.max(0, Math.min(1, 2 * .5 - best.lightness)),
+			baseLinearRgb,
+			targetLinearRgb,
+			contrast: contrastInput,
+			luminanceAtValue,
+			epsilon,
+			maxIterations
+		});
+		if (flippedResult.met) return {
+			...flippedResult,
+			flipped: true
+		};
+	}
 	return {
 		value: candidates[0].lightness,
 		contrast: candidates[0].contrast,
@@ -890,116 +1037,15 @@ function findValueForMixContrast(options) {
 }
 
 //#endregion
-//#region src/glaze.ts
-/**
-* Glaze — OKHSL-based color theme generator.
-*
-* 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";
+//#region src/shadow.ts
 /**
-* 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).
+* Shadow color computation.
 *
-* 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"
-	},
-	modes: {
-		dark: true,
-		highContrast: false
-	}
-};
-function pairNormal(p) {
-	return Array.isArray(p) ? p[0] : 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.
+* Owns the shadow / mix def predicates, default tuning constants, the
+* tuning merge, and the actual `computeShadow` math (hue blend,
+* saturation cap, lightness clamp, alpha curve). The resolver consumes
+* this module per scheme variant.
 */
-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";
 }
@@ -1016,11 +1062,12 @@ const DEFAULT_SHADOW_TUNING = {
 	bgHueBlend: .2
 };
 function resolveShadowTuning(perColor) {
+	const globalTuning = getConfig().shadowTuning;
 	return {
 		...DEFAULT_SHADOW_TUNING,
-		...globalConfig.shadowTuning,
+		...globalTuning,
 		...perColor,
-		lightnessBounds: perColor?.lightnessBounds ?? globalConfig.shadowTuning?.lightnessBounds ?? DEFAULT_SHADOW_TUNING.lightnessBounds
+		lightnessBounds: perColor?.lightnessBounds ?? globalTuning?.lightnessBounds ?? DEFAULT_SHADOW_TUNING.lightnessBounds
 	};
 }
 function circularLerp(a, b, t) {
@@ -1061,6 +1108,80 @@ function computeShadow(bg, fg, intensity, tuning) {
 		alpha
 	};
 }
+
+//#endregion
+//#region src/scheme-mapping.ts
+/**
+* Light / dark scheme lightness mappings.
+*
+* Owns the active lightness window selection (with per-call scaling
+* overrides and high-contrast handling), the Möbius curve used by the
+* `'auto'` dark adaptation, and the saturation-desaturation reducer
+* for dark 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;
+	}
+	const cfg = getConfig();
+	return kind === "dark" ? cfg.darkLightness : cfg.lightLightness;
+}
+function mapLightnessLight(l, mode, isHighContrast, scaling) {
+	if (mode === "static") return l;
+	const [lo, hi] = lightnessWindow(isHighContrast, "light", scaling);
+	return l * (hi - lo) / 100 + lo;
+}
+function mobiusCurve(t, beta) {
+	if (beta >= 1) return t;
+	return t / (t + beta * (1 - t));
+}
+function mapLightnessDark(l, mode, isHighContrast, scaling) {
+	if (mode === "static") return l;
+	const cfg = getConfig();
+	const beta = isHighContrast ? pairHC(cfg.darkCurve) : pairNormal(cfg.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 cfg = getConfig();
+	const beta = isHighContrast ? pairHC(cfg.darkCurve) : pairNormal(cfg.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 - getConfig().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];
+}
+
+//#endregion
+//#region src/validation.ts
+/**
+* Color graph validation and topological sort.
+*
+* `validateColorDefs` rejects bad references (missing / shadow-referencing /
+* base/contrast/lightness mismatches) and detects cycles before the
+* resolver runs. `topoSort` orders defs so each color is processed after
+* its base / bg / fg / target dependencies.
+*/
 function validateColorDefs(defs, externalBases) {
 	const localNames = new Set(Object.keys(defs));
 	const allNames = new Set([...localNames, ...externalBases ? externalBases.keys() : []]);
@@ -1135,89 +1256,62 @@ function topoSort(defs) {
 	for (const name of Object.keys(defs)) visit(name);
 	return result;
 }
+
+//#endregion
+//#region src/warnings.ts
 /**
-* 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`.
+* Contrast-warning dispatcher.
+*
+* Tokens memoize their resolution, but a long-lived process (e.g. a dev
+* server with HMR) can re-resolve the same theme many times. The cache
+* here dedupes warnings within a session with a soft cap to keep noise
+* bounded.
 */
-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] = lightnessWindow(isHighContrast, "light", scaling);
-	return l * (hi - lo) / 100 + lo;
-}
-function mobiusCurve(t, beta) {
-	if (beta >= 1) return t;
-	return t / (t + beta * (1 - t));
-}
-function mapLightnessDark(l, mode, isHighContrast, scaling) {
-	if (mode === "static") return l;
-	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));
-}
+const CONTRAST_WARN_CACHE_LIMIT = 256;
+const contrastWarnCache = /* @__PURE__ */ new Set();
 /**
-* Parse a value that can be absolute (number) or relative (signed string).
-* Returns the numeric value and whether it's relative.
+* 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.
 */
-function parseRelativeOrAbsolute(value) {
-	if (typeof value === "number") return {
-		value,
-		relative: false
-	};
-	return {
-		value: parseFloat(value),
-		relative: true
-	};
+const CONTRAST_WARN_SLACK = .98;
+function schemeLabel(isDark, isHighContrast) {
+	if (isDark && isHighContrast) return "darkContrast";
+	if (isDark) return "dark";
+	if (isHighContrast) return "lightContrast";
+	return "light";
 }
-/**
-* Compute the effective hue for a color, given the theme seed hue
-* and an optional per-color hue override.
-*/
-function resolveEffectiveHue(seedHue, defHue) {
-	if (defHue === void 0) return seedHue;
-	const parsed = parseRelativeOrAbsolute(defHue);
-	if (parsed.relative) return ((seedHue + parsed.value) % 360 + 360) % 360;
-	return (parsed.value % 360 + 360) % 360;
+function formatContrastTarget(input, ratio) {
+	return typeof input === "string" ? `"${input}" (${ratio.toFixed(2)})` : ratio.toFixed(2);
+}
+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.`);
 }
+
+//#endregion
+//#region src/resolver.ts
 /**
-* Check whether a lightness value represents an absolute root definition
-* (i.e. a number, not a relative string).
+* Color resolution engine.
+*
+* Runs the four-pass solver (light → light-HC → dark → dark-HC) that
+* turns a `ColorMap` into a fully resolved `ResolvedColor` per name.
+* Owns the per-scheme resolve helpers for regular, shadow, and mix
+* color defs.
 */
-function isAbsoluteLightness(lightness) {
-	if (lightness === void 0) return false;
-	return typeof (Array.isArray(lightness) ? lightness[0] : lightness) === "number";
+function getSchemeVariant(color, isDark, isHighContrast) {
+	if (isDark && isHighContrast) return color.darkContrast;
+	if (isDark) return color.dark;
+	if (isHighContrast) return color.lightContrast;
+	return color.light;
 }
 function resolveRootColor(_name, def, _ctx, isHighContrast) {
 	const rawL = def.lightness;
@@ -1252,13 +1346,15 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 		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 autoFlip = ctx.autoFlip ?? getConfig().autoFlip;
 		const result = findLightnessForContrast({
 			hue: effectiveHue,
 			saturation: effectiveSat,
 			preferredLightness: clamp(preferredL / 100, windowRange[0], windowRange[1]),
 			baseLinearRgb,
 			contrast: minCr,
-			lightnessRange: [0, 1]
+			lightnessRange: [0, 1],
+			flip: autoFlip
 		});
 		if (!result.met) warnContrastUnmet(name, isDark, isHighContrast, minCr, result.contrast);
 		return {
@@ -1271,12 +1367,6 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 		satFactor
 	};
 }
-function getSchemeVariant(color, isDark, isHighContrast) {
-	if (isDark && isHighContrast) return color.darkContrast;
-	if (isDark) return color.dark;
-	if (isHighContrast) return color.lightContrast;
-	return color.light;
-}
 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);
@@ -1380,12 +1470,14 @@ function resolveMixForScheme(def, ctx, isDark, isHighContrast) {
 		else luminanceAt = (v) => {
 			return gamutClampedLuminance(okhslToLinearSrgb(mixHue(baseVariant, targetVariant, v), baseVariant.s + (targetVariant.s - baseVariant.s) * v, baseVariant.l + (targetVariant.l - baseVariant.l) * v));
 		};
+		const autoFlip = ctx.autoFlip ?? getConfig().autoFlip;
 		t = findValueForMixContrast({
 			preferredValue: t,
 			baseLinearRgb: baseLinear,
 			targetLinearRgb: targetLinear,
 			contrast: minCr,
-			luminanceAtValue: luminanceAt
+			luminanceAtValue: luminanceAt,
+			flip: autoFlip
 		}).value;
 	}
 	if (blend === "transparent") return {
@@ -1402,26 +1494,27 @@ function resolveMixForScheme(def, ctx, isDark, isHighContrast) {
 		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(),
-		scaling
-	};
-	if (externalBases) for (const [name, color] of externalBases) ctx.resolved.set(name, color);
-	function defMode(def) {
-		if (isShadowDef(def) || isMixDef(def)) return void 0;
-		return def.mode ?? "auto";
-	}
-	const lightMap = /* @__PURE__ */ new Map();
+function defMode(def) {
+	if (isShadowDef(def) || isMixDef(def)) return void 0;
+	return def.mode ?? "auto";
+}
+/**
+* Run a single resolve pass over all local names. Pass 1 lazily creates
+* each `ResolvedColor` (all four slots seeded with the just-resolved
+* variant) the first time it sees a name; later passes update the
+* `target` slot on the existing record.
+*/
+function runPass(order, defs, ctx, isDark, isHighContrast, target) {
+	const out = /* @__PURE__ */ new Map();
 	for (const name of order) {
-		const variant = resolveColorForScheme(name, defs[name], ctx, false, false);
-		lightMap.set(name, variant);
-		ctx.resolved.set(name, {
+		const variant = resolveColorForScheme(name, defs[name], ctx, isDark, isHighContrast);
+		out.set(name, variant);
+		const existing = ctx.resolved.get(name);
+		if (existing) ctx.resolved.set(name, {
+			...existing,
+			[target]: variant
+		});
+		else ctx.resolved.set(name, {
 			name,
 			light: variant,
 			dark: variant,
@@ -1430,49 +1523,42 @@ function resolveAllColors(hue, saturation, defs, scaling, externalBases) {
 			mode: defMode(defs[name])
 		});
 	}
-	const lightHCMap = /* @__PURE__ */ new Map();
-	for (const name of order) ctx.resolved.set(name, {
-		...ctx.resolved.get(name),
-		lightContrast: lightMap.get(name)
-	});
-	for (const name of order) {
-		const variant = resolveColorForScheme(name, defs[name], ctx, false, true);
-		lightHCMap.set(name, variant);
-		ctx.resolved.set(name, {
-			...ctx.resolved.get(name),
-			lightContrast: variant
-		});
-	}
-	const darkMap = /* @__PURE__ */ new Map();
-	for (const name of order) ctx.resolved.set(name, {
-		name,
-		light: lightMap.get(name),
-		dark: lightMap.get(name),
-		lightContrast: lightHCMap.get(name),
-		darkContrast: lightHCMap.get(name),
-		mode: defMode(defs[name])
-	});
-	for (const name of order) {
-		const variant = resolveColorForScheme(name, defs[name], ctx, true, false);
-		darkMap.set(name, variant);
-		ctx.resolved.set(name, {
-			...ctx.resolved.get(name),
-			dark: variant
-		});
-	}
-	const darkHCMap = /* @__PURE__ */ new Map();
-	for (const name of order) ctx.resolved.set(name, {
-		...ctx.resolved.get(name),
-		darkContrast: darkMap.get(name)
-	});
+	return out;
+}
+/**
+* Re-seed a single variant slot with a previously-resolved map so the
+* upcoming pass reads sensible fallbacks via `getSchemeVariant`.
+*/
+function seedField(order, ctx, field, source) {
 	for (const name of order) {
-		const variant = resolveColorForScheme(name, defs[name], ctx, true, true);
-		darkHCMap.set(name, variant);
+		const existing = ctx.resolved.get(name);
 		ctx.resolved.set(name, {
-			...ctx.resolved.get(name),
-			darkContrast: variant
+			...existing,
+			[field]: source.get(name)
 		});
 	}
+}
+function resolveAllColors(hue, saturation, defs, scaling, externalBases, overrideAutoFlip) {
+	validateColorDefs(defs, externalBases);
+	const order = topoSort(defs);
+	const cfg = getConfig();
+	const ctx = {
+		hue,
+		saturation,
+		defs,
+		resolved: /* @__PURE__ */ new Map(),
+		scaling,
+		autoFlip: overrideAutoFlip ?? cfg.autoFlip
+	};
+	if (externalBases) for (const [name, color] of externalBases) ctx.resolved.set(name, color);
+	const lightMap = runPass(order, defs, ctx, false, false, "light");
+	seedField(order, ctx, "lightContrast", lightMap);
+	const lightHCMap = runPass(order, defs, ctx, false, true, "lightContrast");
+	seedField(order, ctx, "dark", lightMap);
+	seedField(order, ctx, "darkContrast", lightHCMap);
+	const darkMap = runPass(order, defs, ctx, true, false, "dark");
+	seedField(order, ctx, "darkContrast", darkMap);
+	const darkHCMap = runPass(order, defs, ctx, true, true, "darkContrast");
 	const result = /* @__PURE__ */ new Map();
 	for (const name of order) result.set(name, {
 		name,
@@ -1484,6 +1570,19 @@ function resolveAllColors(hue, saturation, defs, scaling, externalBases) {
 	});
 	return result;
 }
+
+//#endregion
+//#region src/formatters.ts
+/**
+* Output formatting for resolved color maps.
+*
+* Owns the CSS-string formatter dispatch table (`okhsl` / `rgb` / `hsl` /
+* `oklch`) and the four token-map shapes Glaze emits:
+* - `buildTokenMap` — Tasty style-to-state bindings (`#name` keys, state aliases).
+* - `buildFlatTokenMap` — `{ light, dark, ... }` per-variant maps.
+* - `buildJsonMap` — `{ name: { light, dark, ... } }` per-color JSON.
+* - `buildCssMap` — CSS custom property declaration strings per variant.
+*/
 const formatters = {
 	okhsl: formatOkhsl,
 	rgb: formatRgb,
@@ -1500,9 +1599,10 @@ function formatVariant(v, format = "okhsl") {
 	return `${base.slice(0, closing)} / ${fmt(v.alpha, 4)})`;
 }
 function resolveModes(override) {
+	const cfg = getConfig();
 	return {
-		dark: override?.dark ?? globalConfig.modes.dark,
-		highContrast: override?.highContrast ?? globalConfig.modes.highContrast
+		dark: override?.dark ?? cfg.modes.dark,
+		highContrast: override?.highContrast ?? cfg.modes.highContrast
 	};
 }
 function buildTokenMap(resolved, prefix, states, modes, format = "okhsl") {
@@ -1563,206 +1663,74 @@ function buildCssMap(resolved, prefix, suffix, format) {
 		darkContrast: lines.darkContrast.join("\n")
 	};
 }
-function createTheme(hue, saturation, initialColors) {
-	let colorDefs = initialColors ? { ...initialColors } : {};
+
+//#endregion
+//#region src/color-token.ts
+/**
+* Standalone single-color tokens (`glaze.color()` / `glaze.colorFrom()`).
+*
+* Owns the value-shorthand parser (hex, `rgb()` / `hsl()` / `okhsl()` /
+* `oklch()`, OkhslColor object, [r, g, b] tuple), the structured-input
+* validator, the two factory paths (value vs structured), and the
+* JSON-safe export / rehydration round-trip.
+*
+* Standalone tokens snapshot the relevant `globalConfig` fields at
+* create time so later `configure()` calls do not retroactively change
+* exported tokens — the snapshot is captured eagerly in
+* `defaultStandaloneScaling()`. The token's resolved variants are then
+* memoized on first `.resolve()` / `.token()` / ... call.
+*/
+/** 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";
+/** Reserved internal names that user-supplied `name` must not collide with. */
+const RESERVED_STANDALONE_NAMES = new Set([
+	STANDALONE_VALUE,
+	STANDALONE_SEED,
+	STANDALONE_BASE
+]);
+/**
+* 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) {
+	const cfg = getConfig();
+	if (isString) {
+		const [darkLo] = cfg.darkLightness;
+		return {
+			lightLightness: false,
+			darkLightness: [darkLo, 100]
+		};
+	}
 	return {
-		get hue() {
-			return hue;
-		},
-		get saturation() {
-			return saturation;
-		},
-		colors(defs) {
-			colorDefs = {
-				...colorDefs,
-				...defs
-			};
-		},
-		color(name, def) {
-			if (def === void 0) return colorDefs[name];
-			colorDefs[name] = def;
-		},
-		remove(names) {
-			const list = Array.isArray(names) ? names : [names];
-			for (const name of list) delete colorDefs[name];
-		},
-		has(name) {
-			return name in colorDefs;
-		},
-		list() {
-			return Object.keys(colorDefs);
-		},
-		reset() {
-			colorDefs = {};
-		},
-		export() {
-			return {
-				hue,
-				saturation,
-				colors: { ...colorDefs }
-			};
-		},
-		extend(options) {
-			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
-			} : { ...inheritedColors });
-		},
-		resolve() {
-			return resolveAllColors(hue, saturation, colorDefs);
-		},
-		tokens(options) {
-			return buildFlatTokenMap(resolveAllColors(hue, saturation, colorDefs), "", resolveModes(options?.modes), options?.format);
-		},
-		tasty(options) {
-			return buildTokenMap(resolveAllColors(hue, saturation, colorDefs), "", {
-				dark: options?.states?.dark ?? globalConfig.states.dark,
-				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
-			}, resolveModes(options?.modes), options?.format);
-		},
-		json(options) {
-			return buildJsonMap(resolveAllColors(hue, saturation, colorDefs), resolveModes(options?.modes), options?.format);
-		},
-		css(options) {
-			return buildCssMap(resolveAllColors(hue, saturation, colorDefs), "", options?.suffix ?? "-color", options?.format ?? "rgb");
-		}
+		lightLightness: cfg.lightLightness,
+		darkLightness: cfg.darkLightness
 	};
 }
-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 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.
+* 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 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 isGlazeColorToken(candidate) {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && "resolve" in candidate && typeof candidate.resolve === "function";
 }
-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 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 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;
-		},
-		json(options) {
-			const modes = resolveModes(options?.modes);
-			const result = {};
-			for (const [themeName, theme] of Object.entries(themes)) result[themeName] = buildJsonMap(theme.resolve(), modes, options?.format);
-			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 = {
-				light: [],
-				dark: [],
-				lightContrast: [],
-				darkContrast: []
-			};
-			const seen = /* @__PURE__ */ new Map();
-			for (const [themeName, theme] of Object.entries(themes)) {
-				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"),
-				dark: allLines.dark.join("\n"),
-				lightContrast: allLines.lightContrast.join("\n"),
-				darkContrast: allLines.darkContrast.join("\n")
-			};
-		}
-	};
+function isStructuredColorInput(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input) && "hue" in input && "lightness" in input;
 }
 /**
 * Matches the CSS color functions Glaze itself emits (`rgb()`, `hsl()`,
@@ -1881,9 +1849,7 @@ function validateOkhslColor(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.
-*/
+/** 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(", ")}]).`);
 }
@@ -2002,17 +1968,20 @@ function buildStandaloneValueDefs(main, options) {
 		primary
 	};
 }
-function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, effectiveScaling, baseToken, exportData) {
+function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, effectiveScaling, baseToken, exportData, autoFlip) {
 	let cached;
 	const resolveOnce = () => {
 		if (cached) return cached;
-		cached = resolveAllColors(seedHue, seedSaturation, defs, effectiveScaling, baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0);
+		cached = resolveAllColors(seedHue, seedSaturation, defs, effectiveScaling, baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0, autoFlip);
 		return cached;
 	};
-	const resolveStates = (options) => ({
-		dark: options?.states?.dark ?? globalConfig.states.dark,
-		highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
-	});
+	const resolveStates = (options) => {
+		const cfg = getConfig();
+		return {
+			dark: options?.states?.dark ?? cfg.states.dark,
+			highContrast: options?.states?.highContrast ?? cfg.states.highContrast
+		};
+	};
 	const tokenLike = (options) => {
 		return buildTokenMap(resolveOnce(), "", resolveStates(options), resolveModes(options?.modes), options?.format)[`#${primary}`];
 	};
@@ -2042,39 +2011,7 @@ function resolveBaseToken(base) {
 	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) {
+function createColorToken(input, scaling, overrideAutoFlip) {
 	validateStructuredInput(input);
 	const userName = input.name;
 	if (userName !== void 0) validateStandaloneName(userName);
@@ -2096,40 +2033,70 @@ function createColorToken(input, scaling) {
 		mode: "static"
 	};
 	const effectiveScaling = scaling ?? defaultStandaloneScaling(false);
+	const autoFlip = overrideAutoFlip ?? getConfig().autoFlip;
 	const exportData = () => ({
 		form: "structured",
 		input: buildStructuredInputExport(input),
-		scaling: effectiveScaling
+		scaling: effectiveScaling,
+		autoFlip
 	});
-	return createColorTokenFromDefs(input.hue, input.saturation, defs, primary, effectiveScaling, baseToken, exportData);
+	return createColorTokenFromDefs(input.hue, input.saturation, defs, primary, effectiveScaling, baseToken, exportData, autoFlip);
 }
-function createColorTokenFromValue(value, options, scaling) {
+function createColorTokenFromValue(value, options, scaling, overrideAutoFlip) {
 	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 autoFlip = overrideAutoFlip ?? getConfig().autoFlip;
 	const exportData = () => ({
 		form: "value",
 		input: value,
 		...options !== void 0 ? { overrides: buildOverridesExport(options) } : {},
-		scaling: effectiveScaling
+		scaling: effectiveScaling,
+		autoFlip
 	});
-	return createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, effectiveScaling, baseToken, exportData);
+	return createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, effectiveScaling, baseToken, exportData, autoFlip);
 }
 /**
-* Rehydrate a token from its `.export()` snapshot. Recursively rebuilds
-* any base dependency. Inverse of `GlazeColorToken.export()`.
+* 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 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 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;
+}
+/**
+* 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");
 }
 function rehydrateOverrides(data) {
 	const out = {};
@@ -2159,13 +2126,264 @@ function rehydrateStructuredInput(data) {
 	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.
+* Rehydrate a token from its `.export()` snapshot. Recursively rebuilds
+* any base dependency. Inverse of `GlazeColorToken.export()`.
 */
-function isExportedToken(candidate) {
-	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && "form" in candidate && (candidate.form === "value" || candidate.form === "structured");
+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;
+		const overrides = data.overrides ? rehydrateOverrides(data.overrides) : void 0;
+		const cfg = getConfig();
+		const effectiveAutoFlip = data.autoFlip ?? cfg.autoFlip;
+		return createColorTokenFromValue(value, overrides, data.scaling, effectiveAutoFlip);
+	}
+	const input = rehydrateStructuredInput(data.input);
+	const cfg = getConfig();
+	const effectiveAutoFlip = data.autoFlip ?? cfg.autoFlip;
+	return createColorToken(input, data.scaling, effectiveAutoFlip);
 }
+
+//#endregion
+//#region src/palette.ts
+/**
+* Palette factory.
+*
+* Composes multiple themes into a single token namespace with optional
+* theme-name prefixes and a "primary theme" that also surfaces an
+* unprefixed copy of its tokens. All four export methods (`tokens` /
+* `tasty` / `json` / `css`) share a `buildPaletteOutput` driver that
+* handles validation, per-theme iteration, prefix resolution, collision
+* filtering, and primary duplication.
+*/
+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 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;
+}
+/**
+* Shared per-theme driver for `tokens` / `tasty` / `css`. `json` skips
+* this because it doesn't do collision filtering or primary duplication.
+*/
+function buildPaletteOutput(themes, paletteOptions, options, buildOne, merge, empty) {
+	const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+	if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
+	const acc = empty();
+	const seen = /* @__PURE__ */ new Map();
+	for (const [themeName, theme] of Object.entries(themes)) {
+		const resolved = theme.resolve();
+		const prefix = resolvePrefix(options, themeName, true);
+		merge(acc, buildOne(filterCollisions(resolved, prefix, seen, themeName), prefix));
+		if (themeName === effectivePrimary) merge(acc, buildOne(filterCollisions(resolved, "", seen, themeName, true), ""));
+	}
+	return acc;
+}
+function createPalette(themes, paletteOptions) {
+	validatePrimaryTheme(paletteOptions?.primary, themes);
+	return {
+		tokens(options) {
+			const modes = resolveModes(options?.modes);
+			return buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix) => buildFlatTokenMap(filtered, prefix, modes, options?.format), (acc, part) => {
+				for (const variant of Object.keys(part)) {
+					if (!acc[variant]) acc[variant] = {};
+					Object.assign(acc[variant], part[variant]);
+				}
+			}, () => ({}));
+		},
+		tasty(options) {
+			const cfg = getConfig();
+			const states = {
+				dark: options?.states?.dark ?? cfg.states.dark,
+				highContrast: options?.states?.highContrast ?? cfg.states.highContrast
+			};
+			const modes = resolveModes(options?.modes);
+			return buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix) => buildTokenMap(filtered, prefix, states, modes, options?.format), (acc, part) => Object.assign(acc, part), () => ({}));
+		},
+		json(options) {
+			const modes = resolveModes(options?.modes);
+			const result = {};
+			for (const [themeName, theme] of Object.entries(themes)) result[themeName] = buildJsonMap(theme.resolve(), modes, options?.format);
+			return result;
+		},
+		css(options) {
+			const suffix = options?.suffix ?? "-color";
+			const format = options?.format ?? "rgb";
+			const lines = buildPaletteOutput(themes, paletteOptions, options, (filtered, prefix) => buildCssMap(filtered, prefix, suffix, format), (acc, part) => {
+				for (const key of [
+					"light",
+					"dark",
+					"lightContrast",
+					"darkContrast"
+				]) if (part[key]) acc[key].push(part[key]);
+			}, () => ({
+				light: [],
+				dark: [],
+				lightContrast: [],
+				darkContrast: []
+			}));
+			return {
+				light: lines.light.join("\n"),
+				dark: lines.dark.join("\n"),
+				lightContrast: lines.lightContrast.join("\n"),
+				darkContrast: lines.darkContrast.join("\n")
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/theme.ts
+/**
+* Theme factory.
+*
+* Wraps a hue/saturation seed and a mutable `ColorMap`, and exposes
+* `tokens()` / `tasty()` / `json()` / `css()` / `resolve()` / `export()`
+* / `extend()`. Caches the last resolve result so successive exports
+* with the same defs and config don't re-run the four-pass resolver.
+*/
+function createTheme(hue, saturation, initialColors) {
+	let colorDefs = initialColors ? { ...initialColors } : {};
+	let cache = null;
+	function resolveCached() {
+		const version = getConfigVersion();
+		if (cache && cache.version === version) return cache.map;
+		const map = resolveAllColors(hue, saturation, colorDefs);
+		cache = {
+			map,
+			version
+		};
+		return map;
+	}
+	function invalidate() {
+		cache = null;
+	}
+	return {
+		get hue() {
+			return hue;
+		},
+		get saturation() {
+			return saturation;
+		},
+		colors(defs) {
+			colorDefs = {
+				...colorDefs,
+				...defs
+			};
+			invalidate();
+		},
+		color(name, def) {
+			if (def === void 0) return colorDefs[name];
+			colorDefs[name] = def;
+			invalidate();
+		},
+		remove(names) {
+			const list = Array.isArray(names) ? names : [names];
+			for (const name of list) delete colorDefs[name];
+			invalidate();
+		},
+		has(name) {
+			return name in colorDefs;
+		},
+		list() {
+			return Object.keys(colorDefs);
+		},
+		reset() {
+			colorDefs = {};
+			invalidate();
+		},
+		export() {
+			return {
+				hue,
+				saturation,
+				colors: { ...colorDefs }
+			};
+		},
+		extend(options) {
+			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
+			} : { ...inheritedColors });
+		},
+		resolve() {
+			return new Map(resolveCached());
+		},
+		tokens(options) {
+			const modes = resolveModes(options?.modes);
+			return buildFlatTokenMap(resolveCached(), "", modes, options?.format);
+		},
+		tasty(options) {
+			const cfg = getConfig();
+			const states = {
+				dark: options?.states?.dark ?? cfg.states.dark,
+				highContrast: options?.states?.highContrast ?? cfg.states.highContrast
+			};
+			const modes = resolveModes(options?.modes);
+			return buildTokenMap(resolveCached(), "", states, modes, options?.format);
+		},
+		json(options) {
+			const modes = resolveModes(options?.modes);
+			return buildJsonMap(resolveCached(), modes, options?.format);
+		},
+		css(options) {
+			return buildCssMap(resolveCached(), "", options?.suffix ?? "-color", options?.format ?? "rgb");
+		}
+	};
+}
+
+//#endregion
+//#region src/glaze.ts
+/**
+* Glaze — OKHSL-based color theme generator.
+*
+* Public API entry. Wires `glaze()` and its attached static methods to
+* the focused modules in this folder:
+* - `theme.ts` — single-theme factory
+* - `palette.ts` — multi-theme composition
+* - `color-token.ts` — standalone single-color tokens (`glaze.color`)
+* - `shadow.ts` — standalone shadow factory (`glaze.shadow`)
+* - `formatters.ts` — variant → string (`glaze.format`)
+* - `config.ts` — global config singleton
+*/
 /**
 * Create a single-hue glaze theme.
 *
@@ -2180,41 +2398,18 @@ function glaze(hueOrOptions, saturation) {
 	if (typeof hueOrOptions === "number") return createTheme(hueOrOptions, saturation ?? 100);
 	return createTheme(hueOrOptions.hue, hueOrOptions.saturation);
 }
-/**
-* Configure global glaze settings.
-*/
-glaze.configure = function configure(config) {
-	globalConfig = {
-		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
-		},
-		modes: {
-			dark: config.modes?.dark ?? globalConfig.modes.dark,
-			highContrast: config.modes?.highContrast ?? globalConfig.modes.highContrast
-		},
-		shadowTuning: config.shadowTuning ?? globalConfig.shadowTuning
-	};
+/** Configure global glaze settings. */
+glaze.configure = function configure$1(config) {
+	configure(config);
 };
-/**
-* Compose multiple themes into a palette.
-*/
+/** Compose multiple themes into a palette. */
 glaze.palette = function palette(themes, options) {
 	return createPalette(themes, options);
 };
-/**
-* Create a theme from a serialized export.
-*/
+/** Create a theme from a serialized export. */
 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.
 *
@@ -2278,9 +2473,7 @@ glaze.shadow = function shadow(input) {
 		alpha: 1
 	} : void 0, input.intensity, tuning);
 };
-/**
-* Format a resolved color variant as a CSS string.
-*/
+/** Format a resolved color variant as a CSS string. */
 glaze.format = function format(variant, colorFormat) {
 	return formatVariant(variant, colorFormat);
 };
@@ -2326,30 +2519,13 @@ glaze.fromRgb = function fromRgb(r, g, b) {
 glaze.colorFrom = function colorFrom(data) {
 	return colorFromExport(data);
 };
-/**
-* Get the current global configuration (for testing/debugging).
-*/
+/** Get the current global configuration (for testing/debugging). */
 glaze.getConfig = function getConfig() {
-	return { ...globalConfig };
+	return snapshotConfig();
 };
-/**
-* Reset global configuration to defaults.
-*/
-glaze.resetConfig = function resetConfig() {
-	globalConfig = {
-		lightLightness: [10, 100],
-		darkLightness: [15, 95],
-		darkDesaturation: .1,
-		darkCurve: .5,
-		states: {
-			dark: "@dark",
-			highContrast: "@high-contrast"
-		},
-		modes: {
-			dark: true,
-			highContrast: false
-		}
-	};
+/** Reset global configuration to defaults. */
+glaze.resetConfig = function resetConfig$1() {
+	resetConfig();
 };
 
 //#endregion