silvery 0.17.3 → 0.18.0

package/dist/{src-9B5k0JmY.mjs → src-D_BS-as7.mjs}

@@ -486,6 +486,169 @@ var init_terminal_control = __esmMin((() => {
 	`${ESC$3}`;
 }));
 //#endregion
+//#region packages/color/src/oklch.ts
+function parseHex(hex) {
+	if (hex[0] !== "#") return null;
+	const h = hex.slice(1);
+	if (h.length === 3) {
+		const r = parseInt(h[0] + h[0], 16);
+		const g = parseInt(h[1] + h[1], 16);
+		const b = parseInt(h[2] + h[2], 16);
+		if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) return null;
+		return [
+			r,
+			g,
+			b
+		];
+	}
+	if (h.length === 6) {
+		const r = parseInt(h.slice(0, 2), 16);
+		const g = parseInt(h.slice(2, 4), 16);
+		const b = parseInt(h.slice(4, 6), 16);
+		if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) return null;
+		return [
+			r,
+			g,
+			b
+		];
+	}
+	return null;
+}
+/** sRGB channel (0–255) → linear RGB (0–1). Inverse gamma. */
+function srgbToLinear(c) {
+	const s = c / 255;
+	return s <= .04045 ? s / 12.92 : ((s + .055) / 1.055) ** 2.4;
+}
+/** Linear RGB (0–1) → sRGB channel (0–255). Forward gamma. */
+function linearToSrgb(c) {
+	const clamped = Math.max(0, Math.min(1, c));
+	return clamped <= .0031308 ? 12.92 * clamped * 255 : (1.055 * clamped ** (1 / 2.4) - .055) * 255;
+}
+/** Linear RGB → OKLab (Ottosson 2020 matrix). */
+function linearRgbToOklab(r, g, b) {
+	const l = .4122214708 * r + .5363325363 * g + .0514459929 * b;
+	const m = .2119034982 * r + .6806995451 * g + .1073969566 * b;
+	const s = .0883024619 * r + .2817188376 * g + .6299787005 * b;
+	const lCbrt = Math.cbrt(l);
+	const mCbrt = Math.cbrt(m);
+	const sCbrt = Math.cbrt(s);
+	return [
+		.2104542553 * lCbrt + .793617785 * mCbrt - .0040720468 * sCbrt,
+		1.9779984951 * lCbrt - 2.428592205 * mCbrt + .4505937099 * sCbrt,
+		.0259040371 * lCbrt + .7827717662 * mCbrt - .808675766 * sCbrt
+	];
+}
+/** OKLab → linear RGB (inverse of the above). */
+function oklabToLinearRgb(L, a, bb) {
+	const lCbrt = L + .3963377774 * a + .2158037573 * bb;
+	const mCbrt = L - .1055613458 * a - .0638541728 * bb;
+	const sCbrt = L - .0894841775 * a - 1.291485548 * bb;
+	const l = lCbrt ** 3;
+	const m = mCbrt ** 3;
+	const s = sCbrt ** 3;
+	return [
+		4.0767416621 * l - 3.3077115913 * m + .2309699292 * s,
+		-1.2684380046 * l + 2.6097574011 * m - .3413193965 * s,
+		-.0041960863 * l - .7034186147 * m + 1.707614701 * s
+	];
+}
+/** Hex (`#RRGGBB`) → OKLCH. Returns `null` for invalid hex. */
+function hexToOklch(hex) {
+	const rgb = parseHex(hex);
+	if (!rgb) return null;
+	const [r, g, b] = rgb;
+	const [lr, lg, lb] = [
+		srgbToLinear(r),
+		srgbToLinear(g),
+		srgbToLinear(b)
+	];
+	const [L, a, bb] = linearRgbToOklab(lr, lg, lb);
+	const C = Math.sqrt(a * a + bb * bb);
+	let H = Math.atan2(bb, a) * 180 / Math.PI;
+	if (H < 0) H += 360;
+	return {
+		L,
+		C,
+		H
+	};
+}
+/** Check whether linear RGB is inside sRGB gamut (each channel in [0, 1]). */
+function inGamut(r, g, b) {
+	const e = 1e-5;
+	return r >= -e && r <= 1 + e && g >= -e && g <= 1 + e && b >= -e && b <= 1 + e;
+}
+/**
+* OKLCH → hex. Gamut-maps out-of-sRGB colors by reducing chroma until in-gamut
+* (preserves L and H — the perceptual anchors). This is the CSS Color 4
+* recommended approach for rendering OKLCH on sRGB displays.
+*/
+function oklchToHex(c) {
+	const L = Math.max(0, Math.min(1, c.L));
+	const Crad = (c.H % 360 + 360) % 360 * Math.PI / 180;
+	let lo = 0;
+	let hi = Math.max(0, c.C);
+	let [rHi, gHi, bHi] = oklabToLinearRgb(L, hi * Math.cos(Crad), hi * Math.sin(Crad));
+	if (inGamut(rHi, gHi, bHi)) return rgbToHexInternal(linearToSrgb(rHi), linearToSrgb(gHi), linearToSrgb(bHi));
+	for (let i = 0; i < 20; i++) {
+		const mid = (lo + hi) / 2;
+		const [rr, gg, bbLin] = oklabToLinearRgb(L, mid * Math.cos(Crad), mid * Math.sin(Crad));
+		if (inGamut(rr, gg, bbLin)) lo = mid;
+		else hi = mid;
+	}
+	const a = lo * Math.cos(Crad);
+	const bb = lo * Math.sin(Crad);
+	[rHi, gHi, bHi] = oklabToLinearRgb(L, a, bb);
+	return rgbToHexInternal(linearToSrgb(rHi), linearToSrgb(gHi), linearToSrgb(bHi));
+}
+function rgbToHexInternal(r, g, b) {
+	const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+	return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`.toUpperCase();
+}
+/**
+* Linear interpolate in OKLab (rectangular — a, b, L interpolated directly).
+*
+* CSS Color Module 4's default interpolation space. Avoids the hue-arc
+* weirdness of `lerpOklch` when one endpoint is near-neutral (its H is
+* effectively undefined). Produces the expected "tinted surface" when blending
+* `bg` with an accent color.
+*/
+function lerpOklabHex(aHex, bHex, t) {
+	const aOk = hexToOklch(aHex);
+	const bOk = hexToOklch(bHex);
+	if (!aOk || !bOk) return null;
+	const aRad = aOk.H * Math.PI / 180;
+	const bRad = bOk.H * Math.PI / 180;
+	const aA = aOk.C * Math.cos(aRad);
+	const aB = aOk.C * Math.sin(aRad);
+	const bA = bOk.C * Math.cos(bRad);
+	const bB = bOk.C * Math.sin(bRad);
+	const L = aOk.L + (bOk.L - aOk.L) * t;
+	const A = aA + (bA - aA) * t;
+	const B = aB + (bB - aB) * t;
+	const C = Math.sqrt(A * A + B * B);
+	let H = Math.atan2(B, A) * 180 / Math.PI;
+	if (H < 0) H += 360;
+	return oklchToHex({
+		L,
+		C,
+		H
+	});
+}
+/**
+* ΔE in OKLCH (≈ ΔE₀₀ quality in practice — OKLCH was designed to make Euclidean
+* distance perceptually meaningful). Hue is weighted by chroma so near-neutral
+* colors don't produce spurious large ΔH contributions.
+*/
+function deltaE(a, b) {
+	const dL = a.L - b.L;
+	const dC = a.C - b.C;
+	const dh = ((a.H - b.H + 540) % 360 - 180) * (Math.PI / 180);
+	(a.C + b.C) / 2;
+	const dH = 2 * Math.sqrt(a.C * b.C) * Math.sin(dh / 2);
+	return Math.sqrt(dL * dL + dC * dC + dH * dH);
+}
+var init_oklch = __esmMin((() => {}));
+//#endregion
 //#region packages/color/src/color.ts
 /** Parse #rrggbb or #rgb to [r, g, b]. Returns null for invalid input. */
 function hexToRgb(hex) {
@@ -509,33 +672,90 @@ function rgbToHex(r, g, b) {
 	return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`.toUpperCase();
 }
 /**
-* Blend two hex colors. t=0 returns a, t=1 returns b.
+* Blend two hex colors in OKLab space. t=0 returns a, t=1 returns b.
+* Perceptually-uniform midpoints (unlike naive RGB blending which produces
+* muddy halfway colors).
+*
+* Interpolation is done in OKLab (rectangular a/b), not OKLCH (polar). This
+* matches CSS Color Module 4's default interpolation space and avoids hue-arc
+* weirdness when one endpoint is near-neutral (its hue is effectively
+* undefined). For explicit hue-rotation blending, use `lerpOklch` directly.
+*
 * For non-hex inputs (ANSI names), returns `a` unchanged.
 */
 function blend(a, b, t) {
-	const rgbA = hexToRgb(a);
-	const rgbB = hexToRgb(b);
-	if (!rgbA || !rgbB) return a;
-	return rgbToHex(rgbA[0] + (rgbB[0] - rgbA[0]) * t, rgbA[1] + (rgbB[1] - rgbA[1]) * t, rgbA[2] + (rgbB[2] - rgbA[2]) * t);
+	return lerpOklabHex(a, b, t) ?? a;
 }
 /**
-* Brighten a hex color. amount=0.1 adds 10% lightness toward white.
-* For non-hex inputs (ANSI names), returns the color unchanged.
+* Brighten a hex color by raising OKLCH lightness. amount=0.1 adds 0.1 to L
+* (perceptually linear — 10% brighter looks 10% brighter regardless of hue).
+*
+* For non-hex inputs, returns the color unchanged.
 */
 function brighten(color, amount) {
-	return blend(color, "#FFFFFF", amount);
+	const o = hexToOklch(color);
+	if (!o) return color;
+	return oklchToHex({
+		L: Math.min(1, o.L + amount),
+		C: o.C,
+		H: o.H
+	});
 }
 /**
-* Darken a hex color. amount=0.1 adds 10% darkness toward black.
-* For non-hex inputs (ANSI names), returns the color unchanged.
+* Darken a hex color by lowering OKLCH lightness. amount=0.1 subtracts 0.1 from L.
+*
+* For non-hex inputs, returns the color unchanged.
 */
 function darken(color, amount) {
-	return blend(color, "#000000", amount);
+	const o = hexToOklch(color);
+	if (!o) return color;
+	return oklchToHex({
+		L: Math.max(0, o.L - amount),
+		C: o.C,
+		H: o.H
+	});
+}
+/**
+* Desaturate a hex color by lowering OKLCH chroma. amount=0.4 reduces C by 40%
+* (relative — consistent with the original HSL-based contract). For a flat
+* subtraction, use `saturate(color, -amount)`.
+*
+* For non-hex inputs, returns the color unchanged.
+*/
+function desaturate(color, amount) {
+	const o = hexToOklch(color);
+	if (!o) return color;
+	return oklchToHex({
+		L: o.L,
+		C: Math.max(0, o.C * (1 - amount)),
+		H: o.H
+	});
+}
+/**
+* Get the complementary color (180° hue rotation) in OKLCH. Preserves L + C,
+* so the complement has the same perceived brightness and colorfulness.
+*
+* For non-hex inputs, returns the color unchanged.
+*/
+function complement(color) {
+	const o = hexToOklch(color);
+	if (!o) return color;
+	return oklchToHex({
+		L: o.L,
+		C: o.C,
+		H: (o.H + 180) % 360
+	});
+}
+/** Perceptual color distance (ΔE) between two hex colors, in OKLCH. */
+function colorDistance(a, b) {
+	const oa = hexToOklch(a);
+	const ob = hexToOklch(b);
+	if (!oa || !ob) return null;
+	return deltaE(oa, ob);
 }
 /**
-* Linearize an sRGB channel value (0-255) for luminance calculation.
-* Per WCAG 2.1: values below the threshold use a linear scale,
-* above use the gamma-corrected formula.
+* Linearize an sRGB channel value (0-255) for WCAG 2.1 luminance.
+* Kept for WCAG contrast checking — OKLCH uses its own linearization.
 */
 function channelLuminance(c) {
 	const s = c / 255;
@@ -552,7 +772,7 @@ function relativeLuminance(hex) {
 }
 /**
 * Pick black or white text for readability on the given background.
-* Uses relative luminance (WCAG formula).
+* Uses WCAG 2.1 relative luminance.
 */
 function contrastFg(bg) {
 	const luminance = relativeLuminance(bg);
@@ -596,28 +816,9 @@ function hexToHsl(hex) {
 	if (!rgb) return null;
 	return rgbToHsl(rgb[0], rgb[1], rgb[2]);
 }
-/**
-* Desaturate a hex color by reducing saturation.
-* amount=0.4 reduces saturation by 40%.
-* For non-hex inputs, returns the color unchanged.
-*/
-function desaturate(color, amount) {
-	const hsl = hexToHsl(color);
-	if (!hsl) return color;
-	const [h, s, l] = hsl;
-	return hslToHex(h, s * (1 - amount), l);
-}
-/**
-* Get the complementary color (180° hue rotation).
-* For non-hex inputs, returns the color unchanged.
-*/
-function complement(color) {
-	const hsl = hexToHsl(color);
-	if (!hsl) return color;
-	const [h, s, l] = hsl;
-	return hslToHex(h + 180, s, l);
-}
-var init_color = __esmMin((() => {}));
+var init_color = __esmMin((() => {
+	init_oklch();
+}));
 //#endregion
 //#region packages/color/src/contrast.ts
 /**
@@ -653,24 +854,24 @@ function checkContrast(fg, bg) {
 	};
 }
 /**
-* Adjust a color's lightness until it meets a minimum contrast ratio
-* against a reference color. Preserves hue and saturation — only
-* lightness is shifted, and only as much as needed.
+* Adjust a color's OKLCH lightness until it meets a minimum WCAG contrast ratio
+* against a reference color. Preserves hue and chroma — only lightness shifts,
+* and only as much as needed.
 *
 * Returns the original color unchanged if it already meets the target.
 *
+* For impossible targets (e.g. 21:1 against mid-gray), returns the
+* best achievable color (near-black or near-white in the same hue).
+*
 * @param color - The color to adjust (hex)
 * @param against - The reference background color (hex)
 * @param minRatio - Minimum contrast ratio to achieve (e.g. 4.5 for AA)
 * @returns Adjusted hex color meeting the target, or original if already OK
 *
-* For impossible targets (e.g. 21:1 against mid-gray), returns the
-* best achievable color (near-black or near-white in the same hue).
-*
 * @example
 * ```typescript
-* // Yellow on white — too low contrast, gets darkened
-* ensureContrast("#FFAB91", "#FFFFFF", 4.5)  // → "#B35600" (darker orange)
+* // Yellow on white — too low contrast, gets darkened (perceptually; same hue preserved)
+* ensureContrast("#FFAB91", "#FFFFFF", 4.5)
 *
 * // Blue on dark bg — already fine, returned unchanged
 * ensureContrast("#5C9FFF", "#1A1A2E", 4.5)  // → "#5C9FFF"
@@ -680,36 +881,45 @@ function ensureContrast(color, against, minRatio) {
 	const current = checkContrast(color, against);
 	if (!current) return color;
 	if (current.ratio >= minRatio) return color;
-	const hsl = hexToHsl(color);
-	if (!hsl) return color;
-	const [h, s] = hsl;
+	const o = hexToOklch(color);
+	if (!o) return color;
 	const lightBg = contrastFg(against) === "#000000";
 	let lo, hi;
 	if (lightBg) {
 		lo = 0;
-		hi = hsl[2];
+		hi = o.L;
 	} else {
-		lo = hsl[2];
+		lo = o.L;
 		hi = 1;
 	}
-	for (let i = 0; i < 20; i++) {
+	for (let i = 0; i < 24; i++) {
 		const mid = (lo + hi) / 2;
-		const r = checkContrast(hslToHex(h, s, mid), against);
+		const r = checkContrast(oklchToHex({
+			L: mid,
+			C: o.C,
+			H: o.H
+		}), against);
 		if (!r) break;
 		if (lightBg) if (r.ratio >= minRatio) lo = mid;
 		else hi = mid;
 		else if (r.ratio >= minRatio) hi = mid;
 		else lo = mid;
 	}
-	return hslToHex(h, s, lightBg ? lo : hi);
+	return oklchToHex({
+		L: lightBg ? lo : hi,
+		C: o.C,
+		H: o.H
+	});
 }
 var init_contrast = __esmMin((() => {
+	init_oklch();
 	init_color();
 }));
 //#endregion
 //#region packages/color/src/index.ts
 var init_src$1 = __esmMin((() => {
 	init_color();
+	init_oklch();
 	init_contrast();
 }));
 //#endregion
@@ -757,8 +967,15 @@ function resolveToken(name, theme) {
 		const idx = parseInt(token.slice(5), 10);
 		if (idx >= 0 && idx < 16 && theme.palette && idx < theme.palette.length) return theme.palette[idx];
 	}
-	const val = theme[token.replace(/-/g, "")];
-	return typeof val === "string" ? val : void 0;
+	const key = token.replace(/-/g, "");
+	const themeObj = theme;
+	const direct = themeObj[key];
+	if (typeof direct === "string") return direct;
+	const aliased = PRIMER_ALIASES[key];
+	if (aliased) {
+		const val = themeObj[aliased];
+		if (typeof val === "string") return val;
+	}
 }
 /** Convert chalk numeric level (0-3) to ColorLevel. */
 function fromChalkLevel(n) {
@@ -971,10 +1188,44 @@ function createChainWithRef(state, ref) {
 	proxyRef.proxy = proxy;
 	return proxy;
 }
-var ESC$2, KNOWN_METHODS, THEME_TOKENS;
+var PRIMER_ALIASES, ESC$2, KNOWN_METHODS, THEME_TOKENS;
 var init_style = __esmMin((() => {
 	init_detection();
 	init_colors();
+	PRIMER_ALIASES = {
+		fgmuted: "muted",
+		fgdisabled: "disabledfg",
+		fgcursor: "cursor",
+		fgselected: "selection",
+		fginverse: "inverse",
+		fgonsurface: "surface",
+		fgonpopover: "popover",
+		fgonprimary: "primaryfg",
+		fgonsecondary: "secondaryfg",
+		fgonaccent: "accentfg",
+		fgonerror: "errorfg",
+		fgonwarning: "warningfg",
+		fgonsuccess: "successfg",
+		fgoninfo: "infofg",
+		bgmuted: "mutedbg",
+		bgsurface: "surfacebg",
+		bgpopover: "popoverbg",
+		bginverse: "inversebg",
+		bgselected: "selectionbg",
+		bgcursor: "cursorbg",
+		borderfocus: "focusborder",
+		borderinput: "inputborder",
+		brandhover: "brandHover",
+		brandactive: "brandActive",
+		brandred: "brandRed",
+		brandorange: "brandOrange",
+		brandyellow: "brandYellow",
+		brandgreen: "brandGreen",
+		brandteal: "brandTeal",
+		brandblue: "brandBlue",
+		brandpurple: "brandPurple",
+		brandpink: "brandPink"
+	};
 	ESC$2 = "\x1B[";
 	KNOWN_METHODS = new Set([
 		"hex",
@@ -1074,11 +1325,302 @@ var init_mixed_proxy = __esmMin((() => {
 	]);
 }));
 //#endregion
+//#region packages/ansi/src/theme/invariants.ts
+function lightness(hex) {
+	const o = hexToOklch(hex);
+	return o ? o.L : null;
+}
+/**
+* Validate post-derivation invariants on a Theme.
+*
+* Default: visibility checks only (selection ΔL, cursor ΔE). These are
+* invariants that `deriveTheme` doesn't enforce and that matter for every
+* theme regardless of authoring pedigree.
+*
+* Opt into WCAG contrast checks via `{ wcag: true }`. Use at build-time to
+* verify bundled themes, or when loading hand-authored Theme objects that
+* didn't flow through `deriveTheme`'s `ensureContrast` pass.
+*
+* Non-hex values (ANSI names from `ansi16` mode) are skipped with no
+* violation — ANSI 16 themes can't be contrast-checked in hex space.
+*
+* @example
+* ```ts
+* // Default — visibility only, fast
+* const { ok, violations } = validateThemeInvariants(theme)
+*
+* // Build-time audit — full WCAG check
+* const audit = validateThemeInvariants(theme, { wcag: true })
+* ```
+*/
+function validateThemeInvariants(theme, opts = {}) {
+	const checkWcag = opts.wcag ?? false;
+	const checkVisibility = opts.visibility ?? true;
+	const violations = [];
+	if (checkWcag) for (const pair of CONTRAST_PAIRS) {
+		const fg = theme[pair.fg];
+		const bg = theme[pair.bg];
+		if (typeof fg !== "string" || typeof bg !== "string") continue;
+		const r = checkContrast(fg, bg);
+		if (r === null) continue;
+		if (r.ratio < pair.min) violations.push({
+			rule: pair.rule,
+			tokens: [String(pair.fg), String(pair.bg)],
+			actual: r.ratio,
+			required: pair.min,
+			message: `${pair.fg} (${fg}) on ${pair.bg} (${bg}) is ${r.ratio.toFixed(2)}:1, needs ${pair.min.toFixed(1)}:1`
+		});
+	}
+	if (checkVisibility) {
+		const lBg = lightness(theme.bg);
+		const lSelBg = lightness(theme.selectionbg);
+		if (lBg !== null && lSelBg !== null) {
+			const dL = Math.abs(lSelBg - lBg);
+			if (dL < .08) violations.push({
+				rule: "visibility:selection",
+				tokens: ["selectionbg", "bg"],
+				actual: dL,
+				required: SELECTION_DELTA_L,
+				message: `selectionbg (${theme.selectionbg}) differs from bg (${theme.bg}) by ΔL=${dL.toFixed(3)}, needs ≥ ${SELECTION_DELTA_L.toFixed(2)}`
+			});
+		}
+		const oBg = hexToOklch(theme.bg);
+		const oCursorBg = hexToOklch(theme.cursorbg);
+		if (oBg && oCursorBg) {
+			const de = deltaE(oBg, oCursorBg);
+			if (de < .15) violations.push({
+				rule: "visibility:cursor",
+				tokens: ["cursorbg", "bg"],
+				actual: de,
+				required: CURSOR_DELTA_E,
+				message: `cursorbg (${theme.cursorbg}) differs from bg (${theme.bg}) by ΔE=${de.toFixed(3)}, needs ≥ ${CURSOR_DELTA_E.toFixed(2)}`
+			});
+		}
+	}
+	return {
+		ok: violations.length === 0,
+		violations
+	};
+}
+/**
+* Format violations as a multiline error message for throws/logs.
+*/
+function formatViolations(violations) {
+	if (violations.length === 0) return "";
+	return violations.map((v) => `  - [${v.rule}] ${v.message}`).join("\n");
+}
+var AA_RATIO, FAINT_RATIO, SELECTION_DELTA_L, CURSOR_DELTA_E, CONTRAST_PAIRS, ThemeInvariantError;
+var init_invariants = __esmMin((() => {
+	init_src$1();
+	AA_RATIO = 4.5;
+	FAINT_RATIO = 1.5;
+	SELECTION_DELTA_L = .08;
+	CURSOR_DELTA_E = .15;
+	CONTRAST_PAIRS = [
+		{
+			rule: "contrast:fg/bg",
+			fg: "fg",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:fg/surfacebg",
+			fg: "fg",
+			bg: "surfacebg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:fg/popoverbg",
+			fg: "fg",
+			bg: "popoverbg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:muted/mutedbg",
+			fg: "muted",
+			bg: "mutedbg",
+			min: 3
+		},
+		{
+			rule: "contrast:primary/bg",
+			fg: "primary",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:secondary/bg",
+			fg: "secondary",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:accent/bg",
+			fg: "accent",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:error/bg",
+			fg: "error",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:warning/bg",
+			fg: "warning",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:success/bg",
+			fg: "success",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:info/bg",
+			fg: "info",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:link/bg",
+			fg: "link",
+			bg: "bg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:inverse/inversebg",
+			fg: "inverse",
+			bg: "inversebg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:selection/selectionbg",
+			fg: "selection",
+			bg: "selectionbg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:cursor/cursorbg",
+			fg: "cursor",
+			bg: "cursorbg",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:primaryfg/primary",
+			fg: "primaryfg",
+			bg: "primary",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:secondaryfg/secondary",
+			fg: "secondaryfg",
+			bg: "secondary",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:accentfg/accent",
+			fg: "accentfg",
+			bg: "accent",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:errorfg/error",
+			fg: "errorfg",
+			bg: "error",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:warningfg/warning",
+			fg: "warningfg",
+			bg: "warning",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:successfg/success",
+			fg: "successfg",
+			bg: "success",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:infofg/info",
+			fg: "infofg",
+			bg: "info",
+			min: AA_RATIO
+		},
+		{
+			rule: "contrast:inputborder/bg",
+			fg: "inputborder",
+			bg: "bg",
+			min: 3
+		},
+		{
+			rule: "contrast:focusborder/bg",
+			fg: "focusborder",
+			bg: "bg",
+			min: 3
+		},
+		{
+			rule: "contrast:disabledfg/bg",
+			fg: "disabledfg",
+			bg: "bg",
+			min: 3
+		},
+		{
+			rule: "contrast:border/bg",
+			fg: "border",
+			bg: "bg",
+			min: FAINT_RATIO
+		}
+	];
+	ThemeInvariantError = class extends Error {
+		violations;
+		constructor(violations) {
+			super(`Theme invariants failed (${violations.length} violation${violations.length === 1 ? "" : "s"}):\n${formatViolations(violations)}`);
+			this.name = "ThemeInvariantError";
+			this.violations = violations;
+		}
+	};
+}));
+//#endregion
 //#region packages/ansi/src/theme/derive.ts
 function deriveTheme(palette, mode = "truecolor", adjustments) {
 	if (mode === "ansi16") return deriveAnsi16Theme(palette);
 	return deriveTruecolorTheme(palette, adjustments);
 }
+/**
+* Load and validate a theme from a ColorScheme.
+*
+* Combines `deriveTheme()` (auto-adjust via ensureContrast with project-tuned
+* thresholds) with `validateThemeInvariants()` (post-derivation visibility +
+* optional WCAG).
+*
+* We don't re-impose WCAG on top of derive's tweaked thresholds — default
+* validation checks visibility invariants only (selection/cursor vs bg) that
+* derive doesn't handle.
+*
+* @example
+* ```ts
+* // Default: lenient + visibility-only (derive already handled contrast)
+* const theme = loadTheme(myScheme)
+*
+* // Build-time audit: strict + full WCAG
+* const theme = loadTheme(myScheme, { enforce: "strict", wcag: true })
+* ```
+*/
+function loadTheme(palette, opts = {}) {
+	const mode = opts.mode ?? "truecolor";
+	const enforce = opts.enforce ?? "lenient";
+	const theme = deriveTheme(palette, mode, opts.adjustments);
+	if (enforce === "off") return theme;
+	const { ok, violations } = validateThemeInvariants(theme, { wcag: opts.wcag });
+	if (!ok) {
+		if (enforce === "strict") throw new ThemeInvariantError(violations);
+		if (opts.violations) opts.violations.push(...violations);
+	}
+	return theme;
+}
 function deriveTruecolorTheme(p, adjustments) {
 	const dark = p.dark ?? true;
 	const bg = p.background;
@@ -1110,13 +1652,26 @@ function deriveTruecolorTheme(p, adjustments) {
 	const success = ensure("success", p.green, bg, AA);
 	const info = ensure("info", blend(fg, accent, .5), bg, AA);
 	const link = ensure("link", dark ? p.brightBlue : p.blue, bg, AA);
+	const brand = primary;
+	const brandHover = dark ? brighten(primary, .04) : darken(primary, .04);
+	const brandActive = dark ? brighten(primary, .08) : darken(primary, .08);
+	const red = ensure("red", p.red, bg, AA);
+	const orange = ensure("orange", blend(p.red, p.yellow, .5), bg, AA);
+	const yellow = ensure("yellow", p.yellow, bg, AA);
+	const green = ensure("green", p.green, bg, AA);
+	const teal = ensure("teal", blend(p.green, p.cyan, .5), bg, AA);
+	const blue = ensure("blue", dark ? p.brightBlue : p.blue, bg, AA);
+	const purple = ensure("purple", p.magenta, bg, AA);
+	const pink = ensure("pink", blend(p.magenta, p.red, .5), bg, AA);
 	const mutedbg = blend(bg, p.foreground, .04);
 	const muted = ensure("muted", blend(fg, bg, .4), mutedbg, AA);
 	const disabledfg = ensure("disabledfg", blend(fg, bg, .5), bg, DIM);
 	const border = ensure("border", blend(bg, p.foreground, .15), bg, FAINT);
 	const inputborder = ensure("inputborder", blend(bg, p.foreground, .25), bg, CONTROL);
-	const selection = ensure("selection", p.selectionForeground, p.selectionBackground, AA);
-	const cursor = ensure("cursor", p.cursorText, p.cursorColor, AA);
+	const selectionBg = repairSelectionBg(p.selectionBackground, bg);
+	const selection = ensure("selection", p.selectionForeground, selectionBg, AA);
+	const cursorBgRepaired = repairCursorBg(p.cursorColor, bg);
+	const cursor = ensure("cursor", p.cursorText, cursorBgRepaired, AA);
 	return {
 		name: p.name ?? (dark ? "derived-dark" : "derived-light"),
 		bg,
@@ -1130,9 +1685,9 @@ function deriveTruecolorTheme(p, adjustments) {
 		inverse: contrastFg(blend(fg, bg, .1)),
 		inversebg: blend(fg, bg, .1),
 		cursor,
-		cursorbg: p.cursorColor,
+		cursorbg: cursorBgRepaired,
 		selection,
-		selectionbg: p.selectionBackground,
+		selectionbg: selectionBg,
 		primary,
 		primaryfg: contrastFg(primary),
 		secondary,
@@ -1169,7 +1724,26 @@ function deriveTruecolorTheme(p, adjustments) {
 			p.brightMagenta,
 			p.brightCyan,
 			p.brightWhite
-		]
+		],
+		brand,
+		brandHover,
+		brandActive,
+		red,
+		orange,
+		yellow,
+		green,
+		teal,
+		blue,
+		purple,
+		pink,
+		brandRed: red,
+		brandOrange: orange,
+		brandYellow: yellow,
+		brandGreen: green,
+		brandTeal: teal,
+		brandBlue: blue,
+		brandPurple: purple,
+		brandPink: pink
 	};
 }
 function deriveAnsi16Theme(p) {
@@ -1227,21 +1801,281 @@ function deriveAnsi16Theme(p) {
 			p.brightMagenta,
 			p.brightCyan,
 			p.brightWhite
-		]
+		],
+		brand: primaryColor,
+		brandHover: primaryColor,
+		brandActive: primaryColor,
+		brandRed: dark ? p.brightRed : p.red,
+		brandOrange: dark ? p.brightRed : p.red,
+		brandYellow: p.yellow,
+		brandGreen: dark ? p.brightGreen : p.green,
+		brandTeal: p.cyan,
+		brandBlue: dark ? p.brightBlue : p.blue,
+		brandPurple: p.magenta,
+		brandPink: dark ? p.brightMagenta : p.magenta
 	};
 }
+/**
+* Nudge `selectionBg`'s OKLCH lightness until it differs from `bg` by at least
+* `SELECTION_DELTA_L`. Preserves hue + chroma. Non-hex input returns unchanged.
+*
+* Direction: shift away from bg — if bg is dark, lift L; if bg is light, drop L.
+* If the input already meets the threshold, it's returned unchanged.
+*/
+function repairSelectionBg(selectionBg, bg) {
+	const oSel = hexToOklch(selectionBg);
+	const oBg = hexToOklch(bg);
+	if (!oSel || !oBg) return selectionBg;
+	const dL = Math.abs(oSel.L - oBg.L);
+	if (dL >= .08) return selectionBg;
+	const needed = SELECTION_DELTA_L - dL + .005;
+	const direction = oSel.L >= oBg.L ? 1 : -1;
+	return oklchToHex({
+		L: Math.max(0, Math.min(1, oSel.L + direction * needed)),
+		C: oSel.C,
+		H: oSel.H
+	});
+}
+/**
+* Nudge `cursorBg`'s OKLCH values until it differs from `bg` by at least
+* `CURSOR_DELTA_E`. Shifts lightness first (preserves hue/chroma aesthetics).
+* Non-hex input returns unchanged.
+*/
+function repairCursorBg(cursorBg, bg) {
+	const d = colorDistance(cursorBg, bg);
+	if (d === null || d >= .15) return cursorBg;
+	const oCur = hexToOklch(cursorBg);
+	const oBg = hexToOklch(bg);
+	const lGap = SELECTION_DELTA_L + .02;
+	const direction = oCur.L >= oBg.L ? 1 : -1;
+	const candidate = oklchToHex({
+		L: Math.max(0, Math.min(1, oCur.L + direction * lGap)),
+		C: oCur.C,
+		H: oCur.H
+	});
+	const d2 = colorDistance(candidate, bg);
+	if (d2 !== null && d2 >= .15) return candidate;
+	return oBg.L > .5 ? "#000000" : "#FFFFFF";
+}
 var AA, DIM, FAINT, CONTROL;
 var init_derive = __esmMin((() => {
 	init_src$1();
+	init_invariants();
 	AA = 4.5;
 	DIM = 3;
 	FAINT = 1.5;
 	CONTROL = 3;
 }));
 //#endregion
-//#region packages/ansi/src/theme/default-palettes.ts
-var ansi16DarkTheme, ansi16LightTheme;
-var init_default_palettes = __esmMin((() => {
+//#region packages/ansi/src/theme/monochrome.ts
+/**
+* Produce per-token monochrome attrs from a base Theme.
+*
+* Currently returns `DEFAULT_MONO_ATTRS` — a canonical mapping. Passed the
+* theme to allow per-theme overrides in the future (e.g., a palette that
+* prefers `underline` for accents over `italic`). The argument is reserved.
+*/
+function deriveMonochromeTheme(theme) {
+	return DEFAULT_MONO_ATTRS;
+}
+/**
+* Resolve mono-attrs from a color *string* — the high-level entry point
+* consumed by the render pipeline.
+*
+* Accepts strings like `"$primary"`, `"$fg-muted"`, `"$border-focus"`. Strips
+* the `$` prefix and hyphens, tries direct Theme key lookup, then falls back
+* to the Primer alias table. Returns `undefined` for non-token strings (hex,
+* rgb(), named ANSI colors) — callers should treat this as "no attrs".
+*
+* @param color    The color string (e.g. `"$primary"`, `"#ff0000"`, `"red"`)
+* @param theme    Active theme (reserved for per-theme overrides)
+* @returns        Array of mono-attrs for the token, or `undefined` if not a
+*                 recognized token.
+*/
+function monoAttrsForColorString(color, theme) {
+	if (!color.startsWith("$")) return void 0;
+	const raw = color.slice(1).replace(/-/g, "");
+	const attrs = deriveMonochromeTheme(theme);
+	const direct = attrs[raw];
+	if (direct !== void 0) return direct;
+	const aliased = PRIMER_ALIASES_FOR_MONO[raw];
+	if (aliased) {
+		const v = attrs[aliased];
+		if (v !== void 0) return v;
+	}
+}
+var DEFAULT_MONO_ATTRS, PRIMER_ALIASES_FOR_MONO;
+var init_monochrome = __esmMin((() => {
+	DEFAULT_MONO_ATTRS = {
+		bg: [],
+		mutedbg: [],
+		surfacebg: [],
+		popoverbg: [],
+		border: [],
+		cursorbg: [],
+		fg: [],
+		muted: ["dim"],
+		disabledfg: ["dim"],
+		surface: [],
+		popover: [],
+		inverse: ["inverse"],
+		primary: ["bold"],
+		secondary: ["bold"],
+		accent: ["italic", "bold"],
+		error: ["bold", "inverse"],
+		warning: ["bold"],
+		success: ["bold"],
+		info: ["italic"],
+		primaryfg: [],
+		secondaryfg: [],
+		accentfg: [],
+		errorfg: ["inverse"],
+		warningfg: [],
+		successfg: [],
+		infofg: [],
+		link: ["underline"],
+		focusborder: ["bold"],
+		inputborder: [],
+		selection: [],
+		selectionbg: ["inverse"],
+		cursor: []
+	};
+	PRIMER_ALIASES_FOR_MONO = {
+		fgmuted: "muted",
+		fgdisabled: "disabledfg",
+		fgcursor: "cursor",
+		fgselected: "selection",
+		fginverse: "inverse",
+		fgonsurface: "surface",
+		fgonpopover: "popover",
+		fgonprimary: "primaryfg",
+		fgonsecondary: "secondaryfg",
+		fgonaccent: "accentfg",
+		fgonerror: "errorfg",
+		fgonwarning: "warningfg",
+		fgonsuccess: "successfg",
+		fgoninfo: "infofg",
+		bgmuted: "mutedbg",
+		bgsurface: "surfacebg",
+		bgpopover: "popoverbg",
+		bginverse: "inversebg",
+		bgselected: "selectionbg",
+		bgcursor: "cursorbg",
+		borderfocus: "focusborder",
+		borderinput: "inputborder"
+	};
+}));
+//#endregion
+//#region packages/ansi/src/theme/fingerprint.ts
+/**
+* Map ΔE thresholds into a 0–1 confidence.
+*
+* sumΔE=0 + maxΔE=0 → 1.0 (perfect match)
+* sumΔE=30 (threshold)  → ~0.5
+* sumΔE≥60 → ~0.0
+*/
+function computeConfidence(sumDE, maxDE, sumThreshold) {
+	const sumScore = Math.max(0, 1 - sumDE / (sumThreshold * 2));
+	const maxScore = Math.max(0, 1 - maxDE / 16);
+	return Math.max(0, Math.min(1, .7 * sumScore + .3 * maxScore));
+}
+/**
+* Match probed slots against a catalog, returning the best candidate if it
+* satisfies both sum and per-slot thresholds. Returns `null` if nothing matches.
+*
+* `probed` is a partial ColorScheme — whatever slots OSC queries returned. Missing
+* slots are skipped (still counted as "not compared"). Non-hex values are
+* ignored (ΔE can't be computed).
+*/
+function fingerprintMatch(probed, catalog, opts = {}) {
+	const sumThreshold = opts.sumThreshold ?? 30;
+	const perSlotThreshold = opts.perSlotThreshold ?? 8;
+	let best = null;
+	for (const scheme of catalog) {
+		let sumDE = 0;
+		let maxDE = 0;
+		let slotsCompared = 0;
+		for (const field of FINGERPRINT_FIELDS) {
+			const probedVal = probed[field];
+			const catalogVal = scheme[field];
+			if (typeof probedVal !== "string" || typeof catalogVal !== "string") continue;
+			const de = colorDistance(probedVal, catalogVal);
+			if (de === null) continue;
+			const scaled = de * 100;
+			sumDE += scaled;
+			if (scaled > maxDE) maxDE = scaled;
+			slotsCompared++;
+		}
+		if (slotsCompared === 0) continue;
+		if (maxDE > perSlotThreshold) continue;
+		if (sumDE > sumThreshold) continue;
+		if (best === null || sumDE < best.sumDeltaE) best = {
+			scheme,
+			sumDeltaE: sumDE,
+			maxDeltaE: maxDE,
+			slotsCompared,
+			confidence: computeConfidence(sumDE, maxDE, sumThreshold)
+		};
+	}
+	return best;
+}
+var FINGERPRINT_FIELDS;
+var init_fingerprint = __esmMin((() => {
+	init_src$1();
+	FINGERPRINT_FIELDS = [
+		"foreground",
+		"background",
+		"black",
+		"red",
+		"green",
+		"yellow",
+		"blue",
+		"magenta",
+		"cyan",
+		"white",
+		"brightBlack",
+		"brightRed",
+		"brightGreen",
+		"brightYellow",
+		"brightBlue",
+		"brightMagenta",
+		"brightCyan",
+		"brightWhite"
+	];
+}));
+//#endregion
+//#region packages/ansi/src/theme/types.ts
+var COLOR_SCHEME_FIELDS;
+var init_types = __esmMin((() => {
+	COLOR_SCHEME_FIELDS = [
+		"black",
+		"red",
+		"green",
+		"yellow",
+		"blue",
+		"magenta",
+		"cyan",
+		"white",
+		"brightBlack",
+		"brightRed",
+		"brightGreen",
+		"brightYellow",
+		"brightBlue",
+		"brightMagenta",
+		"brightCyan",
+		"brightWhite",
+		"foreground",
+		"background",
+		"cursorColor",
+		"cursorText",
+		"selectionBackground",
+		"selectionForeground"
+	];
+}));
+//#endregion
+//#region packages/ansi/src/theme/default-schemes.ts
+var ansi16DarkTheme, ansi16LightTheme, defaultDarkScheme, defaultLightScheme;
+var init_default_schemes = __esmMin((() => {
 	ansi16DarkTheme = {
 		name: "dark-ansi16",
 		bg: "",
@@ -1294,7 +2128,26 @@ var init_default_palettes = __esmMin((() => {
 			"magentaBright",
 			"cyanBright",
 			"whiteBright"
-		]
+		],
+		brand: "yellow",
+		brandHover: "yellow",
+		brandActive: "yellow",
+		red: "redBright",
+		orange: "redBright",
+		yellow: "yellow",
+		green: "greenBright",
+		teal: "cyan",
+		blue: "blueBright",
+		purple: "magenta",
+		pink: "magentaBright",
+		brandRed: "redBright",
+		brandOrange: "redBright",
+		brandYellow: "yellow",
+		brandGreen: "greenBright",
+		brandTeal: "cyan",
+		brandBlue: "blueBright",
+		brandPurple: "magenta",
+		brandPink: "magentaBright"
 	};
 	ansi16LightTheme = {
 		name: "light-ansi16",
@@ -1348,37 +2201,79 @@ var init_default_palettes = __esmMin((() => {
 			"magentaBright",
 			"cyanBright",
 			"whiteBright"
-		]
+		],
+		brand: "blue",
+		brandHover: "blue",
+		brandActive: "blue",
+		red: "red",
+		orange: "red",
+		yellow: "yellow",
+		green: "green",
+		teal: "cyan",
+		blue: "blue",
+		purple: "magenta",
+		pink: "magenta",
+		brandRed: "red",
+		brandOrange: "red",
+		brandYellow: "yellow",
+		brandGreen: "green",
+		brandTeal: "cyan",
+		brandBlue: "blue",
+		brandPurple: "magenta",
+		brandPink: "magenta"
+	};
+	defaultDarkScheme = {
+		name: "default-dark",
+		dark: true,
+		black: "#2e3440",
+		red: "#bf616a",
+		green: "#a3be8c",
+		yellow: "#ebcb8b",
+		blue: "#81a1c1",
+		magenta: "#b48ead",
+		cyan: "#88c0d0",
+		white: "#d8dee9",
+		brightBlack: "#4c566a",
+		brightRed: "#bf616a",
+		brightGreen: "#a3be8c",
+		brightYellow: "#ebcb8b",
+		brightBlue: "#81a1c1",
+		brightMagenta: "#b48ead",
+		brightCyan: "#8fbcbb",
+		brightWhite: "#eceff4",
+		foreground: "#d8dee9",
+		background: "#2e3440",
+		cursorColor: "#d8dee9",
+		cursorText: "#2e3440",
+		selectionBackground: "#434c5e",
+		selectionForeground: "#d8dee9"
+	};
+	defaultLightScheme = {
+		name: "default-light",
+		dark: false,
+		black: "#5c6370",
+		red: "#d20f39",
+		green: "#40a02b",
+		yellow: "#df8e1d",
+		blue: "#1e66f5",
+		magenta: "#8839ef",
+		cyan: "#179299",
+		white: "#dce0e8",
+		brightBlack: "#6c7086",
+		brightRed: "#d20f39",
+		brightGreen: "#40a02b",
+		brightYellow: "#df8e1d",
+		brightBlue: "#1e66f5",
+		brightMagenta: "#8839ef",
+		brightCyan: "#179299",
+		brightWhite: "#eff1f5",
+		foreground: "#4c4f69",
+		background: "#eff1f5",
+		cursorColor: "#dc8a78",
+		cursorText: "#eff1f5",
+		selectionBackground: "#ccd0da",
+		selectionForeground: "#4c4f69"
 	};
-}));
-//#endregion
-//#region packages/ansi/src/theme/types.ts
-var COLOR_PALETTE_FIELDS;
-var init_types = __esmMin((() => {
-	COLOR_PALETTE_FIELDS = [
-		"black",
-		"red",
-		"green",
-		"yellow",
-		"blue",
-		"magenta",
-		"cyan",
-		"white",
-		"brightBlack",
-		"brightRed",
-		"brightGreen",
-		"brightYellow",
-		"brightBlue",
-		"brightMagenta",
-		"brightCyan",
-		"brightWhite",
-		"foreground",
-		"background",
-		"cursorColor",
-		"cursorText",
-		"selectionBackground",
-		"selectionForeground"
-	];
 }));
 //#endregion
 //#region packages/ansi/src/osc-palette.ts
@@ -1495,7 +2390,7 @@ var init_osc_colors = __esmMin((() => {
 }));
 //#endregion
 //#region packages/ansi/src/theme/detect.ts
-async function detectTerminalPalette(timeoutMs = 150) {
+async function detectTerminalScheme(timeoutMs = 150) {
 	const stdin = process.stdin;
 	const stdout = process.stdout;
 	if (!stdin.isTTY || !stdout.isTTY) return null;
@@ -1601,6 +2496,139 @@ function isDarkColor(hex) {
 var init_detect = __esmMin((() => {
 	init_osc_palette();
 	init_osc_colors();
+}));
+//#endregion
+//#region packages/ansi/src/theme/orchestrator.ts
+function envOverride() {
+	const v = process.env.SILVERY_COLOR;
+	if (!v) return null;
+	if (v === "truecolor" || v === "256" || v === "ansi16" || v === "scheme" || v === "mono" || v === "auto") return v;
+	return null;
+}
+/**
+* Detect the terminal's color scheme + derive a theme in one call.
+*
+* Runs the 4-layer detection cascade (override → probe → fingerprint →
+* fallback) and returns a fully-resolved Theme along with provenance metadata
+* so callers can log how the scheme was determined.
+*
+* This is the recommended entry point for apps — it handles all the gotchas
+* (non-TTY environments, failed probes, partial OSC responses, catalog matches,
+* bg-mode inference) and returns something you can hand to `ThemeProvider`.
+*
+* @example
+* ```ts
+* import { detectScheme } from "@silvery/ansi"
+* import { builtinPalettes } from "@silvery/theme/schemes"
+*
+* const { scheme, theme, source, matchedName, confidence } = await detectScheme({
+*   catalog: Object.values(builtinPalettes),
+*   enforce: "lenient",
+* })
+* console.log(`${source === "fingerprint" ? `detected ${matchedName}` : source} (${(confidence * 100).toFixed(0)}%)`)
+* ```
+*/
+async function detectScheme(opts = {}) {
+	const enforce = opts.enforce ?? "lenient";
+	const wcag = opts.wcag ?? false;
+	if (opts.override) {
+		const theme = loadTheme(opts.override, {
+			enforce,
+			wcag
+		});
+		return {
+			scheme: opts.override,
+			theme,
+			source: "override",
+			confidence: 1,
+			slotSources: allSlotsFrom("fallback"),
+			matchedName: opts.override.name
+		};
+	}
+	const envMode = envOverride();
+	if (envMode === "mono" || envMode === "ansi16") {
+		const fallback = opts.darkFallback !== false ? defaultDarkScheme : defaultLightScheme;
+		return {
+			scheme: fallback,
+			theme: loadTheme(fallback, {
+				enforce,
+				wcag
+			}),
+			source: "override",
+			confidence: 1,
+			slotSources: allSlotsFrom("fallback"),
+			matchedName: fallback.name
+		};
+	}
+	const detected = await detectTerminalScheme(opts.timeoutMs);
+	if (!detected) {
+		const fallback = opts.darkFallback !== false ? defaultDarkScheme : defaultLightScheme;
+		return {
+			scheme: fallback,
+			theme: loadTheme(fallback, {
+				enforce,
+				wcag
+			}),
+			source: "fallback",
+			confidence: 0,
+			slotSources: allSlotsFrom("fallback"),
+			matchedName: fallback.name
+		};
+	}
+	const catalog = opts.catalog ?? [];
+	if (catalog.length > 0) {
+		const match = fingerprintMatch(detected.palette, catalog);
+		if (match) {
+			const theme = loadTheme(match.scheme, {
+				enforce,
+				wcag
+			});
+			return {
+				scheme: match.scheme,
+				theme,
+				source: "fingerprint",
+				confidence: match.confidence,
+				slotSources: allSlotsFrom("catalog"),
+				matchedName: match.scheme.name
+			};
+		}
+	}
+	const merged = {
+		...detected.dark ? defaultDarkScheme : defaultLightScheme,
+		...stripNulls(detected.palette)
+	};
+	const theme = loadTheme(merged, {
+		enforce,
+		wcag
+	});
+	const slotSources = {};
+	for (const field of COLOR_SCHEME_FIELDS) slotSources[field] = typeof detected.palette[field] === "string" ? "probed" : "fallback";
+	const probedCount = Object.values(slotSources).filter((s) => s === "probed").length;
+	return {
+		scheme: merged,
+		theme,
+		source: "probed",
+		confidence: Math.min(1, probedCount / 18),
+		slotSources,
+		matchedName: void 0
+	};
+}
+function stripNulls(partial) {
+	const result = {};
+	for (const [k, v] of Object.entries(partial)) if (v != null) result[k] = v;
+	return result;
+}
+function allSlotsFrom(src) {
+	const out = {};
+	for (const field of COLOR_SCHEME_FIELDS) out[field] = src;
+	return out;
+}
+var init_orchestrator = __esmMin((() => {
+	init_types();
+	init_derive();
+	init_detect();
+	init_fingerprint();
+	init_default_schemes();
 })), CSI;
 var init_color_scheme = __esmMin((() => {
 	CSI = `[`;
@@ -1617,13 +2645,15 @@ var init_src = __esmMin((() => {
 	init_style();
 	init_mixed_proxy();
 	init_derive();
-	init_default_palettes();
+	init_monochrome();
+	init_orchestrator();
+	init_default_schemes();
 	init_types();
 	init_detect();
 	init_osc_palette();
 	init_color_scheme();
 }));
 //#endregion
-export { contrastFg as A, enableKittyKeyboard as B, resolveThemeColor as C, blend as D, ensureContrast as E, hslToHex as F, detectColor as G, bgColorCode as H, rgbToHex as I, detectTerminalCaps as J, detectCursor as K, rgbToHsl as L, desaturate as M, hexToHsl as N, brighten as O, hexToRgb as P, disableKittyKeyboard as R, createStyle as S, checkContrast as T, fgColorCode as U, enableMouse as V, defaultCaps as W, detectUnicode as Y, COLOR_PALETTE_FIELDS as _, queryCursorColor as a, deriveTheme as b, resetCursorColor as c, setCursorColor as d, setForegroundColor as f, setPaletteColor as g, queryPaletteColor as h, queryBackgroundColor as i, darken as j, complement as k, resetForegroundColor as l, queryMultiplePaletteColors as m, detectTerminalPalette as n, queryForegroundColor as o, parsePaletteResponse as p, detectInput as q, detectColorScheme as r, resetBackgroundColor as s, init_src as t, setBackgroundColor as u, ansi16DarkTheme as v, init_src$1 as w, createMixedStyle as x, ansi16LightTheme as y, disableMouse as z };
+export { detectTerminalCaps as $, brighten as A, rgbToHsl as B, createMixedStyle as C, checkContrast as D, init_src$1 as E, hexToHsl as F, enableKittyKeyboard as G, oklchToHex as H, hexToRgb as I, fgColorCode as J, enableMouse as K, hslToHex as L, contrastFg as M, darken as N, ensureContrast as O, desaturate as P, detectInput as Q, relativeLuminance as R, deriveTheme as S, resolveThemeColor as T, disableKittyKeyboard as U, hexToOklch as V, disableMouse as W, detectColor as X, defaultCaps as Y, detectCursor as Z, setPaletteColor as _, queryBackgroundColor as a, COLOR_SCHEME_FIELDS as b, resetBackgroundColor as c, setBackgroundColor as d, detectUnicode as et, setCursorColor as f, queryPaletteColor as g, queryMultiplePaletteColors as h, detectColorScheme as i, complement as j, blend as k, resetCursorColor as l, parsePaletteResponse as m, detectScheme as n, queryCursorColor as o, setForegroundColor as p, bgColorCode as q, detectTerminalScheme as r, queryForegroundColor as s, init_src as t, resetForegroundColor as u, ansi16DarkTheme as v, createStyle as w, monoAttrsForColorString as x, ansi16LightTheme as y, rgbToHex as z };
 
-//# sourceMappingURL=src-9B5k0JmY.mjs.map
+//# sourceMappingURL=src-D_BS-as7.mjs.map