@tenphi/glaze 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -1977,34 +1977,77 @@ function resolveContrastSpec(spec, isHighContrast, polarity) {
 /**
 * Apply the relative-tone delta against a base, honoring `flip`.
 *
-* When `flip` is on and `base + delta` falls outside `[0, 100]`, mirror the
-* delta to the other side of the base (so an offset that would clamp instead
-* reflects back into range). When off, the caller clamps as usual.
+* When `flip` is on and `base + delta` falls outside `[0, 100]`, try mirroring
+* the delta to the other side of the base. If the mirrored target is also out
+* of range, keep the original delta so the caller clamps on the authored side.
+* When off, the caller clamps as usual.
 */
 function applyToneFlip(delta, baseTone, flip) {
 	if (!flip) return delta;
 	const target = baseTone + delta;
 	if (target >= 0 && target <= 100) return delta;
-	return -delta;
+	const mirrored = baseTone - delta;
+	if (mirrored >= 0 && mirrored <= 100) return -delta;
+	return delta;
+}
+/**
+* Dark position for an extreme tone (`'max'` / `'min'`) anchored to a base.
+*
+* A windowed dark remap compresses the base→extreme span, so the pair loses
+* contrast in dark. Instead, measure the tone shift the light scheme applied
+* between the base and the extreme, then replay it against the base's dark
+* tone: `auto` mirrors the sign (both ends invert), `fixed` keeps it. The
+* result is clamped to `[0, 100]` only — crossing the dark tone window is
+* intended, since the author asked for the extreme.
+*/
+function extremeDarkTone(authorTone, mode, isHighContrast, baseResolved, baseDarkTone, config) {
+	const delta = mapToneForScheme(authorTone, mode, false, isHighContrast, config) - getSchemeVariant(baseResolved, false, isHighContrast).t * 100;
+	return clamp(baseDarkTone + (mode === "auto" ? -delta : delta), 0, 100);
 }
 function resolveRootColor(def, isHighContrast) {
 	const rawT = def.tone;
+	return clamp(parseToneValue(isHighContrast ? pairHC(rawT) : pairNormal(rawT)).value, 0, 100);
+}
+/**
+* Effective hue and saturation for one color in one scheme.
+*
+* Dark schemes read the dark seed pair and the color's `darkHue` /
+* `darkSaturation`, each falling back to its light counterpart. An explicit
+* dark saturation — on the seed or the def — is taken literally; the global
+* `darkDesaturation` reduction applies only when neither is authored.
+* `mode: 'static'` pins one value across every scheme, so it skips all of it.
+*
+* Shared by `resolveColorForScheme` (the emitted variant) and
+* `resolveDependentColor` (the contrast solver's inputs) so the solver always
+* measures the color it is actually going to produce.
+*/
+function resolveChannels(def, ctx, isDark) {
+	const mode = def.mode ?? "auto";
+	const satFactor = clamp(def.saturation ?? 1, 0, 1);
+	if (!isDark || mode === "static") return {
+		hue: resolveEffectiveHue(ctx.hue, def.hue),
+		saturation: clamp(satFactor * ctx.saturation / 100, 0, 1)
+	};
+	const darkSeedSaturation = ctx.darkSaturation ?? ctx.saturation;
+	const darkFactor = clamp(def.darkSaturation ?? satFactor, 0, 1);
+	const explicitDark = def.darkSaturation !== void 0 || ctx.darkSaturation !== void 0;
+	const raw = darkFactor * darkSeedSaturation / 100;
 	return {
-		authorTone: clamp(parseToneValue(isHighContrast ? pairHC(rawT) : pairNormal(rawT)).value, 0, 100),
-		satFactor: clamp(def.saturation ?? 1, 0, 1)
+		hue: resolveEffectiveHue(ctx.darkHue ?? ctx.hue, def.darkHue ?? def.hue),
+		saturation: clamp(explicitDark ? raw : mapSaturationDark(raw, mode, ctx.config), 0, 1)
 	};
 }
-function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effectiveHue, polarity, effectivePastel) {
+function resolveDependentColor(name, def, ctx, isHighContrast, isDark, channels, polarity, effectivePastel) {
 	const baseName = def.base;
 	const baseResolved = ctx.resolved.get(baseName);
 	if (!baseResolved) throw new Error(`glaze: base "${baseName}" not yet resolved for "${name}".`);
 	const mode = def.mode ?? "auto";
-	const satFactor = clamp(def.saturation ?? 1, 0, 1);
 	const flip = def.autoFlip ?? ctx.config.autoFlip;
 	const pastel = effectivePastel;
 	const baseVariant = getSchemeVariant(baseResolved, isDark, isHighContrast);
 	const baseTone = baseVariant.t * 100;
 	let preferredTone;
+	let isExtreme = false;
 	const rawTone = def.tone;
 	if (rawTone === void 0) preferredTone = baseTone;
 	else {
@@ -2013,22 +2056,28 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 			const baseLightTone = getSchemeVariant(baseResolved, false, isHighContrast).t * 100;
 			preferredTone = mapToneForScheme(clamp(baseLightTone + applyToneFlip(parsed.value, baseLightTone, flip), 0, 100), "auto", true, isHighContrast, ctx.config);
 		} else preferredTone = clamp(baseTone + applyToneFlip(parsed.value, baseTone, flip), 0, 100);
-		else preferredTone = mapToneForScheme(parsed.value, mode, isDark, isHighContrast, ctx.config);
+		else if (parsed.kind === "extreme" && isDark && mode !== "static") {
+			isExtreme = true;
+			preferredTone = extremeDarkTone(parsed.value, mode, isHighContrast, baseResolved, baseTone, ctx.config);
+		} else {
+			isExtreme = parsed.kind === "extreme";
+			preferredTone = mapToneForScheme(parsed.value, mode, isDark, isHighContrast, ctx.config);
+		}
 	}
 	const rawContrast = def.contrast;
 	if (rawContrast !== void 0) {
 		const resolvedContrast = resolveContrastSpec(rawContrast, isHighContrast, polarity);
-		const effectiveSat = isDark ? mapSaturationDark(satFactor * ctx.saturation / 100, mode, ctx.config) : satFactor * ctx.saturation / 100;
 		const baseOkhsl = toOkhslVariant(baseVariant);
 		const baseLinearRgb = okhslToLinearSrgb(baseOkhsl.h, baseOkhsl.s, baseOkhsl.l, baseVariant.pastel ?? ctx.config.pastel);
 		const toneRange = schemeToneRange(isDark, mode, isHighContrast, ctx.config);
 		let initialDirection;
 		if (preferredTone < baseTone) initialDirection = "darker";
 		else if (preferredTone > baseTone) initialDirection = "lighter";
+		const seedTone = isExtreme ? clamp(preferredTone / 100, 0, 1) : clamp(preferredTone / 100, toneRange[0], toneRange[1]);
 		const result = findToneForContrast({
-			hue: effectiveHue,
-			saturation: effectiveSat,
-			preferredTone: clamp(preferredTone / 100, toneRange[0], toneRange[1]),
+			hue: channels.hue,
+			saturation: channels.saturation,
+			preferredTone: seedTone,
 			baseLinearRgb,
 			contrast: resolvedContrast,
 			toneRange: [0, 1],
@@ -2037,15 +2086,9 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 			pastel
 		});
 		if (!result.met) warnContrastUnmet(name, isDark, isHighContrast, resolvedContrast, result.contrast);
-		return {
-			tone: result.tone * 100,
-			satFactor
-		};
+		return result.tone * 100;
 	}
-	return {
-		tone: clamp(preferredTone, 0, 100),
-		satFactor
-	};
+	return clamp(preferredTone, 0, 100);
 }
 function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
 	if (isShadowDef(def)) return resolveShadowForScheme(def, ctx, isDark, isHighContrast);
@@ -2053,27 +2096,14 @@ function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
 	const regDef = def;
 	const mode = regDef.mode ?? "auto";
 	const isRoot = isAbsoluteTone(regDef.tone) && !regDef.base;
-	const effectiveHue = resolveEffectiveHue(ctx.hue, regDef.hue);
+	const channels = resolveChannels(regDef, ctx, isDark);
 	const polarity = roleToPolarity(resolveRole(name, def, ctx));
 	const pastel = regDef.pastel ?? ctx.config.pastel;
-	let finalTone;
-	let satFactor;
-	if (isRoot) {
-		const root = resolveRootColor(regDef, isHighContrast);
-		finalTone = mapToneForScheme(root.authorTone, mode, isDark, isHighContrast, ctx.config);
-		satFactor = root.satFactor;
-	} else {
-		const dep = resolveDependentColor(name, regDef, ctx, isHighContrast, isDark, effectiveHue, polarity, pastel);
-		finalTone = dep.tone;
-		satFactor = dep.satFactor;
-	}
-	const baseSat = satFactor * ctx.saturation / 100;
-	const finalSat = isDark ? mapSaturationDark(baseSat, mode, ctx.config) : baseSat;
-	const toneFraction = clamp(finalTone / 100, 0, 1);
+	const finalTone = isRoot ? mapToneForScheme(resolveRootColor(regDef, isHighContrast), mode, isDark, isHighContrast, ctx.config) : resolveDependentColor(name, regDef, ctx, isHighContrast, isDark, channels, polarity, pastel);
 	return {
-		h: effectiveHue,
-		s: clamp(finalSat, 0, 1),
-		t: toneFraction,
+		h: channels.hue,
+		s: channels.saturation,
+		t: clamp(finalTone / 100, 0, 1),
 		alpha: regDef.opacity ?? 1,
 		pastel
 	};
@@ -2273,12 +2303,11 @@ function verifyContrastDrift(order, defs, result, config) {
 		}
 	}
 }
-function resolveAllColors(hue, saturation, defs, config, externalBases) {
+function resolveAllColors(seed, defs, config, externalBases) {
 	validateColorDefs(defs, externalBases);
 	const order = topoSort(defs);
 	const ctx = {
-		hue,
-		saturation,
+		...seed,
 		defs,
 		resolved: /* @__PURE__ */ new Map(),
 		config,
@@ -2311,8 +2340,12 @@ function resolveAllColors(hue, saturation, defs, config, externalBases) {
 /**
 * Hue channel planning for `splitHue` exports.
 *
-* Builds per-color hue var references and scheme-independent `--*-hue`
-* declarations for oklch CSS / Tasty output when every color is pastel.
+* Builds per-color hue var references and the `--*-hue` declarations backing
+* them for oklch CSS / Tasty output when every color is pastel.
+*
+* Hue is scheme-independent unless the theme or a color authors a dark hue,
+* so declarations are collected per scheme (`'light'` / `'dark'`) and the dark
+* set is emitted only when it actually differs — see `darkHueDeclarations`.
 */
 const ACHROMATIC_EPSILON = 1e-6;
 function cssProp(prefix, name, suffix) {
@@ -2321,7 +2354,11 @@ function cssProp(prefix, name, suffix) {
 function isAchromatic(v) {
 	return v.s <= ACHROMATIC_EPSILON;
 }
-function themeHuePlan(name, def, variant, ctx) {
+/** Seed hue backing `--{baseName}-hue` in a given scheme. */
+function schemeSeedHue(ctx, scheme) {
+	return scheme === "dark" ? ctx.darkSeedHue ?? ctx.seedHue : ctx.seedHue;
+}
+function themeHuePlan(name, def, variant, ctx, scheme) {
 	if (def === void 0 || isShadowDef(def) || isMixDef(def) || isAchromatic(variant)) return {
 		hueVar: "",
 		inline: true,
@@ -2329,13 +2366,25 @@ function themeHuePlan(name, def, variant, ctx) {
 	};
 	const regDef = def;
 	const baseHueVar = `var(--${ctx.baseName}-hue)`;
-	if (regDef.hue === void 0) return {
+	const prop = cssProp(ctx.prefix, name, "-hue");
+	if ((regDef.mode ?? "auto") === "static" && schemeSeedHue(ctx, "dark") !== ctx.seedHue) {
+		const pinned = resolveEffectiveHue(ctx.seedHue, regDef.hue);
+		return {
+			hueVar: `var(${prop})`,
+			inline: false,
+			declarations: [{
+				prop,
+				value: String(pinned)
+			}]
+		};
+	}
+	const authored = scheme === "dark" ? regDef.darkHue ?? regDef.hue : regDef.hue;
+	if (authored === void 0) return {
 		hueVar: baseHueVar,
 		inline: false,
 		declarations: []
 	};
-	const parsed = parseRelativeOrAbsolute(regDef.hue);
-	const prop = cssProp(ctx.prefix, name, "-hue");
+	const parsed = parseRelativeOrAbsolute(authored);
 	if (parsed.relative) {
 		const sign = parsed.value >= 0 ? "+" : "-";
 		const magnitude = Math.abs(parsed.value);
@@ -2359,13 +2408,13 @@ function themeHuePlan(name, def, variant, ctx) {
 		}]
 	};
 }
-function standaloneHuePlan(name, variant, ctx) {
+function standaloneHuePlan(name, variant, ctx, scheme) {
 	if (isAchromatic(variant)) return {
 		hueVar: "",
 		inline: true,
 		declarations: []
 	};
-	const hue = ctx.resolvedHue ?? variant.h;
+	const hue = scheme === "dark" ? variant.h : ctx.resolvedHue ?? variant.h;
 	const prop = cssProp(ctx.prefix, name, "-hue");
 	return {
 		hueVar: `var(${prop})`,
@@ -2376,12 +2425,12 @@ function standaloneHuePlan(name, variant, ctx) {
 		}]
 	};
 }
-function buildHuePlan(name, def, variant, ctx) {
-	if (ctx.mode === "standalone") return standaloneHuePlan(name, variant, ctx);
-	return themeHuePlan(name, def, variant, ctx);
+function buildHuePlan(name, def, variant, ctx, scheme = "light") {
+	if (ctx.mode === "standalone") return standaloneHuePlan(name, variant, ctx, scheme);
+	return themeHuePlan(name, def, variant, ctx, scheme);
 }
 /** Collect unique hue declarations across all colors (theme + per-color). */
-function collectHueDeclarations(resolved, ctx) {
+function collectHueDeclarations(resolved, ctx, scheme = "light") {
 	if (ctx.emitDeclarations === false) return [];
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -2392,15 +2441,32 @@ function collectHueDeclarations(resolved, ctx) {
 	};
 	if (ctx.mode === "theme") push({
 		prop: `--${ctx.baseName}-hue`,
-		value: String(ctx.seedHue)
+		value: String(schemeSeedHue(ctx, scheme))
 	});
 	for (const [name, color] of resolved) {
 		const def = ctx.defs[name];
-		const plan = buildHuePlan(name, def, color.light, ctx);
+		const plan = buildHuePlan(name, def, scheme === "dark" ? color.dark : color.light, ctx, scheme);
 		for (const decl of plan.declarations) push(decl);
 	}
 	return out;
 }
+/**
+* Dark-scheme hue declarations, or `[]` when dark resolves to the same hues as
+* light (the common case — no `darkHue` anywhere).
+*
+* When they differ, the **whole** set is returned rather than only the entries
+* whose text changed. A relative declaration reads
+* `calc(var(--theme-hue) + N)` in both schemes even though its resolved value
+* moves with the seed, and custom properties substitute `var()` at
+* computed-value time on the declaring element — so re-declaring
+* `--{baseName}-hue` alone would leave inherited per-color vars still holding
+* the light-substituted value.
+*/
+function darkHueDeclarations(resolved, ctx) {
+	const dark = collectHueDeclarations(resolved, ctx, "dark");
+	const light = collectHueDeclarations(resolved, ctx, "light");
+	return dark.length === light.length && dark.every((decl, i) => decl.prop === light[i].prop && decl.value === light[i].value) ? [] : dark;
+}
 function buildHuePlans(resolved, ctx) {
 	const plans = /* @__PURE__ */ new Map();
 	for (const [name, color] of resolved) plans.set(name, buildHuePlan(name, ctx.defs[name], color.light, ctx));
@@ -2474,17 +2540,15 @@ function buildTokenMap(resolved, prefix, states, modes, format = "oklch", pastel
 	const tokens = {};
 	const huePlans = channelCtx !== void 0 && format === "oklch" ? buildHuePlans(resolved, channelCtx) : void 0;
 	if (huePlans !== void 0 && channelCtx !== void 0) {
-		const emitDecls = channelCtx.emitDeclarations !== false;
-		if (emitDecls && channelCtx.mode === "theme") tokens[`$${channelCtx.baseName}-hue`] = { "": String(channelCtx.seedHue) };
-		for (const [name, color] of resolved) {
-			const plan = huePlans.get(name);
-			if (emitDecls) for (const decl of plan.declarations) {
-				const key = `$${decl.prop.slice(2)}`;
-				if (!(key in tokens)) tokens[key] = { "": decl.value };
-			}
-			const colorKey = `#${prefix}${name}`;
-			tokens[colorKey] = buildTokenEntry(color, states, modes, format, pastel, huePlans.get(name));
+		for (const decl of collectHueDeclarations(resolved, channelCtx)) tokens[`$${decl.prop.slice(2)}`] = { "": decl.value };
+		if (modes.dark) for (const decl of darkHueDeclarations(resolved, channelCtx)) {
+			const key = `$${decl.prop.slice(2)}`;
+			tokens[key] = {
+				...tokens[key],
+				[states.dark]: decl.value
+			};
 		}
+		for (const [name, color] of resolved) tokens[`#${prefix}${name}`] = buildTokenEntry(color, states, modes, format, pastel, huePlans.get(name));
 		return tokens;
 	}
 	for (const [name, color] of resolved) {
@@ -2533,7 +2597,13 @@ function buildCssMap(resolved, prefix, suffix, format, pastel = false, channelCt
 		darkContrast: []
 	};
 	const huePlans = channelCtx !== void 0 && format === "oklch" ? buildHuePlans(resolved, channelCtx) : void 0;
-	if (huePlans !== void 0 && channelCtx !== void 0) for (const decl of collectHueDeclarations(resolved, channelCtx)) lines.light.push(`${decl.prop}: ${decl.value};`);
+	if (huePlans !== void 0 && channelCtx !== void 0) {
+		for (const decl of collectHueDeclarations(resolved, channelCtx)) lines.light.push(`${decl.prop}: ${decl.value};`);
+		for (const decl of darkHueDeclarations(resolved, channelCtx)) {
+			lines.dark.push(`${decl.prop}: ${decl.value};`);
+			lines.darkContrast.push(`${decl.prop}: ${decl.value};`);
+		}
+	}
 	for (const [name, color] of resolved) {
 		const prop = `--${prefix}${name}${suffix}`;
 		const plan = huePlans?.get(name);
@@ -2970,6 +3040,13 @@ function validateStructuredInput(input) {
 	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 (typeof input.darkHue === "number" && !Number.isFinite(input.darkHue)) throw new Error(`glaze.color: structured darkHue must be a finite number (got ${input.darkHue}).`);
+	if (input.darkSaturation !== void 0) {
+		if (!Number.isFinite(input.darkSaturation) || input.darkSaturation < 0 || input.darkSaturation > 100) throw new Error(`glaze.color: structured darkSaturation must be a finite number in 0–100 (got ${input.darkSaturation}).`);
+	}
+	if (input.darkSaturationFactor !== void 0) {
+		if (!Number.isFinite(input.darkSaturationFactor) || input.darkSaturationFactor < 0 || input.darkSaturationFactor > 1) throw new Error(`glaze.color: structured darkSaturationFactor must be a finite number in 0–1 (got ${input.darkSaturationFactor}).`);
+	}
 	if (input.opacity !== void 0) validateStandaloneOpacity(input.opacity);
 }
 /**
@@ -3016,11 +3093,27 @@ function extractOkhslFromValue(value) {
 	return value;
 }
 /**
+* Resolve `'max'` / `'min'` to their literal author tones (100 / 0).
+*
+* The hidden `STANDALONE_SEED` anchor exists only so `contrast` has something
+* to measure against — it is not an authored base. Pinning the extreme keeps
+* the token on the plain scheme mapping instead of the base-anchored dark
+* replay the resolver applies to real `base` references.
+*/
+function pinExtremeTone(tone) {
+	const pin = (value) => value === "max" ? 100 : value === "min" ? 0 : value;
+	return Array.isArray(tone) ? [pin(tone[0]), pin(tone[1])] : pin(tone);
+}
+/**
 * 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.
 *
+* An absolute `hue` override becomes the seed while a relative one becomes a
+* def field; `darkHue` always lands on the def in either form, so an absolute
+* `darkHue` wins outright instead of being re-offset by a relative `hue`.
+*
 * When the user requests `contrast` or relative `tone`, a hidden
 * `STANDALONE_SEED` def is synthesized at `mode: 'static'`. That keeps
 * the seed pinned to the literal user-provided color across all four
@@ -3038,10 +3131,13 @@ function buildStandaloneValueDefs(main, options) {
 	if (userName !== void 0) validateStandaloneName(userName);
 	const primary = userName ?? STANDALONE_VALUE;
 	const seedTone = toTone(main.l);
+	const primaryTone = toneOption ?? seedTone;
 	const valueDef = {
 		hue: relativeHue,
 		saturation: options?.saturationFactor,
-		tone: toneOption ?? seedTone,
+		darkHue: options?.darkHue,
+		darkSaturation: options?.darkSaturationFactor,
+		tone: needsSeedAnchor ? pinExtremeTone(primaryTone) : primaryTone,
 		contrast: options?.contrast,
 		mode: options?.mode ?? "auto",
 		autoFlip: options?.autoFlip,
@@ -3058,13 +3154,16 @@ function buildStandaloneValueDefs(main, options) {
 		mode: "static"
 	};
 	return {
-		seedHue,
-		seedSaturation,
+		seed: {
+			hue: seedHue,
+			saturation: seedSaturation,
+			darkSaturation: options?.darkSaturation
+		},
 		defs,
 		primary
 	};
 }
-function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, configOverride, baseToken, buildExport) {
+function createColorTokenFromDefs(seed, defs, primary, configOverride, baseToken, buildExport) {
 	let cache = null;
 	function getEffectiveConfig() {
 		const version = getConfigVersion();
@@ -3081,7 +3180,7 @@ function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, config
 		const version = getConfigVersion();
 		if (cache && cache.version === version && cache.map) return cache.map;
 		const effectiveConfig = getEffectiveConfig();
-		const map = resolveAllColors(seedHue, seedSaturation, defs, effectiveConfig, baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0);
+		const map = resolveAllColors(seed, defs, effectiveConfig, baseToken ? new Map([[STANDALONE_BASE, baseToken.resolve()]]) : void 0);
 		cache = {
 			map,
 			version,
@@ -3119,7 +3218,7 @@ function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, config
 			if (options.splitHue && format === "oklch") {
 				assertAllPastel(renamed, resolveModes());
 				channelCtx = {
-					seedHue,
+					seedHue: seed.hue,
 					baseName: options.name,
 					prefix: "",
 					defs: { [options.name]: defs[primary] },
@@ -3203,8 +3302,10 @@ function createColorToken(input, configOverride) {
 	const hasExternalBase = baseToken !== void 0;
 	const needsSeedAnchor = !hasExternalBase && input.contrast !== void 0;
 	const defs = { [primary]: {
-		tone: input.tone,
+		tone: needsSeedAnchor ? pinExtremeTone(input.tone) : input.tone,
 		saturation: input.saturationFactor,
+		darkHue: input.darkHue,
+		darkSaturation: input.darkSaturationFactor,
 		mode: input.mode ?? "auto",
 		autoFlip: input.autoFlip,
 		contrast: input.contrast,
@@ -3213,16 +3314,17 @@ function createColorToken(input, configOverride) {
 		role: input.role,
 		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
 	} };
-	if (needsSeedAnchor) {
-		const seedTone = pairNormal(input.tone);
-		defs[STANDALONE_SEED] = {
-			tone: seedTone === "max" ? 100 : seedTone === "min" ? 0 : seedTone,
-			saturation: 1,
-			mode: "static"
-		};
-	}
+	if (needsSeedAnchor) defs[STANDALONE_SEED] = {
+		tone: pinExtremeTone(pairNormal(input.tone)),
+		saturation: 1,
+		mode: "static"
+	};
 	const localOverride = configOverride;
-	return createColorTokenFromDefs(input.hue, input.saturation, defs, primary, localOverride, baseToken, (exportArg) => ({
+	return createColorTokenFromDefs({
+		hue: input.hue,
+		saturation: input.saturation,
+		darkSaturation: input.darkSaturation
+	}, defs, primary, localOverride, baseToken, (exportArg) => ({
 		kind: "color",
 		version: GLAZE_EXPORT_VERSION,
 		form: "structured",
@@ -3233,9 +3335,9 @@ function createColorToken(input, configOverride) {
 function createColorTokenFromValue(value, options, configOverride) {
 	const main = extractOkhslFromValue(value);
 	const linkingBase = toLinkingBase(resolveBaseToken(options?.base));
-	const { seedHue, seedSaturation, defs, primary } = buildStandaloneValueDefs(main, options);
+	const { seed, defs, primary } = buildStandaloneValueDefs(main, options);
 	const localOverride = sparseValueFormLocal(configOverride);
-	return createColorTokenFromDefs(seedHue, seedSaturation, defs, primary, localOverride, linkingBase, (exportArg) => ({
+	return createColorTokenFromDefs(seed, defs, primary, localOverride, linkingBase, (exportArg) => ({
 		kind: "color",
 		version: GLAZE_EXPORT_VERSION,
 		form: "value",
@@ -3255,6 +3357,9 @@ function buildOverridesExport(options, exportArg) {
 	if (options.saturation !== void 0) out.saturation = options.saturation;
 	if (options.tone !== void 0) out.tone = options.tone;
 	if (options.saturationFactor !== void 0) out.saturationFactor = options.saturationFactor;
+	if (options.darkHue !== void 0) out.darkHue = options.darkHue;
+	if (options.darkSaturation !== void 0) out.darkSaturation = options.darkSaturation;
+	if (options.darkSaturationFactor !== void 0) out.darkSaturationFactor = options.darkSaturationFactor;
 	if (options.mode !== void 0) out.mode = options.mode;
 	if (options.autoFlip !== void 0) out.autoFlip = options.autoFlip;
 	if (options.contrast !== void 0) out.contrast = options.contrast;
@@ -3272,6 +3377,9 @@ function buildStructuredInputExport(input, exportArg) {
 		tone: input.tone
 	};
 	if (input.saturationFactor !== void 0) out.saturationFactor = input.saturationFactor;
+	if (input.darkHue !== void 0) out.darkHue = input.darkHue;
+	if (input.darkSaturation !== void 0) out.darkSaturation = input.darkSaturation;
+	if (input.darkSaturationFactor !== void 0) out.darkSaturationFactor = input.darkSaturationFactor;
 	if (input.mode !== void 0) out.mode = input.mode;
 	if (input.autoFlip !== void 0) out.autoFlip = input.autoFlip;
 	if (input.opacity !== void 0) out.opacity = input.opacity;
@@ -3294,6 +3402,9 @@ function rehydrateOverrides(data) {
 	if (data.saturation !== void 0) out.saturation = data.saturation;
 	if (data.tone !== void 0) out.tone = data.tone;
 	if (data.saturationFactor !== void 0) out.saturationFactor = data.saturationFactor;
+	if (data.darkHue !== void 0) out.darkHue = data.darkHue;
+	if (data.darkSaturation !== void 0) out.darkSaturation = data.darkSaturation;
+	if (data.darkSaturationFactor !== void 0) out.darkSaturationFactor = data.darkSaturationFactor;
 	if (data.mode !== void 0) out.mode = data.mode;
 	if (data.autoFlip !== void 0) out.autoFlip = data.autoFlip;
 	if (data.contrast !== void 0) out.contrast = data.contrast;
@@ -3311,6 +3422,9 @@ function rehydrateStructuredInput(data) {
 		tone: data.tone
 	};
 	if (data.saturationFactor !== void 0) out.saturationFactor = data.saturationFactor;
+	if (data.darkHue !== void 0) out.darkHue = data.darkHue;
+	if (data.darkSaturation !== void 0) out.darkSaturation = data.darkSaturation;
+	if (data.darkSaturationFactor !== void 0) out.darkSaturationFactor = data.darkSaturationFactor;
 	if (data.mode !== void 0) out.mode = data.mode;
 	if (data.autoFlip !== void 0) out.autoFlip = data.autoFlip;
 	if (data.opacity !== void 0) out.opacity = data.opacity;
@@ -3344,7 +3458,8 @@ function colorFromExport(data) {
 
 //#endregion
 //#region src/theme.ts
-function createTheme(hue, saturation, initialColors, configOverride) {
+function createTheme(seed, initialColors, configOverride) {
+	const { hue, saturation, darkHue, darkSaturation } = seed;
 	let colorDefs = initialColors ? { ...initialColors } : {};
 	let cache = null;
 	function getEffectiveConfig() {
@@ -3362,7 +3477,7 @@ function createTheme(hue, saturation, initialColors, configOverride) {
 		const version = getConfigVersion();
 		if (cache && cache.version === version && cache.map) return cache.map;
 		const effectiveConfig = getEffectiveConfig();
-		const map = resolveAllColors(hue, saturation, colorDefs, effectiveConfig);
+		const map = resolveAllColors(seed, colorDefs, effectiveConfig);
 		cache = {
 			map,
 			version,
@@ -3379,6 +3494,7 @@ function createTheme(hue, saturation, initialColors, configOverride) {
 		assertAllPastel(resolveCached(), resolveModes(options?.modes));
 		return {
 			seedHue: hue,
+			darkSeedHue: darkHue,
 			baseName: options.name ?? "theme",
 			prefix,
 			defs: colorDefs,
@@ -3392,6 +3508,12 @@ function createTheme(hue, saturation, initialColors, configOverride) {
 		get saturation() {
 			return saturation;
 		},
+		get darkHue() {
+			return darkHue;
+		},
+		get darkSaturation() {
+			return darkSaturation;
+		},
 		getConfig() {
 			return getEffectiveConfig();
 		},
@@ -3428,16 +3550,22 @@ function createTheme(hue, saturation, initialColors, configOverride) {
 				version: GLAZE_EXPORT_VERSION,
 				hue,
 				saturation,
+				...darkHue !== void 0 ? { darkHue } : {},
+				...darkSaturation !== void 0 ? { darkSaturation } : {},
 				colors: structuredClone(colorDefs),
 				config: freezeConfigForExport(configOverride, override)
 			};
 		},
 		extend(options) {
-			const newHue = options.hue ?? hue;
-			const newSat = options.saturation ?? saturation;
+			const childSeed = {
+				hue: options.hue ?? hue,
+				saturation: options.saturation ?? saturation,
+				darkHue: options.darkHue ?? darkHue,
+				darkSaturation: options.darkSaturation ?? darkSaturation
+			};
 			const inheritedColors = {};
 			for (const [name, def] of Object.entries(colorDefs)) if (def.inherit !== false) inheritedColors[name] = def;
-			return createTheme(newHue, newSat, options.colors ? {
+			return createTheme(childSeed, options.colors ? {
 				...inheritedColors,
 				...options.colors
 			} : { ...inheritedColors }, configOverride || options.config ? {
@@ -3547,6 +3675,7 @@ function channelCtxForTheme(theme, themeName, passPrefix, themedPrefix, splitHue
 	assertAllPastel(filtered, modes);
 	return {
 		seedHue: theme.hue,
+		darkSeedHue: theme.darkHue,
 		baseName: themeName,
 		prefix: themedPrefix,
 		defs: colorMapFromTheme(theme),
@@ -3578,7 +3707,13 @@ function createThemeFromExport(data, factory = "glaze.themeFrom") {
 	assertExportKind(data, "theme", factory);
 	assertExportVersion(data, factory);
 	if (typeof data.hue !== "number" || typeof data.saturation !== "number") throw new Error(`${factory}: expected numeric "hue" and "saturation" fields.`);
-	return createTheme(data.hue, data.saturation, data.colors, data.config);
+	for (const field of ["darkHue", "darkSaturation"]) if (data[field] !== void 0 && typeof data[field] !== "number") throw new Error(`${factory}: expected "${field}" to be a number when present (got ${JSON.stringify(data[field])}).`);
+	return createTheme({
+		hue: data.hue,
+		saturation: data.saturation,
+		darkHue: data.darkHue,
+		darkSaturation: data.darkSaturation
+	}, data.colors, data.config);
 }
 /**
 * Rebuild a palette from a `palette.export()` snapshot.
@@ -3740,18 +3875,28 @@ function createPalette(themes, paletteOptions) {
 * the theme still reacts to later `configure()` calls for fields it
 * didn't override.
 *
+* The object form also accepts `darkHue` / `darkSaturation` — a separate
+* seed pair for the dark and dark-high-contrast schemes. Both default to
+* their light counterparts, and an explicit `darkSaturation` opts the theme
+* out of the global `darkDesaturation` reduction.
+*
 * @example
 * ```ts
 * const primary = glaze(280, 80);
 * // or shorthand:
 * const primary = glaze({ hue: 280, saturation: 80 });
+* // with a retuned dark seed:
+* const primary = glaze({ hue: 280, saturation: 80, darkHue: 268, darkSaturation: 65 });
 * // with config override:
 * const raw = glaze(280, 80, { lightTone: false });
 * ```
 */
 function glaze(hueOrOptions, saturation, config) {
-	if (typeof hueOrOptions === "number") return createTheme(hueOrOptions, saturation ?? 100, void 0, config);
-	return createTheme(hueOrOptions.hue, hueOrOptions.saturation, void 0, config);
+	if (typeof hueOrOptions === "number") return createTheme({
+		hue: hueOrOptions,
+		saturation: saturation ?? 100
+	}, void 0, config);
+	return createTheme(hueOrOptions, void 0, config);
 }
 /** Configure global glaze settings. */
 glaze.configure = function configure$1(config) {
@@ -3865,7 +4010,10 @@ glaze.fromHex = function fromHex(hex) {
 	const rgb = parseHex(hex);
 	if (!rgb) throw new Error(`glaze: invalid hex color "${hex}".`);
 	const [h, s] = srgbToOkhsl(rgb);
-	return createTheme(h, s * 100);
+	return createTheme({
+		hue: h,
+		saturation: s * 100
+	});
 };
 /**
 * Create a theme from RGB values (0–255).
@@ -3877,7 +4025,10 @@ glaze.fromRgb = function fromRgb(r, g, b) {
 		g / 255,
 		b / 255
 	]);
-	return createTheme(h, s * 100);
+	return createTheme({
+		hue: h,
+		saturation: s * 100
+	});
 };
 /**
 * Rehydrate a `glaze.color()` token from a `.export()` snapshot.