@tenphi/glaze 0.0.0-snapshot.0fcd6cf → 0.0.0-snapshot.12fd135

package/dist/index.cjs

@@ -97,6 +97,12 @@ const K1 = .206;
 const K2 = .03;
 const K3 = (1 + K1) / (1 + K2);
 const EPSILON = 1e-10;
+/**
+* OKLab chroma under which an sRGB input counts as gray. An exact sRGB gray
+* leaves float residue in OKLab a / b (at most 3.7e-8, at white); the faintest
+* deliberate tint, one channel 0.01 of 255 off gray, has 1.06e-5.
+*/
+const GRAY_CHROMA = 1e-6;
 const constrainAngle = (angle) => (angle % 360 + 360) % 360;
 /**
 * OKHSL toe function: maps OKLab lightness L to perceptual lightness l.
@@ -490,13 +496,21 @@ const oklabToOkhsl = (lab, pastel = false) => {
 /**
 * Convert gamma-encoded sRGB (0–1 per channel) to OKHSL.
 * Returns [h, s, l] where h: 0–360, s: 0–1, l: 0–1.
+*
+* A gray reads with saturation 0 (its computed hue is kept). Its OKLab
+* residue would otherwise come out as a saturation that grows toward white
+* (`#fefefe` reads 1.6e-5, `rgb(254.999 254.999 254.999)` 1.6e-2), which a
+* color carries into every scheme and an OKHSL mix reads as a hue.
 */
 function srgbToOkhsl(rgb, pastel = false) {
-	return oklabToOkhsl(linearSrgbToOklab([
+	const oklab = linearSrgbToOklab([
 		sRGBGammaToLinear(rgb[0]),
 		sRGBGammaToLinear(rgb[1]),
 		sRGBGammaToLinear(rgb[2])
-	]), pastel);
+	]);
+	const okhsl = oklabToOkhsl(oklab, pastel);
+	if (Math.hypot(oklab[1], oklab[2]) < GRAY_CHROMA) okhsl[1] = 0;
+	return okhsl;
 }
 /**
 * Convert CSS HSL (sRGB-based) to gamma-encoded sRGB [r, g, b] in 0–1 range.
@@ -670,13 +684,26 @@ function formatOklch(h, s, l, pastel = false) {
 * Format linear sRGB channels as a CSS `color(srgb-linear R G B)` string with
 * 4 decimals. Unlike the other writers it takes linear light, not OKHSL, and
 * does not clamp: a channel may exceed 1, which is how an HDR glow value
-* (`glaze.formatHdr()`) goes past SDR white — `1` is SDR white, `2` one stop
-* above it. Opaque only; HDR values carry no alpha.
+* written with `glaze.formatHdr(v, 'srgb-linear')` goes past SDR white — `1`
+* is SDR white, `2` one stop above it (the default extended form is
+* `formatSrgb`). Opaque only; HDR values carry no alpha.
 */
 function formatSrgbLinear(rgb) {
 	return `color(srgb-linear ${fmt$1(rgb[0], 4)} ${fmt$1(rgb[1], 4)} ${fmt$1(rgb[2], 4)})`;
 }
 /**
+* Format extended sRGB channels — gamma-encoded, with the transfer function
+* continued past 1 (`sRGBLinearToGamma` does) — as a CSS `color(srgb R G B)`
+* string with 4 decimals. Like `formatSrgbLinear` it takes the channels of
+* its own space and does not clamp, so an HDR glow value
+* (`glaze.formatHdr()`) can pass SDR white: `1` is SDR white, about `1.3533`
+* one stop above it. CSS reads it as the same color as the matching
+* `color(srgb-linear …)`. Opaque only; HDR values carry no alpha.
+*/
+function formatSrgb(rgb) {
+	return `color(srgb ${fmt$1(rgb[0], 4)} ${fmt$1(rgb[1], 4)} ${fmt$1(rgb[2], 4)})`;
+}
+/**
 * Convert gamma-encoded sRGB channels (0–1) to a 6-digit lowercase hex
 * string (`#rrggbb`). Channels are clamped to [0,1] and rounded to 8-bit.
 * Alpha is not encoded here — DTCG carries it as a separate `alpha` field.
@@ -716,18 +743,26 @@ function clamp(v, min, max) {
 function lerp(a, b, f) {
 	return a + (b - a) * f;
 }
+/** Brackets `undefined` or a non-finite number while JSON writes it. */
+const UNWRITABLE_MARK = "";
+const UNWRITABLE_RE = /"\uE000([^"]*)\uE000"/g;
 /**
 * A rejected input as a validation error shows it. Numbers and `undefined`
 * via `String` (`JSON.stringify(NaN)` is "null"), a bigint with its `n`
 * (JSON can't write one), anything else via JSON so a string shows its quotes
-* and an array its shape — falling back to `String` for what JSON can't write
-* (a symbol, a function, a cycle).
+* and an array its shape, with `undefined` or a non-finite number inside
+* written as it prints (`[10,NaN]`, `{"wcag":undefined}`; JSON would write
+* `null` or drop the key) — falling back to `String` for what JSON can't
+* write (a symbol, a function, a cycle).
 */
 function showValue(value) {
 	if (typeof value === "number" || value === void 0) return String(value);
 	if (typeof value === "bigint") return `${value}n`;
 	try {
-		return JSON.stringify(value) ?? String(value);
+		const plain = JSON.stringify(value);
+		if (plain === void 0) return String(value);
+		if (plain.includes(UNWRITABLE_MARK)) return plain;
+		return JSON.stringify(value, (_key, v) => v === void 0 || typeof v === "number" && !Number.isFinite(v) ? `${UNWRITABLE_MARK}${v}${UNWRITABLE_MARK}` : v)?.replace(UNWRITABLE_RE, "$1") ?? String(value);
 	} catch {
 		return String(value);
 	}
@@ -1178,8 +1213,8 @@ function schemeToneRange(isDark, mode, isHighContrast, config) {
 * surface at all gets none and keeps the SDR shortfall warning. Since the
 * value lands the whole step, only a full-reach glow meets SDR at the boundary
 * (`exposure` → 0); one with `reach` below 1 jumps from its pigment to the
-* exact step. `hdrToLinearSrgb` turns a resolved HDR value back into linear
-* sRGB for the writers.
+* exact step. `hdrToLinearSrgb` / `hdrToSrgb` turn a resolved HDR value back
+* into linear or extended sRGB channels for the writers (both public).
 */
 /** Most stops of HDR headroom a glow may use; larger values clamp to it. */
 const MAX_HEADROOM = 2;
@@ -1209,11 +1244,13 @@ const DEFAULT_LIGHTING_TUNING = {
 * warned about one above the maximum.
 */
 function resolveLightingTuning(perColor, globalTuning) {
+	const field = (key) => perColor?.[key] ?? globalTuning?.[key] ?? DEFAULT_LIGHTING_TUNING[key];
 	const headroom = perColor?.headroom ?? globalTuning?.headroom ?? 0;
 	return {
-		...DEFAULT_LIGHTING_TUNING,
-		...globalTuning,
-		...perColor,
+		objectInfluence: field("objectInfluence"),
+		tint: field("tint"),
+		reach: field("reach"),
+		hueBleed: field("hueBleed"),
 		headroom: clamp(headroom, 0, MAX_HEADROOM)
 	};
 }
@@ -1223,11 +1260,18 @@ function circularLerp(a, b, t) {
 	else if (diff < -180) diff += 360;
 	return ((a + diff * t) % 360 + 360) % 360;
 }
-const SAT_EPSILON = 1e-6;
+/**
+* Saturation at or below which a color has no hue of its own. A gray given as
+* a value parses with saturation 0; a near-gray under this has a hue too
+* faint to give a tint.
+*/
+const HUE_EPSILON = 1e-4;
 const BISECT_ITERATIONS = 40;
 const GOLDEN = (Math.sqrt(5) - 1) / 2;
 /** Float noise a target tone may sit above 100 without counting as HDR. */
 const HDR_TRIGGER_EPS = 1e-9;
+/** Float noise a pigment may move the surface by and still count as not. */
+const NO_LIFT_EPS = 1e-9;
 /** Float noise a surface tone may sit below 100 and still count as white. */
 const WHITE_SURFACE_EPS = 1e-6;
 /**
@@ -1245,16 +1289,30 @@ function objectFactor(kind, bgTone, fgTone, objectInfluence) {
 * The pigment: pure black (shadow) / pure white (glow) by default. `reach`
 * below 1 parks it part of the way from the surface's tone to that extreme so
 * a `tint` — saturation in the surface's hue, optionally pulled toward the
-* object's hue by `hueBleed` — can show.
+* object's hue by `hueBleed` — can show. A neutral surface has no hue to give:
+* the tint takes the object's hue when `hueBleed` is above 0, and the pigment
+* stays neutral otherwise.
 */
 function pigmentFor(kind, bg, fg, bgTone, tuning) {
 	const reach = clamp(tuning.reach, 0, 1);
 	const tone = kind === "shadow" ? bgTone * (1 - reach) : bgTone + (100 - bgTone) * reach;
 	const bleed = clamp(tuning.hueBleed, 0, 1);
+	const l = clamp(fromTone(tone), 0, 1);
+	const tint = clamp(tuning.tint, 0, 1);
+	const objectHue = fg !== void 0 && fg.s > HUE_EPSILON && bleed > 0 ? fg.h : void 0;
+	if (bg.s <= HUE_EPSILON) return objectHue === void 0 ? {
+		h: bg.h,
+		s: 0,
+		l
+	} : {
+		h: objectHue,
+		s: tint,
+		l
+	};
 	return {
-		h: fg !== void 0 && fg.s > SAT_EPSILON && bleed > 0 ? circularLerp(bg.h, fg.h, bleed) : bg.h,
-		s: clamp(tuning.tint, 0, 1),
-		l: clamp(fromTone(tone), 0, 1)
+		h: objectHue === void 0 ? bg.h : circularLerp(bg.h, objectHue, bleed),
+		s: tint,
+		l
 	};
 }
 /**
@@ -1311,7 +1369,7 @@ function solveOpacity(kind, gain, step) {
 	if (gain(1) < step) {
 		hi = kind === "shadow" ? strongestShadowAlpha(gain) : 1;
 		const reached = gain(hi);
-		if (reached < step) return reached > 0 ? {
+		if (reached < step) return reached > NO_LIFT_EPS ? {
 			alpha: hi,
 			reached
 		} : {
@@ -1422,6 +1480,21 @@ function hdrToLinearSrgb(hdr) {
 	];
 }
 /**
+* Extended sRGB of a resolved HDR value: `hdrToLinearSrgb` through the sRGB
+* transfer function, continued past 1 the way CSS and the platform
+* extended-sRGB spaces continue it, unclamped. These are the channels of
+* `color(srgb R G B)` (`glaze.formatHdr()`), and what a WebGPU `'srgb'`
+* canvas, `CGColorSpace.extendedSRGB`, and Android's `EXTENDED_SRGB` take.
+*/
+function hdrToSrgb(hdr) {
+	const [r, g, b] = hdrToLinearSrgb(hdr);
+	return [
+		sRGBLinearToGamma(r),
+		sRGBLinearToGamma(g),
+		sRGBLinearToGamma(b)
+	];
+}
+/**
 * Opacity of a shadow pigment's darkest composite. Full opacity for pure
 * black; a tinted pigment whose channels pull in different directions can
 * bottom out earlier, so a golden-section search over the unimodal gain finds
@@ -1521,6 +1594,18 @@ const WCAG_HC_PROMOTION = {
 	AA: "AAA",
 	"AA-large": "AAA-large"
 };
+/** An `{ apca }` spec: its `apca` is set (a key holding `undefined` is not). */
+function isApcaSpec(spec) {
+	return spec.apca !== void 0;
+}
+/** Whether `value` names a WCAG preset (internal; see validation.ts). */
+function isContrastPreset(value) {
+	return typeof value === "string" && Object.hasOwn(CONTRAST_PRESETS, value);
+}
+/** Whether `value` names an APCA preset (internal; see validation.ts). */
+function isApcaPreset(value) {
+	return typeof value === "string" && Object.hasOwn(APCA_PRESETS, value);
+}
 function resolveMinContrast(value) {
 	if (typeof value === "number") return Math.max(1, value);
 	return CONTRAST_PRESETS[value];
@@ -1546,7 +1631,7 @@ function pickPair(p, isHighContrast) {
 * presets are `'wcag'`; only an `{ apca }` object is `'apca'`.
 */
 function contrastMetricOf(spec) {
-	return typeof spec === "object" && "apca" in spec ? "apca" : "wcag";
+	return typeof spec === "object" && isApcaSpec(spec) ? "apca" : "wcag";
 }
 /**
 * Resolve a `ContrastSpec` (already selected from any outer HC pair) for a
@@ -1569,12 +1654,12 @@ function resolveContrastForMode(spec, isHighContrast, polarity, outerExplicitHC)
 		metric: "wcag",
 		target: resolveWcagTarget(spec, isHighContrast, !!outerExplicitHC)
 	};
-	if ("apca" in spec) {
+	if (isApcaSpec(spec)) {
 		const baseTarget = resolveApcaTarget(pickPair(spec.apca, isHighContrast));
 		const innerExplicitHC = Array.isArray(spec.apca);
 		return {
 			metric: "apca",
-			target: isHighContrast && !outerExplicitHC && !innerExplicitHC ? Math.min(baseTarget + APCA_HC_ENHANCEMENT, APCA_MAX_LC) : baseTarget,
+			target: isHighContrast && !outerExplicitHC && !innerExplicitHC ? Math.max(baseTarget, Math.min(baseTarget + APCA_HC_ENHANCEMENT, APCA_MAX_LC)) : baseTarget,
 			polarity: polarity ?? "fg"
 		};
 	}
@@ -1602,6 +1687,7 @@ function resolveContrastForMode(spec, isHighContrast, polarity, outerExplicitHC)
 * for direct callers.
 */
 function resolveContrastForLevel(spec, level, polarity) {
+	if (!Number.isFinite(level)) throw new Error(`glaze: resolveContrastForLevel needs a finite level (got ${level}).`);
 	const outerExplicitHC = Array.isArray(spec);
 	const f = levelFraction(level);
 	const normal = resolveContrastForMode(pairNormal(spec), false, polarity, outerExplicitHC);
@@ -1947,10 +2033,11 @@ function dedupe(key) {
 }
 /**
 * Whether `actual` is short of the floor by more than the slack. The solver
-* aims slightly past the target, so a smaller shortfall is rounding noise.
+* aims slightly past the target, so a smaller shortfall is rounding noise. A
+* non-finite target or measurement counts as a miss, so it is reported.
 */
 function missesFloor(contrast, actual) {
-	return actual < (contrast.metric === "apca" ? contrast.target - CONTRAST_WARN_SLACK_APCA : contrast.target * CONTRAST_WARN_SLACK_WCAG);
+	return !(actual >= (contrast.metric === "apca" ? contrast.target - CONTRAST_WARN_SLACK_APCA : contrast.target * CONTRAST_WARN_SLACK_WCAG));
 }
 function contrastKey(kind, name, scheme, contrast, actual) {
 	return `${kind}|${name}|${scheme}|${contrast.metric}|${contrast.target.toFixed(2)}|${actual.toFixed(2)}`;
@@ -1966,13 +2053,16 @@ function warnContrastUnmet(name, isDark, isHighContrast, contrast, actual) {
 * Warn when a mix's ratio / opacity search could not reach its contrast floor
 * against the mix's `base`. An unmet mix means even the pure target falls
 * short, so the fix is the target color or the floor, not a tone window.
-* `actual` is the contrast of the value the mix settled at.
+* `actual` is the contrast of the value the mix settled at. `pastelCapped`
+* says the pastel cap is why: the mix's pastel gamut paints the target with
+* less saturation, and the target painted in full would meet the floor, so
+* the hint offers `pastel: false`.
 */
-function warnMixContrastUnmet(name, isDark, isHighContrast, contrast, actual) {
+function warnMixContrastUnmet(name, isDark, isHighContrast, contrast, actual, pastelCapped = false) {
 	if (!missesFloor(contrast, actual)) return;
 	const scheme = schemeLabel(isDark, isHighContrast);
 	if (dedupe(contrastKey("unmet-mix", name, scheme, contrast, actual))) return;
-	console.warn(`glaze: mix "${name}" cannot meet ${metricLabel(contrast)} against its base in ${scheme} scheme (got ${actual.toFixed(2)}). Even the pure target falls short; try lowering the contrast target or mixing toward a color further from the base.`);
+	console.warn(`glaze: mix "${name}" cannot meet ${metricLabel(contrast)} against its base in ${scheme} scheme (got ${actual.toFixed(2)}). ` + (pastelCapped ? "Even the pure target falls short once the mix's pastel gamut caps its saturation; try `pastel: false` on the mix, lowering the contrast target, or mixing toward a color further from the base." : "Even the pure target falls short; try lowering the contrast target or mixing toward a color further from the base."));
 }
 /**
 * Verification (the drift check in docs/okhst.mdx): a chromatic swatch
@@ -2126,6 +2216,13 @@ function defaultConfig() {
 	};
 }
 /**
+* `value`, or `fallback` when it is `undefined`. Only `undefined` means
+* "keep": a `null` is passed on so the field's validator rejects it.
+*/
+function keepIfUndefined(value, fallback) {
+	return value !== void 0 ? value : fallback;
+}
+/**
 * Validate an authored `contrastLevel`. Numbers clamp to 0–100 so a slider
 * can't produce an out-of-range level; a non-finite number throws rather than
 * silently reading as `'auto'`, which would turn a `NaN` slider value into an
@@ -2183,15 +2280,26 @@ function normalizeHeadroom(value, where, deferred) {
 	return value;
 }
 /**
-* Validate and copy a lighting tuning: a detached copy (or `undefined`) with a
-* glow's `headroom` checked and clamped by `normalizeHeadroom`. A shadow has no
-* headroom — it darkens toward black, and nothing goes below black — so a
-* `headroom` on shadow tuning throws. Only `undefined` counts as unset.
-* `deferred` queues the clamp warning (see `normalizeHeadroom`).
+* Validate and copy a lighting tuning: a detached copy (or `undefined`) with
+* `objectInfluence` / `tint` / `reach` / `hueBleed` checked to be finite
+* numbers (the 0–1 fields clamp at use) and a glow's `headroom` checked and
+* clamped by `normalizeHeadroom`. A shadow has no headroom — it darkens toward
+* black, and nothing goes below black — so a `headroom` on shadow tuning
+* throws. Only `undefined` counts as unset. `deferred` queues the clamp
+* warning (see `normalizeHeadroom`).
 */
 function normalizeLightingTuning(kind, tuning, where, deferred) {
 	if (tuning === void 0) return void 0;
 	const out = { ...tuning };
+	for (const field of [
+		"objectInfluence",
+		"tint",
+		"reach",
+		"hueBleed"
+	]) {
+		const value = out[field];
+		if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value))) throw new Error(`glaze: ${where}.${field} must be a finite number (got ${showValue(value)}).`);
+	}
 	const headroom = tuning?.headroom;
 	if (headroom === void 0) return out;
 	if (kind === "shadow") throw new Error(`glaze: ${where}.headroom is not supported — a shadow darkens toward black, and nothing goes below black. Headroom is for glows (glowTuning or a glow's tuning).`);
@@ -2274,7 +2382,8 @@ const OVERRIDE_FIELD_COPY = {
 * through unchanged.
 */
 function copyConfigOverride(override) {
-	if (typeof override !== "object" || override === null) return override;
+	if (override === null) return void 0;
+	if (typeof override !== "object") return override;
 	const source = override;
 	const out = {};
 	for (const [key, copy] of Object.entries(OVERRIDE_FIELD_COPY)) if (key in source) out[key] = copy(source[key]);
@@ -2317,7 +2426,7 @@ function configure(config) {
 	const next = {
 		lightTone: normalizeToneWindowInput(config.lightTone !== void 0 ? config.lightTone : globalConfig.lightTone, "lightTone"),
 		darkTone: normalizeToneWindowInput(config.darkTone !== void 0 ? config.darkTone : globalConfig.darkTone, "darkTone"),
-		darkDesaturation: normalizeDarkDesaturation(config.darkDesaturation ?? globalConfig.darkDesaturation),
+		darkDesaturation: normalizeDarkDesaturation(keepIfUndefined(config.darkDesaturation, globalConfig.darkDesaturation)),
 		states: {
 			dark: config.states?.dark ?? globalConfig.states.dark,
 			highContrast: config.states?.highContrast ?? globalConfig.states.highContrast,
@@ -2333,7 +2442,7 @@ function configure(config) {
 		autoFlip: config.autoFlip ?? globalConfig.autoFlip,
 		pastel: false,
 		inferRole: config.inferRole ?? globalConfig.inferRole,
-		contrastLevel: normalizeContrastLevel(config.contrastLevel ?? globalConfig.contrastLevel)
+		contrastLevel: normalizeContrastLevel(keepIfUndefined(config.contrastLevel, globalConfig.contrastLevel))
 	};
 	flushWarnings(deferred);
 	configVersion++;
@@ -2363,7 +2472,7 @@ function mergeConfig(base, override = {}) {
 	const merged = {
 		lightTone: normalizeToneWindowInput(override.lightTone !== void 0 ? override.lightTone : base.lightTone, "lightTone"),
 		darkTone: normalizeToneWindowInput(override.darkTone !== void 0 ? override.darkTone : base.darkTone, "darkTone"),
-		darkDesaturation: normalizeDarkDesaturation(override.darkDesaturation ?? base.darkDesaturation),
+		darkDesaturation: normalizeDarkDesaturation(keepIfUndefined(override.darkDesaturation, base.darkDesaturation)),
 		states: { ...base.states },
 		modes: { ...base.modes },
 		shadowTuning: normalizeLightingTuning("shadow", override.shadowTuning ?? base.shadowTuning, "shadowTuning"),
@@ -2371,7 +2480,7 @@ function mergeConfig(base, override = {}) {
 		autoFlip: override.autoFlip ?? base.autoFlip,
 		pastel: override.pastel ?? false,
 		inferRole: override.inferRole ?? base.inferRole,
-		contrastLevel: normalizeContrastLevel(override.contrastLevel ?? base.contrastLevel)
+		contrastLevel: normalizeContrastLevel(keepIfUndefined(override.contrastLevel, base.contrastLevel))
 	};
 	flushWarnings(deferred);
 	return merged;
@@ -2438,7 +2547,7 @@ function assertExportVersion(data, factory) {
 	if (data.version > GLAZE_EXPORT_VERSION) throw new Error(`${factory}: unsupported export version ${data.version} (this library supports version ${GLAZE_EXPORT_VERSION}). Upgrade @tenphi/glaze to load this snapshot.`);
 }
 /**
-* Reject a version-1 (Glaze 2) theme snapshot that carries shadow colors or a
+* Reject a version-1 (Glaze 1.1–2) theme snapshot that carries shadow colors or a
 * `shadowTuning`. Glaze 3 changed what shadow `intensity`, `fg` and tuning
 * mean, so restoring one would silently re-render every shadow differently.
 * Version-1 snapshots without shadows load as before. `fallbackVersion` is the
@@ -2451,7 +2560,7 @@ function assertNoLegacyShadows(data, factory, fallbackVersion) {
 	const hasTuning = isPlainObject(data.config) && data.config.shadowTuning !== void 0;
 	if (shadows.length === 0 && !hasTuning) return;
 	const what = shadows.length > 0 ? `shadow colors (${shadows.map((n) => JSON.stringify(n)).join(", ")})` : "a \"shadowTuning\" config";
-	throw new Error(`${factory}: this snapshot is export version 1 (Glaze 2) and contains ${what}. Glaze 3 changed what shadow "intensity", "fg" and tuning mean, so it would restore with different shadows. Re-author them as described in docs/migration.md ("3.0 — shadows and glows") and export again.`);
+	throw new Error(`${factory}: this snapshot is export version 1 (Glaze 1.1–2) and contains ${what}. Glaze 3 changed what shadow "intensity", "fg" and tuning mean, so it would restore with different shadows. Re-author them as described in docs/migration.md ("3.0 — shadows and glows") and export again.`);
 }
 /**
 * When `kind` is present, it must match the factory. Missing `kind` is
@@ -2552,7 +2661,8 @@ function themeHuePlan(name, def, variant, ctx, scheme) {
 	const regDef = def;
 	const baseHueVar = `var(--${ctx.baseName}-hue)`;
 	const prop = cssProp(ctx.prefix, name, "-hue");
-	if ((regDef.mode ?? "auto") === "static" && schemeSeedHue(ctx, "dark") !== ctx.seedHue) return {
+	const isStatic = (regDef.mode ?? "auto") === "static";
+	if (isStatic && schemeSeedHue(ctx, "dark") !== ctx.seedHue) return {
 		hueVar: `var(${prop})`,
 		inline: false,
 		declarations: [{
@@ -2560,12 +2670,13 @@ function themeHuePlan(name, def, variant, ctx, scheme) {
 			value: hueValue(variant.h)
 		}]
 	};
-	if (regDef.hue === void 0 && regDef.darkHue === void 0 && regDef.from === void 0) return {
+	const darkHue = isStatic ? void 0 : regDef.darkHue;
+	if (regDef.hue === void 0 && darkHue === void 0 && regDef.from === void 0) return {
 		hueVar: baseHueVar,
 		inline: false,
 		declarations: []
 	};
-	const authored = scheme === "dark" ? regDef.darkHue ?? regDef.hue : regDef.hue;
+	const authored = scheme === "dark" ? darkHue ?? regDef.hue : regDef.hue;
 	if (authored === void 0) {
 		if (regDef.from !== void 0) return {
 			hueVar: `var(${prop})`,
@@ -2785,23 +2896,49 @@ function claimValueProps(resolved, prefix, suffix, owners, labels) {
 * Matches the color functions Glaze itself emits (`rgb()`, `hsl()`, `okhsl()`,
 * `okhst()`, `oklch()`) plus their legacy alpha aliases (`rgba()`, `hsla()`).
 *
-* Only numeric components are supported; named colors (`red`) and
-* relative-color syntax (`from <color> ...`) are out of scope. Hue is read with
-* `parseFloat`, so a bare number or `deg` is degrees and any other angle unit
-* (`turn`, `rad`, `grad`) is misread as degrees.
+* Only numeric components are supported, plus the CSS keyword `none` (a missing
+* component, read as 0 as CSS renders it); named colors (`red`) and
+* relative-color syntax (`from <color> ...`) are out of scope. A hue takes a
+* bare number (degrees) or `deg` / `turn` / `rad` / `grad`.
 */
 const COLOR_FN_RE = /^(rgba?|hsla?|okhsl|okhst|oklch)\(\s*([^)]*)\s*\)$/i;
-function parseNumberOrPercent(raw, percentScale) {
-	if (raw.endsWith("%")) return parseFloat(raw) / 100 * percentScale;
-	return parseFloat(raw);
+/** One numeric component: a CSS number with an optional unit. */
+const COMPONENT_RE = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)([a-z%]*)$/i;
+/** Degrees per unit of each CSS angle unit. */
+const ANGLE_UNITS = {
+	"": 1,
+	deg: 1,
+	turn: 360,
+	rad: 180 / Math.PI,
+	grad: .9
+};
+function readComponent(raw, input, units) {
+	if (raw.toLowerCase() === "none") return 0;
+	const m = COMPONENT_RE.exec(raw);
+	const scale = m ? units[m[2].toLowerCase()] : void 0;
+	const value = m ? parseFloat(m[1]) * (scale ?? NaN) : NaN;
+	if (!Number.isFinite(value)) throw new Error(`glaze: invalid component "${raw}" in "${input}".`);
+	return value;
+}
+/** A number, or a percentage of `percentScale`. */
+function parseNumberOrPercent(raw, percentScale, input) {
+	return readComponent(raw, input, {
+		"": 1,
+		"%": percentScale / 100
+	});
+}
+/** A hue in degrees. */
+function parseHue(raw, input) {
+	return readComponent(raw, input, ANGLE_UNITS);
 }
+const clamp01 = (value) => Math.min(1, Math.max(0, value));
 /**
 * 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.
+* by the caller, with a warning: translucency is a color's `opacity` field.
 */
 function splitColorBody(body) {
 	const slashIdx = body.indexOf("/");
@@ -2822,8 +2959,13 @@ function splitColorBody(body) {
 		hadAlpha: false
 	};
 }
+/** Inputs already warned about, so a re-parsed `from` warns once. */
+const warnedAlpha = /* @__PURE__ */ new Set();
 function warnDroppedAlpha(input) {
-	console.warn(`glaze: alpha component dropped from "${input}" (standalone color has no opacity field).`);
+	if (warnedAlpha.has(input)) return;
+	if (warnedAlpha.size >= 256) warnedAlpha.clear();
+	warnedAlpha.add(input);
+	console.warn(`glaze: alpha component dropped from "${input}"; use the color's \`opacity\` (or a transparent mix) for translucency.`);
 }
 function parseColorString(input) {
 	if (input.startsWith("#")) {
@@ -2843,13 +2985,14 @@ function parseColorString(input) {
 	const { components, hadAlpha } = splitColorBody(m[2].trim());
 	if (hadAlpha) warnDroppedAlpha(input);
 	if (components.length !== 3) throw new Error(`glaze: expected 3 components in "${input}".`);
+	const [c0, c1, c2] = components;
 	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
+				clamp01(parseNumberOrPercent(c0, 255, input) / 255),
+				clamp01(parseNumberOrPercent(c1, 255, input) / 255),
+				clamp01(parseNumberOrPercent(c2, 255, input) / 255)
 			]);
 			return {
 				h,
@@ -2859,7 +3002,7 @@ function parseColorString(input) {
 		}
 		case "hsl":
 		case "hsla": {
-			const [oh, os, ol] = srgbToOkhsl(hslToSrgb(parseFloat(components[0]), parseNumberOrPercent(components[1], 1), parseNumberOrPercent(components[2], 1)));
+			const [oh, os, ol] = srgbToOkhsl(hslToSrgb(parseHue(c0, input), clamp01(parseNumberOrPercent(c1, 1, input)), clamp01(parseNumberOrPercent(c2, 1, input))));
 			return {
 				h: oh,
 				s: os,
@@ -2867,19 +3010,19 @@ function parseColorString(input) {
 			};
 		}
 		case "okhsl": return {
-			h: parseFloat(components[0]),
-			s: parseNumberOrPercent(components[1], 1),
-			l: parseNumberOrPercent(components[2], 1)
+			h: parseHue(c0, input),
+			s: clamp01(parseNumberOrPercent(c1, 1, input)),
+			l: clamp01(parseNumberOrPercent(c2, 1, input))
 		};
 		case "okhst": return okhstToOkhsl({
-			h: parseFloat(components[0]),
-			s: parseNumberOrPercent(components[1], 1),
-			t: parseNumberOrPercent(components[2], 1)
+			h: parseHue(c0, input),
+			s: clamp01(parseNumberOrPercent(c1, 1, input)),
+			t: clamp01(parseNumberOrPercent(c2, 1, input))
 		});
 		case "oklch": {
-			const L = parseNumberOrPercent(components[0], 1);
-			const C = parseNumberOrPercent(components[1], .4);
-			const hRad = parseFloat(components[2]) * Math.PI / 180;
+			const L = clamp01(parseNumberOrPercent(c0, 1, input));
+			const C = Math.max(0, parseNumberOrPercent(c1, .4, input));
+			const hRad = parseHue(c2, input) * Math.PI / 180;
 			const [h, s, l] = oklabToOkhsl([
 				L,
 				C * Math.cos(hRad),
@@ -2901,8 +3044,16 @@ function parseColorString(input) {
 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.");
+	assertNonNegative("OkhslColor", {
+		s,
+		l
+	});
 	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, tone } (which uses 0–100)?");
 }
+/** Reject a negative 0–1 component, naming it: no color has one. */
+function assertNonNegative(kind, fields) {
+	for (const [key, n] of Object.entries(fields)) if (n < 0) throw new Error(`glaze.color: ${kind} ${key} must be 0 or more (got ${n}).`);
+}
 /** Validate a user-supplied `{ r, g, b }` object in 0–255. */
 function validateRgbColor(value) {
 	for (const key of [
@@ -2918,6 +3069,10 @@ function validateRgbColor(value) {
 function validateOklchColor(value) {
 	const { l, c, h } = value;
 	if (!Number.isFinite(l) || !Number.isFinite(c) || !Number.isFinite(h)) throw new Error("glaze.color: OklchColor l/c/h must be finite numbers.");
+	assertNonNegative("OklchColor", {
+		l,
+		c
+	});
 	if (l > 1.5 || c > 1.5) throw new Error("glaze.color: OklchColor l/c must be in 0–1 range (matching oklch() strings).");
 }
 function oklchComponentsToOkhsl(l, c, hDeg) {
@@ -2933,6 +3088,36 @@ function oklchComponentsToOkhsl(l, c, hDeg) {
 		l: outL
 	};
 }
+/**
+* A detached copy of a color value. A value object is read by property access
+* once its shape is known, so a getter, an inherited field or a proxy copies
+* like a plain field (a spread would drop the first two). Strings, and shapes
+* the parser rejects anyway, pass through.
+*/
+function copyColorValue(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+	const v = value;
+	if (isRgbColorObject(value)) return {
+		r: v.r,
+		g: v.g,
+		b: v.b
+	};
+	if (isOklchColorObject(value)) return {
+		l: v.l,
+		c: v.c,
+		h: v.h
+	};
+	if (isOkhstColorObject(value)) return {
+		h: v.h,
+		s: v.s,
+		t: v.t
+	};
+	return {
+		h: v.h,
+		s: v.s,
+		l: v.l
+	};
+}
 function isRgbColorObject(value) {
 	return "r" in value && "g" in value && "b" in value;
 }
@@ -2946,12 +3131,18 @@ function isOkhstColorObject(value) {
 function validateOkhstColor(value) {
 	const { h, s, t } = value;
 	if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(t)) throw new Error("glaze.color: OkhstColor h/s/t must be finite numbers.");
+	assertNonNegative("OkhstColor", {
+		s,
+		t
+	});
 	if (s > 1.5 || t > 1.5) throw new Error("glaze.color: OkhstColor s/t must be in 0–1 range. Did you mean the structured form { hue, saturation, tone } (which uses 0–100)?");
 }
 /**
 * Extract an OKHSL color from any `GlazeColorValue` form. Also used by
 * `glaze.shadow()` / `glaze.glow()` so all their inputs (hex, color
-* functions, OKHSL, literal objects) go through one parser.
+* functions, OKHSL, literal objects) go through one parser. A value object's
+* 0–1 field that passed its check above 1 (up to 1.5) clamps to 1, as the
+* same value in a color function does.
 */
 function extractOkhslFromValue(value) {
 	if (typeof value === "string") return parseColorString(value);
@@ -2971,14 +3162,22 @@ function extractOkhslFromValue(value) {
 	}
 	if (isOklchColorObject(value)) {
 		validateOklchColor(value);
-		return oklchComponentsToOkhsl(value.l, value.c, value.h);
+		return oklchComponentsToOkhsl(clamp01(value.l), value.c, value.h);
 	}
 	if (isOkhstColorObject(value)) {
 		validateOkhstColor(value);
-		return okhstToOkhsl(value);
+		return okhstToOkhsl({
+			h: value.h,
+			s: clamp01(value.s),
+			t: clamp01(value.t)
+		});
 	}
 	validateOkhslColor(value);
-	return value;
+	return {
+		h: value.h,
+		s: clamp01(value.s),
+		l: clamp01(value.l)
+	};
 }
 
 //#endregion
@@ -3142,7 +3341,10 @@ function oppositeRole(role) {
 *
 * `validateColorDefs` rejects bad references (missing / shadow- or
 * glow-referencing / base/contrast/tone mismatches — a relative tone in either
-* entry of an HC pair needs a base) and bad per-color lighting tuning (a
+* entry of an HC pair needs a base), a malformed `contrast` spec (a misspelled
+* preset, a non-finite number, a bad shape), a numeric field the resolver can't
+* place (non-finite, a malformed `'+N'`, an opacity outside 0–1), and bad
+* per-color lighting tuning (a
 * `headroom` on a shadow; a glow `headroom` that is not a finite number ≥ 0,
 * with one above the maximum warned about — once every def has passed — and
 * clamped at resolve), and detects cycles before the resolver runs. `topoSort` orders defs so each color is
@@ -3168,6 +3370,56 @@ function hasRelativeTone(tone) {
 	if (tone === void 0) return false;
 	return !isAbsoluteTone(pairNormal(tone)) || !isAbsoluteTone(pairHC(tone));
 }
+const isWcagValue = (value) => typeof value === "number" && Number.isFinite(value) || isContrastPreset(value);
+const isApcaValue = (value) => typeof value === "number" && Number.isFinite(value) || isApcaPreset(value);
+/**
+* A value, or a `[normal, highContrast]` pair of two, that passes `isValue`.
+* Both entries are read by index: `every` would skip a hole (`[, 7]`).
+*/
+function isPairOf(value, isValue) {
+	return Array.isArray(value) ? value.length === 2 && isValue(value[0]) && isValue(value[1]) : isValue(value);
+}
+/**
+* A WCAG value, or an object with exactly one of `wcag` / `apca` set. A key
+* holding `undefined` is unset, as everywhere else; other keys are ignored.
+*/
+function isContrastSpec(spec) {
+	if (isWcagValue(spec)) return true;
+	if (typeof spec !== "object" || spec === null || Array.isArray(spec)) return false;
+	const { wcag, apca } = spec;
+	if (wcag === void 0 === (apca === void 0)) return false;
+	return wcag !== void 0 ? isPairOf(wcag, isWcagValue) : isPairOf(apca, isApcaValue);
+}
+const SIGNED_NUMBER_RE = /^[+-](?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+* A relative `'+N'` / `'-N'` string with a finite `N`. Whitespace around it
+* is allowed, as the resolver's `parseFloat` reads past it. Also checks a
+* token's structured `darkHue`.
+*/
+const isRelativeValue = (value) => typeof value === "string" && SIGNED_NUMBER_RE.test(value.trim()) && Number.isFinite(parseFloat(value));
+const isToneValue = (value) => isFiniteNumber(value) || value === "max" || value === "min" || isRelativeValue(value);
+const isHueValue = (value) => isFiniteNumber(value) || isRelativeValue(value);
+const isOpacity = (value) => isFiniteNumber(value) && value >= 0 && value <= 1;
+/**
+* Reject a numeric field the resolver can't place: `NaN`, `Infinity`, a
+* relative string that isn't `'+N'` / `'-N'` (`'+-5'`, `'+abc'`), an opacity
+* outside 0–1. Each would otherwise reach the output as `NaN`.
+*/
+function assertField(name, field, value, isValid) {
+	if (value === void 0 || isValid(value)) return;
+	throw new Error(`glaze: color "${name}" has an invalid "${field}" ${showValue(value)}.`);
+}
+/**
+* Reject a malformed `contrast`: a misspelled preset, a non-finite number, an
+* object without exactly one of `wcag` / `apca`, or a pair without exactly two
+* entries. The solver would read each as no target at all and pin the color
+* to the scheme's extreme without a word.
+*/
+function assertValidContrast(name, contrast) {
+	if (contrast === void 0 || isPairOf(contrast, isContrastSpec)) return;
+	throw new Error(`glaze: color "${name}" has an invalid "contrast" ${showValue(contrast)}. Use a WCAG ratio or 'AA' / 'AAA' / 'AA-large' / 'AAA-large', { wcag: … }, { apca: … }, or a [normal, highContrast] pair of these.`);
+}
 /**
 * Reject a `contrast` pair whose two entries measure in different metrics.
 *
@@ -3201,11 +3453,15 @@ function validateColorDefs(defs, externalBases) {
 			const kind = def.type;
 			for (const field of ["bg", "fg"]) {
 				const ref = def[field];
-				if (ref === void 0) continue;
+				if (ref === void 0) {
+					if (field === "fg") continue;
+					throw new Error(`glaze: ${kind} "${name}" is missing "bg".`);
+				}
 				if (!allNames.has(ref)) throw new Error(`glaze: ${kind} "${name}" references non-existent ${field} "${ref}".`);
 				const refKind = overlayKindOf(defs, ref);
 				if (refKind !== void 0) throw new Error(`glaze: ${kind} "${name}" ${field} "${ref}" references a ${refKind} color.`);
 			}
+			assertField(name, "intensity", def.intensity, (v) => isPairOf(v, isFiniteNumber));
 			normalizeLightingTuning(kind, def.tuning, `${kind} "${name}" tuning`, deferred);
 			continue;
 		}
@@ -3217,10 +3473,19 @@ function validateColorDefs(defs, externalBases) {
 				const refKind = overlayKindOf(defs, ref);
 				if (refKind !== void 0) throw new Error(`glaze: mix "${name}" ${field} "${ref}" references a ${refKind} color.`);
 			}
+			assertField(name, "value", def.value, (v) => isPairOf(v, isFiniteNumber));
+			assertValidContrast(name, def.contrast);
 			assertConsistentContrastMetric(name, def.contrast);
 			continue;
 		}
 		const regDef = def;
+		assertField(name, "tone", regDef.tone, (v) => isPairOf(v, isToneValue));
+		assertField(name, "hue", regDef.hue, isHueValue);
+		assertField(name, "darkHue", regDef.darkHue, isHueValue);
+		assertField(name, "saturation", regDef.saturation, isFiniteNumber);
+		assertField(name, "darkSaturation", regDef.darkSaturation, isFiniteNumber);
+		assertField(name, "opacity", regDef.opacity, isOpacity);
+		assertValidContrast(name, regDef.contrast);
 		assertConsistentContrastMetric(name, regDef.contrast);
 		if (regDef.from !== void 0) try {
 			extractOkhslFromValue(regDef.from);
@@ -3320,16 +3585,43 @@ function topoSort(defs) {
 * Variants are stored in OKHST: `h` / `s` are OKHSL hue/saturation and
 * `t` is the canonical contrast-uniform tone (0–1, reference eps). The
 * resolver works in tone for regular colors and converts to/from OKHSL
-* lightness only at the mix / shadow / glow and luminance edges. A glow whose
-* step crosses white with `headroom` above 0 also carries `hdr` — its opaque
-* base in OKHST plus an exposure in stops — and swaps the SDR shortfall
-* warning for one that fires only when the headroom cap falls short. HDR
-* values never feed another color: nothing may build on a glow.
+* lightness only at the mix / shadow / glow and luminance edges. A mix reads
+* a base or target under another `pastel` flag in its own gamut, through the
+* color that endpoint paints, and measures its contrast floor on the color it
+* emits. A glow whose step crosses white with `headroom` above 0 also carries
+* `hdr` — its opaque base in OKHST plus an exposure in stops — and swaps the
+* SDR shortfall warning for one that fires only when the headroom cap falls
+* short. HDR values never feed another color: nothing may build on a glow.
 *
 * Every function receives a single `GlazeConfigResolved` so the full
 * per-instance config (including overrides) is available without
 * re-reading the global singleton mid-resolve.
 */
+/**
+* Defs anchored at their authored tone whatever their mode (see `darkAnchor`).
+* A `glaze.color()` token's hidden seed is `static` only so that its token's
+* `contrast` floor measures against the literal input; a delta on it still
+* steps in dark like one on an `auto` color authored at that tone.
+*/
+const authoredToneAnchors = /* @__PURE__ */ new WeakSet();
+/**
+* Anchor `def` at its authored tone in dark, whatever its mode (internal, for
+* a token's hidden seed; see `authoredToneAnchors`).
+*/
+function anchorAtAuthoredTone(def) {
+	authoredToneAnchors.add(def);
+	return def;
+}
+/**
+* The base of a tone-less, contrast-less `auto` color, which takes its base's
+* dark anchor as is; `undefined` for any other def.
+*/
+function aliasBaseOf(def) {
+	if (def === void 0 || isMixDef(def) || isLightingDef(def)) return;
+	const regDef = def;
+	if ((regDef.mode ?? "auto") !== "auto" || regDef.contrast !== void 0 || regDef.tone !== void 0 || regDef.from !== void 0) return;
+	return regDef.base;
+}
 function getSchemeVariant(color, isDark, isHighContrast) {
 	if (isDark && isHighContrast) return color.darkContrast;
 	if (isDark) return color.dark;
@@ -3550,11 +3842,11 @@ function readsStoredLightTone(isHighContrast, config) {
 * Where a step of `delta` from `anchor` lands on the authored scale: clamped to
 * `0–100`, widened to reach an anchor past the dark window (a base a contrast
 * floor, an extreme's replay, or its own fixed / static placement put there).
-* A step back toward the scale then
-* moves by the full delta, and one that points further out stops at the anchor
-* — the base itself — instead of snapping back to the window's edge. Either
-* way a step stops at the window's edge or at its base, whichever is further
-* out, so the result moves continuously as the base crosses the edge.
+* A step back toward the scale then moves by the full delta, and one that
+* points further out stops at the anchor — the base itself — instead of
+* snapping back to the window's edge. Either way a step stops at the window's
+* edge or at its base, whichever is further out, so the result moves
+* continuously as the base crosses the edge.
 */
 function stepFromAnchor(anchor, delta) {
 	return clamp(anchor + delta, Math.min(0, anchor), Math.max(100, anchor));
@@ -3586,6 +3878,9 @@ function stepFromAnchor(anchor, delta) {
 *   is this pass's. A base under another dark window — or one with no hook — is
 *   read back through this pass's dark window, so a `'+0'` lands on it and the
 *   step is this window's scale times the delta.
+* - A token's hidden seed (`anchorAtAuthoredTone`) is `static`, but returns its
+*   tone as authored, like an `auto` color placed by a tone, so a delta on it
+*   inverts in dark as it would from the same color in a theme.
 *
 * In high contrast and at `contrastLevel: 100` at the reference light eps
 * (`readsStoredLightTone`), a light-side color's light tone *is* its authored
@@ -3595,14 +3890,29 @@ function stepFromAnchor(anchor, delta) {
 *
 * Memoized per resolve and pass on `ctx.anchors`, so a long chain of deltas
 * resolves in linear time without deep recursion: the dark passes run in topo
-* order, so a base's anchor is cached before its dependents ask for it.
+* order, so a base's anchor is cached before its dependents ask for it. A
+* tone-less alias never asks for its own, so a chain of aliases is walked in a
+* loop instead.
 */
 function darkAnchor(name, ctx, isHighContrast) {
 	const memo = ctx.anchors[isHighContrast ? 1 : 0];
 	const cached = memo.get(name);
 	if (cached) return cached;
+	if (aliasBaseOf(ctx.defs[name]) !== void 0) {
+		const chain = [];
+		let target = name;
+		for (let base = aliasBaseOf(ctx.defs[target]); base !== void 0 && !memo.has(target); base = aliasBaseOf(ctx.defs[target])) {
+			chain.push(target);
+			target = base;
+		}
+		let anchor = darkAnchor(target, ctx, isHighContrast);
+		for (let i = chain.length - 1; i >= 0; i--) {
+			anchor = withStoredLightTone(chain[i], anchor, ctx, isHighContrast);
+			memo.set(chain[i], anchor);
+		}
+		return anchor;
+	}
 	const color = ctx.resolved.get(name);
-	const lightTone = getSchemeVariant(color, false, isHighContrast).t * 100;
 	const fromDark = (config) => ({
 		tone: unmapDarkTone(getSchemeVariant(color, true, isHighContrast).t * 100, "auto", isHighContrast, config),
 		lightSide: false
@@ -3622,7 +3932,7 @@ function darkAnchor(name, ctx, isHighContrast) {
 		const config = configForColor(regDef, ctx.config);
 		const rawTone = regDef.tone ?? fromSeed(regDef)?.tone;
 		const parsed = rawTone === void 0 ? void 0 : passTone(rawTone, isHighContrast, config);
-		if (mode !== "auto" || regDef.contrast !== void 0) anchor = fromDark(config);
+		if (mode !== "auto" && !authoredToneAnchors.has(regDef) || regDef.contrast !== void 0) anchor = fromDark(config);
 		else if (parsed === void 0) anchor = darkAnchor(regDef.base, ctx, isHighContrast);
 		else if (parsed.kind === "relative") {
 			const base = darkAnchor(regDef.base, ctx, isHighContrast);
@@ -3638,14 +3948,22 @@ function darkAnchor(name, ctx, isHighContrast) {
 			lightSide: true
 		};
 	}
-	if (anchor.lightSide && readsStoredLightTone(isHighContrast, ctx.config)) anchor = {
-		tone: lightTone,
-		lightSide: true
-	};
+	anchor = withStoredLightTone(name, anchor, ctx, isHighContrast);
 	memo.set(name, anchor);
 	return anchor;
 }
 /**
+* A light-side anchor read as the color's stored light tone where that is its
+* authored tone (`readsStoredLightTone`; see `darkAnchor`).
+*/
+function withStoredLightTone(name, anchor, ctx, isHighContrast) {
+	if (!anchor.lightSide || !readsStoredLightTone(isHighContrast, ctx.config)) return anchor;
+	return {
+		tone: getSchemeVariant(ctx.resolved.get(name), false, isHighContrast).t * 100,
+		lightSide: true
+	};
+}
+/**
 * A resolved color's dark-delta anchor for one pass (see `darkAnchor`), read
 * after its resolve. This is what a `glaze.color()` token hands the resolver
 * (with its config, and cached per pass) when another token links to it as a
@@ -3797,6 +4115,10 @@ function resolveLightingForScheme(name, def, ctx, isDark, isHighContrast) {
 function okhslVariantToLinearRgb(v, pastel) {
 	return okhslToLinearSrgb(v.h, v.s, v.l, pastel);
 }
+/** Saturation at or below which a mix endpoint counts as gray (no hue). */
+const MIX_SAT_EPSILON = 1e-6;
+/** Lightness margin from 0 and 1 for re-reading a mix endpoint's saturation. */
+const MIX_EXTREME_L = 1e-4;
 /**
 * Resolve hue for OKHSL mixing, handling achromatic colors.
 * When one color has no saturation, its hue is meaningless —
@@ -3804,9 +4126,8 @@ function okhslVariantToLinearRgb(v, pastel) {
 * 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;
+	const baseHasSat = base.s > MIX_SAT_EPSILON;
+	const targetHasSat = target.s > MIX_SAT_EPSILON;
 	if (baseHasSat && targetHasSat) return circularLerp(base.h, target.h, t);
 	if (targetHasSat) return target.h;
 	return base.h;
@@ -3818,18 +4139,20 @@ function linearSrgbLerp(base, target, t) {
 		base[2] + (target[2] - base[2]) * t
 	];
 }
-function linearRgbToToneVariant(rgb, pastel) {
-	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])))
-	], pastel);
-	return toToneVariant({
+/**
+* Linear sRGB → OKHSL in one saturation space. Channels are clamped to sRGB
+* first, and a pastel read caps saturation at the pastel limit (same hue and
+* lightness), so the result is a color that space can paint.
+*/
+function linearRgbToOkhsl(rgb, pastel) {
+	const [h, s, l] = srgbToOkhsl(toDisplayGamma(rgb), pastel);
+	return {
 		h,
 		s,
 		l,
-		alpha: 1
-	});
+		alpha: 1,
+		pastel
+	};
 }
 function resolveMixForScheme(name, def, ctx, isDark, isHighContrast) {
 	const baseResolved = ctx.resolved.get(def.base);
@@ -3841,50 +4164,64 @@ function resolveMixForScheme(name, def, ctx, isDark, isHighContrast) {
 	const space = def.space ?? "okhsl";
 	const polarity = roleToPolarity(resolveRole(name, def, ctx));
 	const pastel = def.pastel ?? ctx.config.pastel;
-	const baseLinear = okhslVariantToLinearRgb(baseVariant, baseVariant.pastel ?? ctx.config.pastel);
-	const targetLinear = okhslVariantToLinearRgb(targetVariant, targetVariant.pastel ?? ctx.config.pastel);
+	const basePastel = baseVariant.pastel ?? ctx.config.pastel;
+	const targetPastel = targetVariant.pastel ?? ctx.config.pastel;
+	const baseLinear = okhslVariantToLinearRgb(baseVariant, basePastel);
+	const targetLinear = okhslVariantToLinearRgb(targetVariant, targetPastel);
+	const inMixSpace = (v, own) => {
+		if (own === pastel || v.s <= MIX_SAT_EPSILON) return v;
+		const l = clamp(v.l, MIX_EXTREME_L, 1 - MIX_EXTREME_L);
+		const s = oklabToOkhsl(okhslToOklab(v.h, v.s, l, own), pastel)[1];
+		return {
+			...v,
+			s,
+			pastel
+		};
+	};
+	let mixAt;
+	let paintAt;
+	if (blend === "transparent") {
+		const overlay = inMixSpace(targetVariant, targetPastel);
+		const baseGamma = toDisplayGamma(baseLinear);
+		const overlayGamma = toDisplayGamma(okhslVariantToLinearRgb(overlay, pastel));
+		mixAt = (v) => ({
+			...overlay,
+			alpha: clamp(v, 0, 1)
+		});
+		paintAt = (v) => compositeOverGamma(baseGamma, overlayGamma, v);
+	} else if (space === "srgb") {
+		const lerpAt = (v) => linearSrgbLerp(baseLinear, targetLinear, v);
+		mixAt = (v) => linearRgbToOkhsl(lerpAt(v), pastel);
+		paintAt = pastel ? (v) => {
+			const mixed = mixAt(v);
+			return mixed.s < 1 ? lerpAt(v) : okhslVariantToLinearRgb(mixed, true);
+		} : lerpAt;
+	} else {
+		const from = inMixSpace(baseVariant, basePastel);
+		const to = inMixSpace(targetVariant, targetPastel);
+		mixAt = (v) => ({
+			h: mixHue(from, to, v),
+			s: clamp(from.s + (to.s - from.s) * v, 0, 1),
+			l: clamp(from.l + (to.l - from.l) * v, 0, 1),
+			alpha: 1
+		});
+		paintAt = (v) => okhslVariantToLinearRgb(mixAt(v), pastel);
+	}
 	if (def.contrast !== void 0) {
 		const resolvedContrast = resolveContrastSpec(def.contrast, isHighContrast, ctx.config, polarity);
 		const metric = resolvedContrast.metric;
-		let luminanceAt;
-		if (blend === "transparent") {
-			const baseGamma = toDisplayGamma(baseLinear);
-			const targetGamma = toDisplayGamma(targetLinear);
-			luminanceAt = (v) => metricLuminance(metric, compositeOverGamma(baseGamma, targetGamma, v));
-		} else if (space === "srgb") luminanceAt = (v) => metricLuminance(metric, linearSrgbLerp(baseLinear, targetLinear, v));
-		else luminanceAt = (v) => {
-			return metricLuminance(metric, okhslToLinearSrgb(mixHue(baseVariant, targetVariant, v), baseVariant.s + (targetVariant.s - baseVariant.s) * v, baseVariant.l + (targetVariant.l - baseVariant.l) * v, pastel));
-		};
 		const result = findValueForMixContrast({
 			preferredValue: t,
 			baseLinearRgb: baseLinear,
 			contrast: resolvedContrast,
-			luminanceAtValue: luminanceAt,
+			luminanceAtValue: (v) => metricLuminance(metric, paintAt(v)),
 			flip: ctx.config.autoFlip
 		});
 		t = result.value;
-		if (!result.met) warnMixContrastUnmet(name, isDark, isHighContrast, resolvedContrast, result.contrast);
+		if (!result.met) warnMixContrastUnmet(name, isDark, isHighContrast, resolvedContrast, result.contrast, pastel && !targetPastel && metricScore(metric, metricLuminance(metric, targetLinear), metricLuminance(metric, baseLinear), resolvedContrast.polarity) >= resolvedContrast.target);
 	}
-	if (blend === "transparent") return {
-		...toToneVariant({
-			h: targetVariant.h,
-			s: targetVariant.s,
-			l: targetVariant.l,
-			alpha: clamp(t, 0, 1)
-		}),
-		pastel
-	};
-	if (space === "srgb") return {
-		...linearRgbToToneVariant(linearSrgbLerp(baseLinear, targetLinear, t), pastel),
-		pastel
-	};
 	return {
-		...toToneVariant({
-			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
-		}),
+		...toToneVariant(mixAt(t)),
 		pastel
 	};
 }
@@ -4054,8 +4391,8 @@ function resolveAllColors(seed, defs, config, externalBases, externalAnchors) {
 * Output formatting for resolved color maps.
 *
 * Owns the CSS-string formatter dispatch table (`okhsl` / `rgb` / `hsl` /
-* `oklch`), the HDR glow writer (`formatHdrVariant`, `color(srgb-linear …)`),
-* and the token-map shapes Glaze emits:
+* `oklch`), the HDR glow writer (`formatHdrVariant`: extended `color(srgb …)`,
+* or `color(srgb-linear …)` on request), and the 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.
@@ -4066,7 +4403,8 @@ function resolveAllColors(seed, defs, config, externalBases, externalAnchors) {
 *
 * The HDR tier (`variant.hdr`, a glow past SDR white) is emitted only with
 * `modes.hdr` (`css()`: its `hdr` option), and always as a literal
-* `color(srgb-linear R G B)` — whatever `format`, even under `splitHue`.
+* `color(srgb R G B)` with channels past 1 — whatever `format`, even under
+* `splitHue`.
 * Without it every shape is byte-identical to SDR. Each shape carries it the
 * way its consumer composes values:
 * - Tasty: a sparse `hdr` state key after each SDR key that has one (`''`,
@@ -4146,15 +4484,16 @@ function formatVariant(v, format = "oklch", pastel = false) {
 }
 /**
 * Format a variant's HDR value (`variant.hdr`, set on a glow past white with
-* `headroom`) as `color(srgb-linear R G B)`, or `undefined` when it has none.
-* Always that form, whatever the SDR format: OKLCH lightness clamps at parse
-* time and `rgb()` / `hsl()` cannot pass white. Emitted as a literal, never
-* with a split hue.
-*/
-function formatHdrVariant(v, format = "srgb-linear") {
-	if (format !== "srgb-linear") throw new Error(`glaze: unknown HDR format ${JSON.stringify(format)}. Use 'srgb-linear'.`);
+* `headroom`) as extended `color(srgb R G B)` (default) or
+* `color(srgb-linear R G B)` — the same color, with the brightest channel
+* past 1 — or `undefined` when it has none. One of these whatever the SDR
+* format: OKLCH lightness clamps at parse time and `rgb()` / `hsl()` cannot
+* pass white. Emitted as a literal, never with a split hue.
+*/
+function formatHdrVariant(v, format = "srgb") {
+	if (format !== "srgb" && format !== "srgb-linear") throw new Error(`glaze: unknown HDR format ${JSON.stringify(format)}. Use 'srgb' or 'srgb-linear'.`);
 	if (v.hdr === void 0) return void 0;
-	return formatSrgbLinear(hdrToLinearSrgb(v.hdr));
+	return format === "srgb" ? formatSrgb(hdrToSrgb(v.hdr)) : formatSrgbLinear(hdrToLinearSrgb(v.hdr));
 }
 /**
 * Format a resolved variant as `oklch(L C <hueVar>)`, splicing a CSS hue var
@@ -4381,8 +4720,8 @@ const DTCG_EXTENSION_NAMESPACE = "me.tenphi.glaze";
 * The DTCG form of an HDR value: `exposure` in stops, the luminance `tone`
 * it lands (past 100 unless `headroom` caps a saturated base short of it), the
 * opaque `base` as a DTCG sRGB color (always sRGB, whatever `colorSpace`, and
-* never pastel — the base is standard OKHSL), and the HDR color as linear sRGB
-* components, the brightest above 1.
+* never pastel — the base is standard OKHSL), and the HDR color as extended
+* sRGB components (the numbers of `glaze.formatHdr()`), the brightest above 1.
 */
 function dtcgHdrValue(hdr) {
 	const linear = hdrToLinearSrgb(hdr);
@@ -4392,11 +4731,11 @@ function dtcgHdrValue(hdr) {
 		tone: roundTo(toneFromY(relativeLuminanceFromLinearRgb(linear)), 4),
 		base: dtcgSrgbValue(h, s, l, false),
 		value: {
-			colorSpace: "srgb-linear",
+			colorSpace: "srgb",
 			components: [
-				roundTo(linear[0], 6),
-				roundTo(linear[1], 6),
-				roundTo(linear[2], 6)
+				roundTo(sRGBLinearToGamma(linear[0]), 6),
+				roundTo(sRGBLinearToGamma(linear[1]), 6),
+				roundTo(sRGBLinearToGamma(linear[2]), 6)
 			]
 		}
 	};
@@ -4665,7 +5004,7 @@ 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.darkHue !== void 0 && !(typeof input.darkHue === "number" ? Number.isFinite(input.darkHue) : isRelativeValue(input.darkHue))) throw new Error(`glaze.color: structured darkHue must be a finite number or a '+N' / '-N' offset (got ${showValue(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}).`);
 	}
@@ -4724,7 +5063,9 @@ function standaloneRole(role) {
 * 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
-* variants, so the contrast solver always anchors against it.
+* variants, so the contrast solver always anchors against it. Its dark-delta
+* anchor is still its authored tone (`anchorAtAuthoredTone`), so a delta on it
+* inverts in dark like one on the same color in a theme.
 */
 function buildStandaloneValueDefs(main, options) {
 	const seedHue = typeof options?.hue === "number" ? options.hue : main.h;
@@ -4754,13 +5095,13 @@ function buildStandaloneValueDefs(main, options) {
 		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
 	};
 	const defs = { [primary]: valueDef };
-	if (needsSeedAnchor) defs[STANDALONE_SEED] = {
+	if (needsSeedAnchor) defs[STANDALONE_SEED] = anchorAtAuthoredTone({
 		hue: main.h,
 		saturation: 1,
 		tone: seedTone,
 		mode: "static",
 		role: "surface"
-	};
+	});
 	return {
 		seed: {
 			hue: seedHue,
@@ -4928,7 +5269,8 @@ function resolveBaseToken(base) {
 function isGlazeColorToken(candidate) {
 	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && "resolve" in candidate && typeof candidate.resolve === "function";
 }
-function createColorToken(input, configOverride) {
+function createColorToken(rawInput, configOverride) {
+	const input = copyTokenOptions(rawInput);
 	validateStructuredInput(input);
 	const userName = input.name;
 	if (userName !== void 0) validateStandaloneName(userName);
@@ -4949,12 +5291,12 @@ function createColorToken(input, configOverride) {
 		role: standaloneRole(input.role),
 		base: hasExternalBase ? STANDALONE_BASE : needsSeedAnchor ? STANDALONE_SEED : void 0
 	} };
-	if (needsSeedAnchor) defs[STANDALONE_SEED] = {
+	if (needsSeedAnchor) defs[STANDALONE_SEED] = anchorAtAuthoredTone({
 		tone: pinExtremeTone(pairNormal(input.tone)),
 		saturation: 1,
 		mode: "static",
 		role: "surface"
-	};
+	});
 	const localOverride = copyConfigOverride(configOverride);
 	return createColorTokenFromDefs({
 		hue: input.hue,
@@ -4964,11 +5306,13 @@ function createColorToken(input, configOverride) {
 		kind: "color",
 		version: GLAZE_EXPORT_VERSION,
 		form: "structured",
-		input: buildStructuredInputExport(input, exportArg),
+		input: buildStructuredInputExport(input, baseToken, exportArg),
 		config: freezeConfigForExport(localOverride, exportArg)
 	}));
 }
-function createColorTokenFromValue(value, options, configOverride) {
+function createColorTokenFromValue(input, inputOptions, configOverride) {
+	const value = copyColorValue(input);
+	const options = inputOptions && copyTokenOptions(inputOptions);
 	const main = extractOkhslFromValue(value);
 	const baseToken = resolveBaseToken(options?.base);
 	const { seed, defs, primary } = buildStandaloneValueDefs(main, options);
@@ -4977,40 +5321,43 @@ function createColorTokenFromValue(value, options, configOverride) {
 		kind: "color",
 		version: GLAZE_EXPORT_VERSION,
 		form: "value",
-		input: value,
-		...options !== void 0 ? { overrides: buildOverridesExport(options, exportArg) } : {},
+		input: copyColorValue(value),
+		...options !== void 0 ? { overrides: buildOverridesExport(options, baseToken, exportArg) } : {},
 		config: freezeConfigForExport(localOverride, exportArg)
 	}));
 }
 /**
-* 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.
+* Build a JSON-safe snapshot of `GlazeColorOverrides`. `base` is serialized
+* as its token's own snapshot: a raw value as the token it is wrapped in, so
+* its config is frozen with the rest and a restored token doesn't follow later
+* `glaze.configure()` calls through its base. Every object in it is a fresh
+* copy, so editing a snapshot never reaches the live token.
 */
-function buildOverridesExport(options, exportArg) {
+function buildOverridesExport(options, baseToken, exportArg) {
 	const out = {};
 	if (options.hue !== void 0) out.hue = options.hue;
 	if (options.saturation !== void 0) out.saturation = options.saturation;
-	if (options.tone !== void 0) out.tone = options.tone;
+	if (options.tone !== void 0) out.tone = copyPair(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;
+	if (options.contrast !== void 0) out.contrast = copyContrast(options.contrast);
 	if (options.opacity !== void 0) out.opacity = options.opacity;
 	if (options.name !== void 0) out.name = options.name;
 	if (options.pastel !== void 0) out.pastel = options.pastel;
 	if (options.role !== void 0) out.role = options.role;
-	if (options.base !== void 0) out.base = isGlazeColorToken(options.base) ? options.base.export(exportArg) : options.base;
+	if (baseToken !== void 0) out.base = baseToken.export(exportArg);
 	return out;
 }
-function buildStructuredInputExport(input, exportArg) {
+/** The structured-input counterpart of `buildOverridesExport`. */
+function buildStructuredInputExport(input, baseToken, exportArg) {
 	const out = {
 		hue: input.hue,
 		saturation: input.saturation,
-		tone: input.tone
+		tone: copyPair(input.tone)
 	};
 	if (input.saturationFactor !== void 0) out.saturationFactor = input.saturationFactor;
 	if (input.darkHue !== void 0) out.darkHue = input.darkHue;
@@ -5019,13 +5366,68 @@ function buildStructuredInputExport(input, exportArg) {
 	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;
-	if (input.contrast !== void 0) out.contrast = input.contrast;
+	if (input.contrast !== void 0) out.contrast = copyContrast(input.contrast);
 	if (input.name !== void 0) out.name = input.name;
 	if (input.pastel !== void 0) out.pastel = input.pastel;
 	if (input.role !== void 0) out.role = input.role;
-	if (input.base !== void 0) out.base = isGlazeColorToken(input.base) ? input.base.export(exportArg) : input.base;
+	if (baseToken !== void 0) out.base = baseToken.export(exportArg);
 	return out;
 }
+/** A copy of a `[normal, highContrast]` pair, or the value itself. */
+function copyPair(value) {
+	return Array.isArray(value) ? [...value] : value;
+}
+/**
+* A copy of a `contrast` value, read by property access so a proxy (reactive
+* state) copies too. Other keys of a spec object are kept for the validator.
+*/
+function copyContrast(contrast) {
+	const copySpec = (spec) => {
+		if (typeof spec !== "object" || spec === null) return spec;
+		const out = { ...spec };
+		for (const key of ["wcag", "apca"]) {
+			const value = spec[key];
+			if (value !== void 0) out[key] = copyPair(value);
+		}
+		return out;
+	};
+	return Array.isArray(contrast) ? contrast.map(copySpec) : copySpec(contrast);
+}
+/** Every field of `GlazeColorInput` / `GlazeColorOverrides`. */
+const TOKEN_OPTION_KEYS = [
+	"hue",
+	"saturation",
+	"tone",
+	"saturationFactor",
+	"darkHue",
+	"darkSaturation",
+	"darkSaturationFactor",
+	"mode",
+	"autoFlip",
+	"opacity",
+	"contrast",
+	"base",
+	"name",
+	"pastel",
+	"role"
+];
+/**
+* A detached copy of a token's input or overrides, each field read by property
+* access so a getter, an inherited field or a proxy copies like a plain one.
+* The pairs, `contrast` and a raw value `base` are copied too, so a caller
+* editing them later doesn't change the token (a token `base` is kept, as
+* tokens are immutable). Other keys (a value form's `from`) are left out.
+*/
+function copyTokenOptions(options) {
+	const source = options;
+	const out = {};
+	for (const key of TOKEN_OPTION_KEYS) if (source[key] !== void 0) out[key] = source[key];
+	const copy = out;
+	if (copy.tone !== void 0) copy.tone = copyPair(copy.tone);
+	if (copy.contrast !== void 0) copy.contrast = copyContrast(copy.contrast);
+	if (copy.base !== void 0 && !isGlazeColorToken(copy.base)) copy.base = copyColorValue(copy.base);
+	return copy;
+}
 /**
 * Discriminate a `GlazeColorTokenExport` from a raw `GlazeColorValue`.
 */
@@ -5119,8 +5521,25 @@ function colorFromExport(data) {
 * property, so a `suffix` that lands one on a hue var (`'-hue'`, or `''` with a
 * color named `*-hue`) throws too.
 */
+/**
+* Reject a seed the resolver can't use: every color multiplies its hue and
+* saturation, so a non-finite one paints the whole theme `NaN`.
+*/
+function assertValidSeed(seed) {
+	for (const field of [
+		"hue",
+		"saturation",
+		"darkHue",
+		"darkSaturation"
+	]) {
+		const value = seed?.[field];
+		if ((field === "darkHue" || field === "darkSaturation") && value === void 0) continue;
+		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`glaze: theme seed ${field} must be a finite number (got ${showValue(value)}).`);
+	}
+}
 function createTheme(seed, initialColors, callerOverride) {
 	const configOverride = copyConfigOverride(callerOverride);
+	assertValidSeed(seed);
 	const { hue, saturation, darkHue, darkSaturation } = seed;
 	let colorDefs = initialColors ? { ...initialColors } : {};
 	let cache = null;
@@ -5587,8 +6006,8 @@ function glaze(hueOrOptions, saturationOrConfig, config) {
 	if (typeof hueOrOptions === "number") return createTheme({
 		hue: hueOrOptions,
 		saturation: (typeof saturationOrConfig === "number" ? saturationOrConfig : void 0) ?? 100
-	}, void 0, config);
-	return createTheme(hueOrOptions, void 0, typeof saturationOrConfig === "object" ? saturationOrConfig : config);
+	}, void 0, (config === void 0 || config === null) && typeof saturationOrConfig === "object" && saturationOrConfig !== null ? saturationOrConfig : config);
+	return createTheme(hueOrOptions, void 0, typeof saturationOrConfig === "object" && saturationOrConfig !== null ? saturationOrConfig : config);
 }
 /** Configure global glaze settings. */
 glaze.configure = function configure$1(config) {
@@ -5653,14 +6072,16 @@ glaze.color = function color(input, config) {
 	if (typeof input === "string") return createColorTokenFromValue(input, void 0, config);
 	const obj = input;
 	if ("from" in obj) {
-		const { from, ...overrides } = input;
-		return createColorTokenFromValue(from, overrides, config);
+		const fromInput = input;
+		return createColorTokenFromValue(fromInput.from, fromInput, config);
 	}
 	if ("hue" in obj) return createColorToken(input, config);
 	return createColorTokenFromValue(input, void 0, config);
 };
 /** Shared body of `glaze.shadow()` / `glaze.glow()`. */
 function standaloneLighting(kind, input) {
+	if (input?.bg === void 0) throw new Error(`glaze.${kind}(): "bg" is required.`);
+	if (typeof input.intensity !== "number" || !Number.isFinite(input.intensity)) throw new Error(`glaze.${kind}(): "intensity" must be a finite number (got ${showValue(input.intensity)}).`);
 	const bg = extractOkhslFromValue(input.bg);
 	const fg = input.fg ? extractOkhslFromValue(input.fg) : void 0;
 	const cfg = getConfig();
@@ -5714,19 +6135,19 @@ glaze.format = function format(variant, colorFormat, pastel) {
 };
 /**
 * Format a variant's HDR value — set on a glow whose step crosses SDR white
-* with `headroom` above 0 — as `color(srgb-linear R G B)`, with channels that
-* may exceed 1. Returns `undefined` for a variant without one. Only
-* `'srgb-linear'` is supported: OKLCH lightness clamps at parse time and
-* `rgb()` / `hsl()` cannot go past white.
+* with `headroom` above 0 — as extended `color(srgb R G B)`, with channels
+* that may exceed 1 (`1` is SDR white), or as the same color in linear light
+* with `'srgb-linear'`. Returns `undefined` for a variant without one.
 *
 * @example
 * ```ts
 * const v = glaze.glow({ bg: '#ffffff', intensity: 12, tuning: { headroom: 1 } });
-* glaze.format(v);    // SDR: 'oklch(1 0 0)'
-* glaze.formatHdr(v); // 'color(srgb-linear 1.4631 1.4631 1.4631)'
+* glaze.format(v);                   // SDR: 'oklch(1 0 0)'
+* glaze.formatHdr(v);                // 'color(srgb 1.1813 1.1813 1.1813)'
+* glaze.formatHdr(v, 'srgb-linear'); // 'color(srgb-linear 1.4631 1.4631 1.4631)'
 * ```
 */
-glaze.formatHdr = function formatHdr(variant, hdrFormat = "srgb-linear") {
+glaze.formatHdr = function formatHdr(variant, hdrFormat = "srgb") {
 	return formatHdrVariant(variant, hdrFormat);
 };
 /**
@@ -5817,10 +6238,13 @@ exports.formatOkhsl = formatOkhsl;
 exports.formatOkhst = formatOkhst;
 exports.formatOklch = formatOklch;
 exports.formatRgb = formatRgb;
+exports.formatSrgb = formatSrgb;
 exports.formatSrgbLinear = formatSrgbLinear;
 exports.fromTone = fromTone;
 exports.gamutClampedLuminance = gamutClampedLuminance;
 exports.glaze = glaze;
+exports.hdrToLinearSrgb = hdrToLinearSrgb;
+exports.hdrToSrgb = hdrToSrgb;
 exports.hslToSrgb = hslToSrgb;
 exports.inferRoleFromName = inferRoleFromName;
 exports.isColorTokenExport = isColorTokenExport;