silvery 0.19.2 → 0.21.1

package/dist/{src-B5GjfG7g.mjs → schemes-DYt2ushj.mjs}

@@ -1,820 +1,5 @@
-import { B as bakeFlat, C as COLOR_SCHEME_FIELDS, E as deriveFields, H as ANSI16_SLOT_HEX, S as ansi16LightTheme$1, T as deriveTheme$1, o as detectTheme$1, t as init_src, x as ansi16DarkTheme$1 } from "./src-NCKb8kE5.mjs";
-import { blend, brighten, checkContrast, darken, ensureContrast, hexToOklch, hexToRgb, oklchToHex, relativeLuminance } from "@silvery/color";
-//#region packages/theme/src/generate.ts
-init_src();
-/**
-* Resolve an ANSI16 slot name (e.g. "yellow", "blueBright") to its canonical
-* hex value. Falls back to the input string if not found (e.g., already hex).
-*/
-function slotHex(name) {
-	return ANSI16_SLOT_HEX[name] ?? name;
-}
-/**
-* Generate a complete ANSI 16 theme from a primary color + dark/light preference.
-*
-* All token values are hex strings (e.g. "#808000" for yellow).
-* Terminal rendering quantizes these to 4-bit ANSI codes at paint time
-* when colorLevel === "basic".
-*/
-function generateTheme(primary, dark) {
-	const primaryHex = slotHex(primary);
-	const fgHex = slotHex(dark ? "whiteBright" : "black");
-	const accentHex = primaryHex;
-	const selectionbgHex = primaryHex;
-	const surfacebgHex = slotHex(dark ? "black" : "white");
-	const derived = deriveFields({
-		primary: primaryHex,
-		accent: accentHex,
-		fg: fgHex,
-		selectionbg: selectionbgHex,
-		surfacebg: surfacebgHex,
-		ring: {
-			red: slotHex(dark ? "redBright" : "red"),
-			orange: slotHex(dark ? "redBright" : "red"),
-			yellow: slotHex("yellow"),
-			green: slotHex(dark ? "greenBright" : "green"),
-			teal: slotHex("cyan"),
-			blue: slotHex(dark ? "blueBright" : "blue"),
-			purple: slotHex("magenta"),
-			pink: slotHex(dark ? "magentaBright" : "magenta")
-		}
-	});
-	return {
-		name: `${dark ? "dark" : "light"}-${primary}`,
-		bg: "",
-		fg: fgHex,
-		muted: slotHex(dark ? "white" : "blackBright"),
-		mutedbg: slotHex(dark ? "black" : "white"),
-		surface: slotHex(dark ? "whiteBright" : "black"),
-		surfacebg: surfacebgHex,
-		popover: slotHex(dark ? "whiteBright" : "black"),
-		popoverbg: slotHex(dark ? "blackBright" : "white"),
-		inverse: slotHex(dark ? "black" : "whiteBright"),
-		inversebg: slotHex(dark ? "whiteBright" : "black"),
-		cursor: slotHex("black"),
-		cursorbg: primaryHex,
-		selection: slotHex("black"),
-		selectionbg: primaryHex,
-		primary: primaryHex,
-		primaryfg: slotHex("black"),
-		secondary: primaryHex,
-		secondaryfg: slotHex("black"),
-		accent: primaryHex,
-		accentfg: slotHex("black"),
-		error: slotHex(dark ? "redBright" : "red"),
-		errorfg: slotHex("black"),
-		warning: primaryHex,
-		warningfg: slotHex("black"),
-		success: slotHex(dark ? "greenBright" : "green"),
-		successfg: slotHex("black"),
-		info: slotHex(dark ? "cyanBright" : "cyan"),
-		infofg: slotHex("black"),
-		border: slotHex("gray"),
-		inputborder: slotHex("gray"),
-		focusborder: slotHex(dark ? "blueBright" : "blue"),
-		link: slotHex("blueBright"),
-		disabledfg: slotHex("gray"),
-		palette: [
-			slotHex("black"),
-			slotHex("red"),
-			slotHex("green"),
-			slotHex("yellow"),
-			slotHex("blue"),
-			slotHex("magenta"),
-			slotHex("cyan"),
-			slotHex("white"),
-			slotHex("blackBright"),
-			slotHex("redBright"),
-			slotHex("greenBright"),
-			slotHex("yellowBright"),
-			slotHex("blueBright"),
-			slotHex("magentaBright"),
-			slotHex("cyanBright"),
-			slotHex("whiteBright")
-		],
-		...derived
-	};
-}
-//#endregion
-//#region packages/theme/src/import/types.ts
-/** All Base16 color keys in order. */
-const BASE16_KEYS = [
-	"base00",
-	"base01",
-	"base02",
-	"base03",
-	"base04",
-	"base05",
-	"base06",
-	"base07",
-	"base08",
-	"base09",
-	"base0A",
-	"base0B",
-	"base0C",
-	"base0D",
-	"base0E",
-	"base0F"
-];
-//#endregion
-//#region packages/theme/src/import/base16.ts
-/**
-* Import Base16 YAML/JSON schemes into ColorScheme format.
-*
-* Base16 defines 16 colors (base00–base0F). We map them to ColorScheme's
-* 22 colors, deriving bright variants and special colors.
-*
-* @see https://github.com/chriskempson/base16
-*/
-/**
-* Parse Base16 YAML into a Base16Scheme object.
-* Handles both quoted and unquoted values, comments, and blank lines.
-*/
-function parseBase16Yaml(yaml) {
-	const result = {};
-	for (const raw of yaml.split("\n")) {
-		const line = raw.trim();
-		if (!line || line.startsWith("#")) continue;
-		const colonIdx = line.indexOf(":");
-		if (colonIdx === -1) continue;
-		const key = line.slice(0, colonIdx).trim();
-		let value = line.slice(colonIdx + 1).trim();
-		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
-		const commentIdx = value.indexOf("#");
-		if (commentIdx > 0) value = value.slice(0, commentIdx).trim();
-		result[key] = value;
-	}
-	if (!result.scheme) throw new Error("Base16 YAML missing required field: scheme");
-	for (const key of BASE16_KEYS) {
-		if (!result[key]) throw new Error(`Base16 YAML missing required color: ${key}`);
-		if (!/^[0-9a-fA-F]{6}$/.test(result[key])) throw new Error(`Base16 color ${key} must be a 6-digit hex string without '#', got: "${result[key]}"`);
-	}
-	return result;
-}
-/** Compute relative luminance (WCAG 2.0) from a hex color with `#` prefix. */
-function luminance(hex) {
-	const rgb = hexToRgb(hex);
-	if (!rgb) return 0;
-	const [r, g, b] = rgb.map((c) => {
-		const s = c / 255;
-		return s <= .03928 ? s / 12.92 : Math.pow((s + .055) / 1.055, 2.4);
-	});
-	return .2126 * r + .7152 * g + .0722 * b;
-}
-/** Normalize a bare hex string to `#RRGGBB` (uppercase). */
-function hex(bare) {
-	return `#${bare.toUpperCase()}`;
-}
-/**
-* Import a Base16 YAML (or JSON) scheme into a ColorScheme.
-*
-* Mapping:
-*   base00 → background, base01 → brightBlack, base02 → selectionBackground,
-*   base03 → white (muted fg), base05 → foreground/brightWhite,
-*   base08 → red, base09 → brightRed, base0A → yellow,
-*   base0B → green, base0C → cyan, base0D → blue, base0E → magenta,
-*   base0F → brightMagenta.
-*
-* Bright color variants are derived by brightening normals.
-* `dark` is inferred from base00 luminance.
-*/
-function importBase16(yamlOrJson) {
-	return base16ToColorScheme(parseBase16Yaml(yamlOrJson));
-}
-/** Convert a parsed Base16Scheme to ColorScheme. */
-function base16ToColorScheme(scheme) {
-	const bg = hex(scheme.base00);
-	const fg = hex(scheme.base05);
-	const isDark = luminance(bg) < .179;
-	const black = isDark ? darken(bg, .15) : brighten(bg, .15);
-	const red = hex(scheme.base08);
-	const green = hex(scheme.base0B);
-	const yellow = hex(scheme.base0A);
-	const blue = hex(scheme.base0D);
-	const magenta = hex(scheme.base0E);
-	const cyan = hex(scheme.base0C);
-	return {
-		name: scheme.scheme,
-		dark: isDark,
-		black,
-		red,
-		green,
-		yellow,
-		blue,
-		magenta,
-		cyan,
-		white: hex(scheme.base03),
-		brightBlack: hex(scheme.base01),
-		brightRed: hex(scheme.base09),
-		brightGreen: brighten(green, .15),
-		brightYellow: brighten(yellow, .15),
-		brightBlue: brighten(blue, .15),
-		brightMagenta: hex(scheme.base0F),
-		brightCyan: brighten(cyan, .15),
-		brightWhite: fg,
-		foreground: fg,
-		background: bg,
-		cursorColor: fg,
-		cursorText: bg,
-		selectionBackground: hex(scheme.base02),
-		selectionForeground: fg
-	};
-}
-//#endregion
-//#region packages/theme/src/sterling/contrast.ts
-/**
-* Sterling contrast guardrails — D3 from sterling-preflight.md.
-*
-* Two modes:
-*   - `strict` — throw when a core role pair fails WCAG AA 4.5:1.
-*     Used by the catalog test (all 84 shipped schemes must pass).
-*   - `auto-lift` — adjust OKLCH lightness until AA passes (±0.04L increments
-*     up to ~0.20L). Logs at debug; silent by default. Used for user schemes
-*     at runtime.
-*
-* Pinned tokens (per-role overrides supplied by scheme authors) are excluded
-* from auto-lift and from strict-mode enforcement — the author accepts the
-* contrast consequence of pinning.
-*/
-/** WCAG AA threshold for normal text. */
-const WCAG_AA = 4.5;
-var ContrastError = class extends Error {
-	violations;
-	constructor(violations) {
-		const summary = violations.slice(0, 5).map((v) => `${v.token}: ${v.ratio.toFixed(2)} < ${v.target} (fg=${v.fg}, bg=${v.bg})`).join("; ");
-		const extra = violations.length > 5 ? ` (+${violations.length - 5} more)` : "";
-		super(`Sterling contrast: ${violations.length} violation(s): ${summary}${extra}`);
-		this.name = "ContrastError";
-		this.violations = violations;
-	}
-};
-/**
-* Verify `fg` on `bg` meets `target` ratio. Returns `null` when already
-* passing; otherwise returns a ContrastViolation.
-*/
-function checkAA(token, fg, bg, target = WCAG_AA) {
-	const r = checkContrast(fg, bg);
-	if (!r) return null;
-	if (r.ratio >= target) return null;
-	return {
-		token,
-		fg,
-		bg,
-		ratio: r.ratio,
-		target
-	};
-}
-/**
-* Auto-lift `fg` against `bg` until the `target` contrast ratio is met,
-* via OKLCH L shifts (hue + chroma preserved). Light bg → darken;
-* dark bg → lighten.
-*
-* Implementation note: binary-searches the minimum L shift achieving the
-* target. Falls back to a best-effort value if the target is unreachable
-* (e.g., yellow against white can never hit 4.5:1 at any lightness while
-* preserving yellow hue; the result is the darkest in-gamut yellow).
-*/
-function autoLift(fg, bg, target = WCAG_AA) {
-	const current = checkContrast(fg, bg);
-	if (!current) return {
-		value: fg,
-		lifted: false
-	};
-	if (current.ratio >= target) return {
-		value: fg,
-		lifted: false
-	};
-	const adjusted = ensureContrast(fg, bg, target);
-	return {
-		value: adjusted,
-		lifted: adjusted !== fg
-	};
-}
-//#endregion
-//#region packages/theme/src/sterling/derive.ts
-/**
-* Sterling derivation — preservative OKLCH rules over a 22-color ColorScheme.
-*
-* Implements design-system.md §"Derivation rules" with guardrails from D3.
-* Produces the nested `Roles` shape. `flatten.ts` projects the flat keys.
-*
-* Derivation is:
-*   1. `scheme.primary` (or fallback) → accent.fg / accent.bg / info.fg
-*   2. status roles from `scheme.red / yellow / green / primary`
-*   3. Adaptive OKLCH hover/active L-shift (direction = base-L, not scheme.dark):
-*        baseL > 0.6  → darken (hover −0.04L, active −0.08L)
-*        baseL ≤ 0.6  → brighten (hover +0.04L, active +0.08L)
-*      At L extremes (target L > 0.9 or < 0.1) chroma is proportionally
-*      reduced so the color pushes toward gray instead of collapsing to
-*      white/black — fixes the Frappe yellow/light-accent whiteout.
-*   4. `fgOn` picked for WCAG AA against role's `bg` (prefers scheme bg/fg)
-*   5. surface ramp via OKLCH blend
-*   6. contrast guardrail: strict throws, auto-lift adjusts
-*
-* Per-hue delta adaptation: yellows (H ∈ [80, 110]) get ±0.06L / ±0.10L,
-* low-chroma schemes (C < 0.05) get ±0.06L / ±0.10L. Everything else uses
-* the standard ±0.04L / ±0.08L.
-*
-* Pinned tokens (via `DeriveOptions.pins`) bypass both the rule and
-* auto-lift; they're written verbatim onto the Theme.
-*/
-/**
-* Default typography variants — token-based, works across any Sterling theme.
-* Consumed by `<Text variant="h1">` via the theme's `variants` record.
-*
-* Keys use Sterling flat-token names in their color slots (`$fg-accent`,
-* `$fg-muted`, `$bg-muted`) so the defaults resolve against every Sterling-
-* derived Theme without further wiring.
-*/
-const DEFAULT_VARIANTS = {
-	h1: {
-		color: "$fg-accent",
-		bold: true
-	},
-	h2: {
-		color: "$fg-accent",
-		bold: true
-	},
-	h3: { bold: true },
-	body: {},
-	"body-muted": { color: "$fg-muted" },
-	"fine-print": {
-		color: "$fg-muted",
-		dim: true
-	},
-	strong: { bold: true },
-	em: { italic: true },
-	link: {
-		color: "$fg-accent",
-		underlineStyle: "single"
-	},
-	key: {
-		color: "$fg-accent",
-		bold: true
-	},
-	code: { backgroundColor: "$bg-muted" },
-	kbd: {
-		backgroundColor: "$bg-muted",
-		color: "$fg-accent",
-		bold: true
-	}
-};
-/**
-* Build the 16-slot ANSI palette from a ColorScheme. Indexed `$color0` …
-* `$color15` by the framework's token resolver.
-*/
-function buildPalette(scheme) {
-	return [
-		scheme.black,
-		scheme.red,
-		scheme.green,
-		scheme.yellow,
-		scheme.blue,
-		scheme.magenta,
-		scheme.cyan,
-		scheme.white,
-		scheme.brightBlack,
-		scheme.brightRed,
-		scheme.brightGreen,
-		scheme.brightYellow,
-		scheme.brightBlue,
-		scheme.brightMagenta,
-		scheme.brightCyan,
-		scheme.brightWhite
-	];
-}
-/**
-* Derive the 8-hue categorical ring from a ColorScheme. Mirrors the legacy
-* derive.ts logic — blends scheme hues for the missing Sterling slots
-* (orange from red+yellow, teal from green+cyan, pink from magenta+red).
-*/
-function buildCategoricalHues(scheme) {
-	const dark = scheme.dark ?? true;
-	return {
-		red: scheme.red,
-		orange: blend(scheme.red, scheme.yellow, .5),
-		yellow: scheme.yellow,
-		green: scheme.green,
-		teal: blend(scheme.green, scheme.cyan, .5),
-		blue: dark ? scheme.brightBlue : scheme.blue,
-		purple: scheme.magenta,
-		pink: blend(scheme.magenta, scheme.red, .5)
-	};
-}
-function isYellowish(hex) {
-	const o = hexToOklch(hex);
-	if (!o) return false;
-	return o.H >= 80 && o.H <= 120;
-}
-function isLowChroma(hex) {
-	const o = hexToOklch(hex);
-	if (!o) return false;
-	return o.C < .05;
-}
-/** Compute state-shift deltas for a given base color. Wider for yellows + low-chroma. */
-function stateDeltas(base) {
-	if (isYellowish(base) || isLowChroma(base)) return {
-		hover: .06,
-		active: .1
-	};
-	return {
-		hover: .04,
-		active: .08
-	};
-}
-/**
-* Adaptive L-shift: direction follows the token's own luminance, NOT
-* scheme.dark. High-L tokens (yellows, light accents) darken; low-L tokens
-* brighten. Uniform handling — yields a reliable "more active than hover"
-* relationship no matter what hue/lightness the base is.
-*
-* Chroma preservation at L extremes: when the target L pushes past 0.9
-* (approaching white) or below 0.1 (approaching black), chroma is scaled
-* down proportionally so the color drifts toward gray rather than
-* collapsing to #FFFFFF or #000000. This preserves perceptual differences
-* between the base / hover / active states even on intrinsically-bright
-* tokens (catppuccin-frappe yellow, light blue accents, etc.).
-*
-* Returns the original hex unchanged when OKLCH parsing fails.
-*/
-function shiftL(hex, amount) {
-	const o = hexToOklch(hex);
-	if (!o) return hex;
-	const direction = o.L > .6 ? -1 : 1;
-	const targetL = clamp01(o.L + direction * amount);
-	let nextC = o.C;
-	if (targetL > .9 || targetL < .1) {
-		const factor = clamp01(1 - Math.abs(targetL - .5) * 2);
-		nextC = o.C * factor;
-	}
-	return oklchToHex({
-		L: targetL,
-		C: nextC,
-		H: o.H
-	});
-}
-function clamp01(x) {
-	return x < 0 ? 0 : x > 1 ? 1 : x;
-}
-/** Label the direction the adaptive L-shift took, for trace rule strings. */
-function shiftLabel(hex) {
-	const o = hexToOklch(hex);
-	if (!o) return "brighten";
-	return o.L > .6 ? "darken" : "brighten";
-}
-function inferMode(scheme, explicit) {
-	if (explicit) return explicit;
-	if (typeof scheme.dark === "boolean") return scheme.dark ? "dark" : "light";
-	const lum = relativeLuminance(scheme.background);
-	return lum !== null && lum < .5 ? "dark" : "light";
-}
-/**
-* Pick a foreground color to draw on a filled `bg` of a role. Prefers
-* `scheme.background` if it beats AA against the role bg (i.e. the role bg
-* is bright enough that using dark text reads); otherwise `scheme.foreground`;
-* otherwise falls back to white/black by bg luminance.
-*/
-function pickFgOn(roleBg, scheme) {
-	const candidates = [
-		scheme.foreground,
-		scheme.background,
-		"#FFFFFF",
-		"#000000"
-	];
-	let best = candidates[0];
-	let bestRatio = 0;
-	for (const c of candidates) {
-		const r = checkAA("fgOn", c, roleBg);
-		if (r === null) return c;
-		if (r.ratio > bestRatio) {
-			best = c;
-			bestRatio = r.ratio;
-		}
-	}
-	return best;
-}
-/**
-* Resolve a pin for a token path. Accepts both nested (`"accent.hover.bg"`)
-* and flat (`"bg-accent-hover"`) forms. Returns the pinned hex or undefined.
-*/
-function pin(pins, nested, flat) {
-	if (!pins) return void 0;
-	return pins[nested] ?? pins[flat];
-}
-/**
-* Shared guard: handles pin → rule → contrast check → auto-lift → record.
-* `target` defaults to WCAG_AA (4.5); callers use 3.0 for "muted" tokens
-* that are deemphasized by design.
-*/
-function guardTarget(nestedPath, flatPath, rule, inputs, value, against, target, contrast, pins, trace, violations) {
-	const pinned = pin(pins, nestedPath, flatPath);
-	if (pinned !== void 0) {
-		trace.push({
-			token: nestedPath,
-			rule: "pinned by scheme author",
-			inputs: [pinned],
-			output: pinned,
-			pinned: true
-		});
-		return pinned;
-	}
-	if (against === void 0) {
-		trace.push({
-			token: nestedPath,
-			rule,
-			inputs,
-			output: value
-		});
-		return value;
-	}
-	if (checkAA(nestedPath, value, against, target) === null) {
-		trace.push({
-			token: nestedPath,
-			rule,
-			inputs,
-			output: value
-		});
-		return value;
-	}
-	const lifted = autoLift(value, against, target);
-	const finalValue = lifted.value;
-	const residual = checkAA(nestedPath, finalValue, against, target);
-	if (residual !== null) violations.push(residual);
-	trace.push({
-		token: nestedPath,
-		rule: lifted.lifted ? `${rule} + auto-lift` : rule,
-		inputs,
-		output: finalValue,
-		...lifted.lifted ? { liftedFrom: value } : {}
-	});
-	return finalValue;
-}
-/**
-* Derive a Theme's nested roles from a ColorScheme. Guardrails applied.
-*/
-function deriveRoles(scheme, opts) {
-	const mode = inferMode(scheme, opts.mode);
-	const contrast = opts.contrast ?? "auto-lift";
-	const pins = opts.pins;
-	const trace = [];
-	const violations = [];
-	const primary = scheme.primary ?? (mode === "dark" ? scheme.brightBlue : scheme.blue);
-	const bg = scheme.background;
-	const fg = scheme.foreground;
-	function guard(nestedPath, flatPath, rule, inputs, value, against, target = WCAG_AA) {
-		return guardTarget(nestedPath, flatPath, rule, inputs, value, against, target, contrast, pins, trace, violations);
-	}
-	const accentBase = guard("accent.fg", "fg-accent", "scheme.primary", [primary], primary, bg);
-	const accentBg = guard("accent.bg", "bg-accent", "scheme.primary", [primary], primary);
-	const deltaA = stateDeltas(accentBg);
-	const bgDir = shiftLabel(accentBg);
-	const accentHoverBg = guard("accent.hover.bg", "bg-accent-hover", `OKLCH ${bgDir} ${deltaA.hover}L on accent.bg`, [accentBg], shiftL(accentBg, deltaA.hover));
-	const accentActiveBg = guard("accent.active.bg", "bg-accent-active", `OKLCH ${bgDir} ${deltaA.active}L on accent.bg`, [accentBg], shiftL(accentBg, deltaA.active));
-	const accentFgOn = guard("accent.fgOn", "fg-on-accent", "contrast-pick(scheme.fg/bg/BW)", [accentBg], pickFgOn(accentBg, scheme), accentBg);
-	const accentBorder = guard("accent.border", "border-accent", "= accent.bg", [accentBg], accentBg);
-	const fgDir = shiftLabel(accentBase);
-	const accentHoverFg = guard("accent.hover.fg", "fg-accent-hover", `OKLCH ${fgDir} ${deltaA.hover}L on accent.fg`, [accentBase], shiftL(accentBase, deltaA.hover), bg);
-	const accentActiveFg = guard("accent.active.fg", "fg-accent-active", `OKLCH ${fgDir} ${deltaA.active}L on accent.fg`, [accentBase], shiftL(accentBase, deltaA.active), bg);
-	return {
-		roles: {
-			accent: {
-				fg: accentBase,
-				bg: accentBg,
-				fgOn: accentFgOn,
-				border: accentBorder,
-				hover: {
-					fg: accentHoverFg,
-					bg: accentHoverBg
-				},
-				active: {
-					fg: accentActiveFg,
-					bg: accentActiveBg
-				}
-			},
-			info: buildInteractive("info", primary, scheme, opts, trace, violations),
-			success: buildInteractive("success", scheme.green, scheme, opts, trace, violations),
-			warning: buildInteractive("warning", scheme.yellow, scheme, opts, trace, violations),
-			error: buildInteractive("error", scheme.red, scheme, opts, trace, violations),
-			muted: {
-				fg: guard("muted.fg", "fg-muted", "blend(fg, bg, 0.4)", [fg, bg], blend(fg, bg, .4), bg, 3),
-				bg: guard("muted.bg", "bg-muted", "blend(bg, fg, 0.08)", [bg, fg], blend(bg, fg, .08))
-			},
-			surface: {
-				default: guard("surface.default", "bg-surface-default", "scheme.background", [bg], bg),
-				subtle: guard("surface.subtle", "bg-surface-subtle", "blend(bg, fg, 0.05)", [bg, fg], blend(bg, fg, .05)),
-				raised: guard("surface.raised", "bg-surface-raised", "blend(bg, fg, 0.08)", [bg, fg], blend(bg, fg, .08)),
-				overlay: guard("surface.overlay", "bg-surface-overlay", "blend(bg, fg, 0.12)", [bg, fg], blend(bg, fg, .12)),
-				hover: guard("surface.hover", "bg-surface-hover", "blend(bg, fg, 0.10)", [bg, fg], blend(bg, fg, .1))
-			},
-			border: {
-				default: guard("border.default", "border-default", "blend(bg, fg, 0.18)", [bg, fg], blend(bg, fg, .18)),
-				focus: guard("border.focus", "border-focus", "= accent.bg", [accentBg], accentBg, bg),
-				muted: guard("border.muted", "border-muted", "blend(bg, fg, 0.10)", [bg, fg], blend(bg, fg, .1))
-			},
-			cursor: {
-				fg: guard("cursor.fg", "fg-cursor", "scheme.cursorText", [scheme.cursorText], scheme.cursorText),
-				bg: guard("cursor.bg", "bg-cursor", "scheme.cursorColor", [scheme.cursorColor], scheme.cursorColor)
-			}
-		},
-		mode,
-		trace,
-		violations
-	};
-}
-function buildInteractive(name, seed, scheme, opts, trace, violations) {
-	const pins = opts.pins;
-	const contrast = opts.contrast ?? "auto-lift";
-	const bg = scheme.background;
-	const guard = (nestedPath, flatPath, rule, inputs, value, against, target = WCAG_AA) => guardTarget(nestedPath, flatPath, rule, inputs, value, against, target, contrast, pins, trace, violations);
-	const fg = guard(`${name}.fg`, `fg-${name}`, seedRule(name), [seed], seed, bg);
-	const roleBg = guard(`${name}.bg`, `bg-${name}`, seedRule(name), [seed], seed);
-	const delta = stateDeltas(roleBg);
-	const bgDir = shiftLabel(roleBg);
-	const fgOn = guard(`${name}.fgOn`, `fg-on-${name}`, "contrast-pick(scheme.fg/bg/BW)", [roleBg], pickFgOn(roleBg, scheme), roleBg);
-	const hoverBg = guard(`${name}.hover.bg`, `bg-${name}-hover`, `OKLCH ${bgDir} ${delta.hover}L`, [roleBg], shiftL(roleBg, delta.hover));
-	const activeBg = guard(`${name}.active.bg`, `bg-${name}-active`, `OKLCH ${bgDir} ${delta.active}L`, [roleBg], shiftL(roleBg, delta.active));
-	return {
-		fg,
-		bg: roleBg,
-		fgOn,
-		hover: { bg: hoverBg },
-		active: { bg: activeBg }
-	};
-}
-function seedRule(name) {
-	switch (name) {
-		case "info": return "scheme.primary (info mirrors accent's seed, derived independently)";
-		case "success": return "scheme.green";
-		case "warning": return "scheme.yellow";
-		case "error": return "scheme.red";
-		case "accent": return "scheme.primary";
-		default: return `scheme.${name}`;
-	}
-}
-/**
-* Derive a full Theme (pre-flatten) from a ColorScheme. Throws `ContrastError`
-* in strict mode if any role pair fails WCAG AA. Callers typically wrap this
-* with `flatten()` (from `flatten.ts`) to get the user-facing Theme.
-*
-* Returned Theme is NOT frozen and DOES NOT contain flat keys yet.
-*/
-function deriveTheme(scheme, opts = {}) {
-	const { roles, mode, trace, violations } = deriveRoles(scheme, opts);
-	if ((opts.contrast ?? "auto-lift") === "strict" && violations.length > 0) throw new ContrastError(violations);
-	return {
-		...roles,
-		...buildCategoricalHues(scheme),
-		name: scheme.name,
-		mode,
-		variants: DEFAULT_VARIANTS,
-		palette: buildPalette(scheme),
-		...opts.trace ? { derivationTrace: trace } : {}
-	};
-}
-/**
-* Merge a DeepPartial<Theme> onto an existing Theme (for `sterling.theme()`).
-* Nested role objects are spread deeply; flat keys are replaced if present.
-*/
-function mergePartial(base, patch) {
-	if (!patch) return base;
-	const out = { ...base };
-	for (const [k, v] of Object.entries(patch)) {
-		if (v === void 0) continue;
-		const cur = base[k];
-		if (cur && typeof cur === "object" && typeof v === "object" && !Array.isArray(v)) {
-			out[k] = {
-				...cur,
-				...v
-			};
-			for (const [k2, v2] of Object.entries(v)) if (v2 && typeof v2 === "object" && !Array.isArray(v2) && cur[k2] && typeof cur[k2] === "object") out[k][k2] = {
-				...cur[k2],
-				...v2
-			};
-		} else out[k] = v;
-	}
-	return out;
-}
-//#endregion
-//#region packages/theme/src/sterling/inline.ts
-/**
-* Build a ColorScheme-shaped input from a legacy Theme when the original
-* scheme isn't available (hand-crafted themes, picker round-trips).
-*/
-function schemeFromLegacy(theme) {
-	const palette = theme.palette ?? [];
-	return {
-		name: theme.name,
-		dark: isDark(theme.bg),
-		primary: theme.primary,
-		black: palette[0] ?? "#000000",
-		red: palette[1] ?? theme.error,
-		green: palette[2] ?? theme.success,
-		yellow: palette[3] ?? theme.warning,
-		blue: palette[4] ?? theme.primary,
-		magenta: palette[5] ?? theme.accent,
-		cyan: palette[6] ?? theme.info,
-		white: palette[7] ?? theme.fg,
-		brightBlack: palette[8] ?? theme.muted,
-		brightRed: palette[9] ?? theme.error,
-		brightGreen: palette[10] ?? theme.success,
-		brightYellow: palette[11] ?? theme.warning,
-		brightBlue: palette[12] ?? theme.primary,
-		brightMagenta: palette[13] ?? theme.accent,
-		brightCyan: palette[14] ?? theme.info,
-		brightWhite: palette[15] ?? theme.fg,
-		foreground: theme.fg,
-		background: theme.bg,
-		cursorColor: theme.cursorbg,
-		cursorText: theme.cursor,
-		selectionBackground: theme.selectionbg,
-		selectionForeground: theme.selection
-	};
-}
-/**
-* Quick luminance check — matches relativeLuminance threshold (0.5). Avoids
-* pulling in @silvery/color for a single boolean.
-*/
-function isDark(hex) {
-	const m = /^#?([0-9a-f]{6})$/i.exec(hex);
-	if (!m?.[1]) return true;
-	const n = parseInt(m[1], 16);
-	const r = n >> 16 & 255;
-	const g = n >> 8 & 255;
-	const b = n & 255;
-	return (.2126 * r + .7152 * g + .0722 * b) / 255 < .5;
-}
-/**
-* Write Sterling flat tokens onto a legacy Theme in-place and return the
-* augmented object. Mirrors the old `augmentWithSterlingFlat` semantics:
-* only sets a key if it's not already a string on the theme.
-*
-* When `scheme` is provided, Sterling derives directly from it (full fidelity).
-* Otherwise a scheme is reconstructed from the theme's palette (lossy on ANSI
-* slots but fine for Sterling's derivation surface).
-*/
-function inlineSterlingTokens(theme, scheme) {
-	const { roles } = deriveRoles(scheme ?? schemeFromLegacy(theme), { contrast: "auto-lift" });
-	const out = { ...theme };
-	const setIfAbsent = (key, value) => {
-		if (!(key in out) || typeof out[key] !== "string") out[key] = value;
-	};
-	const accent = roles.accent;
-	if (accent) {
-		setIfAbsent("fg-accent", accent.fg);
-		setIfAbsent("bg-accent", accent.bg);
-		setIfAbsent("fg-on-accent", accent.fgOn);
-		for (const state of ["hover", "active"]) {
-			const s = accent[state];
-			if (!s) continue;
-			setIfAbsent(`fg-accent-${state}`, s.fg);
-			setIfAbsent(`bg-accent-${state}`, s.bg);
-		}
-	}
-	for (const role of [
-		"info",
-		"success",
-		"warning",
-		"error"
-	]) {
-		const r = roles[role];
-		if (!r) continue;
-		setIfAbsent(`fg-${role}`, r.fg);
-		setIfAbsent(`bg-${role}`, r.bg);
-		setIfAbsent(`fg-on-${role}`, r.fgOn);
-		for (const state of ["hover", "active"]) {
-			const s = r[state];
-			if (!s) continue;
-			setIfAbsent(`bg-${role}-${state}`, s.bg);
-		}
-	}
-	if (roles.accent && "border" in roles.accent) setIfAbsent("border-accent", roles.accent.border);
-	const surf = roles.surface;
-	if (surf) {
-		setIfAbsent("bg-surface-default", surf.default);
-		setIfAbsent("bg-surface-subtle", surf.subtle);
-		setIfAbsent("bg-surface-raised", surf.raised);
-		setIfAbsent("bg-surface-overlay", surf.overlay);
-		setIfAbsent("bg-surface-hover", surf.hover);
-	}
-	const b = roles.border;
-	if (b) {
-		setIfAbsent("border-default", b.default);
-		setIfAbsent("border-focus", b.focus);
-		setIfAbsent("border-muted", b.muted);
-	}
-	const c = roles.cursor;
-	if (c) {
-		setIfAbsent("fg-cursor", c.fg);
-		setIfAbsent("bg-cursor", c.bg);
-	}
-	const m = roles.muted;
-	if (m) {
-		setIfAbsent("fg-muted", m.fg);
-		setIfAbsent("bg-muted", m.bg);
-	}
-	return out;
-}
-//#endregion
+import { it as deriveTheme, nt as ansi16DarkTheme$1, rt as ansi16LightTheme$1 } from "./src-Oe6x5PrS.mjs";
+import { brighten } from "@silvery/color";
 //#region packages/theme/src/schemes/catppuccin.ts
 /** Catppuccin Mocha — the classic dark variant. */
 const catppuccinMocha = {
@@ -3186,29 +2371,34 @@ const gnomeTerminalTango = {
 };
 //#endregion
 //#region packages/theme/src/schemes/index.ts
-init_src();
+/**
+* Built-in themes and palette registry.
+*
+* Exports:
+* - Pre-derived Theme objects (ansi16Dark, ansi16Light, defaultDark, defaultLight)
+* - ColorScheme definitions from popular theme systems (70+ palettes)
+* - Registry functions (getThemeByName, getSchemeByName)
+*/
 /**
 * Dark ANSI 16 theme — hex-valued, derived from the default dark scheme.
 * All token values are hex strings (no ANSI slot names).
-* Terminal rendering quantizes hex to 4-bit ANSI codes when colorLevel === "basic".
+* Terminal rendering quantizes hex to 4-bit ANSI codes when colorLevel === "ansi16".
 *
 * Sterling flat tokens (`bg-surface-subtle`, `fg-on-accent`, `border-focus`, …)
-* are baked in at construction — consumers can read either legacy fields or
-* Sterling flat keys off the same Theme object.
+* are baked in by `@silvery/ansi`'s `deriveAnsi16Theme` — consumers read either
+* legacy fields or Sterling flat keys off the same object.
 */
-const ansi16DarkTheme = inlineSterlingTokens(ansi16DarkTheme$1);
+const ansi16DarkTheme = ansi16DarkTheme$1;
 /**
 * Light ANSI 16 theme — hex-valued, derived from the default light scheme.
 * All token values are hex strings (no ANSI slot names).
-* Terminal rendering quantizes hex to 4-bit ANSI codes when colorLevel === "basic".
-*
-* Sterling flat tokens baked in at construction.
+* Terminal rendering quantizes hex to 4-bit ANSI codes when colorLevel === "ansi16".
 */
-const ansi16LightTheme = inlineSterlingTokens(ansi16LightTheme$1);
-/** Dark truecolor theme — derived from Nord. Sterling flat tokens baked in. */
-const defaultDarkTheme = inlineSterlingTokens(deriveTheme$1(nord), nord);
-/** Light truecolor theme — derived from Catppuccin Latte. Sterling flat tokens baked in. */
-const defaultLightTheme = inlineSterlingTokens(deriveTheme$1(catppuccinLatte), catppuccinLatte);
+const ansi16LightTheme = ansi16LightTheme$1;
+/** Dark truecolor theme — derived from Nord. Sterling flat tokens baked in by `deriveTheme`. */
+const defaultDarkTheme = deriveTheme(nord);
+/** Light truecolor theme — derived from Catppuccin Latte. Sterling flat tokens baked in by `deriveTheme`. */
+const defaultLightTheme = deriveTheme(catppuccinLatte);
 /** All built-in ColorScheme definitions (70+ palettes). */
 const builtinPalettes = {
 	"catppuccin-mocha": catppuccinMocha,
@@ -3313,7 +2503,7 @@ function getThemeByName(name) {
 	const builtin = builtinThemes[name];
 	if (builtin) return builtin;
 	const palette = builtinPalettes[name];
-	if (palette) return inlineSterlingTokens(deriveTheme$1(palette), palette);
+	if (palette) return deriveTheme(palette);
 	return ansi16DarkTheme;
 }
 /** Resolve a palette by name. Returns undefined if not found. */
@@ -3321,985 +2511,6 @@ function getSchemeByName(name) {
 	return builtinPalettes[name];
 }
 //#endregion
-//#region packages/theme/src/generators.ts
-/**
-* Palette generators — produce a ColorScheme from various inputs.
-*
-* All generators return a complete ColorScheme (22 fields).
-*/
-function isDarkColor$1(hex) {
-	const L = relativeLuminance(hex);
-	return L === null ? true : L < .5;
-}
-/**
-* Target hues for each accent slot, in OKLCH degrees.
-* OKLCH hues differ from HSL — red ≈ 29, green ≈ 142, blue ≈ 264. Calibrated
-* per Ottosson's reference ramps for perceptually-uniform accent generation.
-*/
-const targetHues = {
-	red: 29,
-	orange: 55,
-	yellow: 90,
-	green: 142,
-	teal: 195,
-	blue: 240,
-	purple: 305,
-	pink: 350
-};
-/** Find which hue slot the primary color best matches by OKLCH hue angle proximity. */
-function assignPrimaryToSlot(primary) {
-	const o = hexToOklch(primary);
-	if (!o) return "blue";
-	const h = o.H;
-	for (const [lo, hi, name] of [
-		[
-			0,
-			15,
-			"red"
-		],
-		[
-			15,
-			42,
-			"orange"
-		],
-		[
-			42,
-			75,
-			"yellow"
-		],
-		[
-			75,
-			170,
-			"green"
-		],
-		[
-			170,
-			210,
-			"teal"
-		],
-		[
-			210,
-			275,
-			"blue"
-		],
-		[
-			275,
-			330,
-			"purple"
-		],
-		[
-			330,
-			360,
-			"pink"
-		]
-	]) if (h >= lo && h < hi) return name;
-	return "red";
-}
-/** Generate 8 accent hues from a primary, placing it in its natural slot. */
-function generateAccentsFromPrimary(primary) {
-	const o = hexToOklch(primary);
-	if (!o) return {
-		red: "#BF616A",
-		orange: "#D08770",
-		yellow: "#EBCB8B",
-		green: "#A3BE8C",
-		teal: "#88C0D0",
-		blue: "#5E81AC",
-		purple: "#B48EAD",
-		pink: "#D4879C"
-	};
-	const slot = assignPrimaryToSlot(primary);
-	const result = {};
-	for (const [name, targetH] of Object.entries(targetHues)) result[name] = name === slot ? primary : oklchToHex({
-		L: o.L,
-		C: o.C,
-		H: targetH
-	});
-	return result;
-}
-/**
-* Generate a ColorScheme from a Base16 YAML scheme.
-*
-* Maps base00–base0F to ANSI palette colors, derives special colors.
-*/
-function fromBase16(yamlOrJson) {
-	return importBase16(yamlOrJson);
-}
-/**
-* Generate a full ColorScheme from 1-3 hex colors.
-*
-* At minimum, provide `background` or `primary`. Missing colors are
-* generated via surface ramp (from bg) and hue rotation (from primary).
-*/
-function fromColors(opts) {
-	const dark = opts.dark ?? (opts.background ? isDarkColor$1(opts.background) : true);
-	const step = dark ? brighten : darken;
-	const bg = opts.background ?? (dark ? "#2E3440" : "#FFFFFF");
-	const fg = opts.foreground ?? step(bg, .85);
-	const accents = opts.primary ? generateAccentsFromPrimary(opts.primary) : {
-		red: "#BF616A",
-		orange: "#D08770",
-		yellow: "#EBCB8B",
-		green: "#A3BE8C",
-		teal: "#88C0D0",
-		blue: "#5E81AC",
-		purple: "#B48EAD",
-		pink: "#D4879C"
-	};
-	const black = dark ? darken(bg, .05) : darken(bg, .1);
-	const white = dark ? blend(fg, bg, .3) : blend(bg, fg, .3);
-	const brightBlack = step(bg, .15);
-	const brightWhite = dark ? fg : brighten(fg, .1);
-	return {
-		name: opts.name ?? (dark ? "generated-dark" : "generated-light"),
-		dark,
-		primary: opts.primary,
-		black,
-		red: accents.red,
-		green: accents.green,
-		yellow: accents.yellow,
-		blue: accents.blue,
-		magenta: accents.purple,
-		cyan: accents.teal,
-		white,
-		brightBlack,
-		brightRed: accents.orange,
-		brightGreen: brighten(accents.green, .15),
-		brightYellow: brighten(accents.yellow, .15),
-		brightBlue: brighten(accents.blue, .15),
-		brightMagenta: accents.pink,
-		brightCyan: brighten(accents.teal, .15),
-		brightWhite,
-		foreground: fg,
-		background: bg,
-		cursorColor: fg,
-		cursorText: bg,
-		selectionBackground: blend(bg, accents.blue, .3),
-		selectionForeground: fg
-	};
-}
-/**
-* Look up a built-in palette by name.
-*
-* @returns The ColorScheme, or undefined if not found.
-*/
-function fromPreset(name) {
-	return getSchemeByName(name);
-}
-//#endregion
-//#region packages/theme/src/builder.ts
-/**
-* Chainable theme builder — create themes from minimal input.
-*
-* @example
-* ```typescript
-* // Just a background color
-* const theme = createTheme().bg('#2E3440').build()
-*
-* // Primary + explicit dark mode
-* const theme = createTheme().primary('#EBCB8B').dark().build()
-*
-* // Three-color input (dark/light inferred from bg luminance)
-* const theme = createTheme()
-*   .bg('#2E3440').fg('#ECEFF4').primary('#EBCB8B').build()
-*
-* // Preset with override
-* const theme = createTheme().preset('nord').primary('#A3BE8C').build()
-* ```
-*/
-init_src();
-function isDarkColor(hex) {
-	const rgb = hexToRgb(hex);
-	if (!rgb) return true;
-	return (rgb[0] + rgb[1] + rgb[2]) / 765 < .5;
-}
-/** Create a chainable theme builder. */
-function createTheme() {
-	const state = { colors: {} };
-	const builder = {
-		bg(color) {
-			state.bgColor = color;
-			return builder;
-		},
-		fg(color) {
-			state.fgColor = color;
-			return builder;
-		},
-		primary(color) {
-			state.primaryColor = color;
-			return builder;
-		},
-		accent(color) {
-			return builder.primary(color);
-		},
-		dark() {
-			state.dark = true;
-			return builder;
-		},
-		light() {
-			state.dark = false;
-			return builder;
-		},
-		color(name, value) {
-			state.colors[name] = value;
-			return builder;
-		},
-		palette(p) {
-			state.presetPalette = p;
-			return builder;
-		},
-		preset(name) {
-			const p = getSchemeByName(name);
-			if (p) state.presetPalette = p;
-			return builder;
-		},
-		build() {
-			const isDark = state.dark ?? (state.bgColor ? isDarkColor(state.bgColor) : true);
-			let palette;
-			if (state.presetPalette) {
-				palette = { ...state.presetPalette };
-				if (state.bgColor) palette.background = state.bgColor;
-				if (state.fgColor) palette.foreground = state.fgColor;
-				if (state.primaryColor) {
-					palette.primary = state.primaryColor;
-					const ansiName = hueToAnsiField(assignPrimaryToSlot(state.primaryColor));
-					palette[ansiName] = state.primaryColor;
-				}
-				palette.dark = isDark;
-			} else palette = fromColors({
-				background: state.bgColor,
-				foreground: state.fgColor,
-				primary: state.primaryColor,
-				dark: isDark
-			});
-			for (const [key, val] of Object.entries(state.colors)) if (val !== void 0 && typeof val === "string") palette[key] = val;
-			return deriveTheme$1(palette);
-		}
-	};
-	return builder;
-}
-/** Map a HueName to the corresponding ColorScheme field. */
-function hueToAnsiField(hue) {
-	return {
-		red: "red",
-		orange: "brightRed",
-		yellow: "yellow",
-		green: "green",
-		teal: "cyan",
-		blue: "blue",
-		purple: "magenta",
-		pink: "brightMagenta"
-	}[hue];
-}
-/**
-* Quick theme from a primary color or color name.
-*
-* @example
-* ```typescript
-* quickTheme('#EBCB8B', 'dark')  // yellow primary, dark mode
-* quickTheme('blue')              // blue primary, default dark
-* ```
-*/
-function quickTheme(primaryOrHex, mode) {
-	const b = createTheme();
-	if (primaryOrHex.startsWith("#")) b.primary(primaryOrHex);
-	else b.primary({
-		red: "#BF616A",
-		orange: "#D08770",
-		yellow: "#EBCB8B",
-		green: "#A3BE8C",
-		teal: "#88C0D0",
-		cyan: "#88C0D0",
-		blue: "#5E81AC",
-		purple: "#B48EAD",
-		pink: "#D4879C",
-		magenta: "#B48EAD",
-		white: "#ECEFF4"
-	}[primaryOrHex] ?? "#5E81AC");
-	if (mode === "dark") b.dark();
-	else if (mode === "light") b.light();
-	return b.build();
-}
-/**
-* Create a theme from a built-in preset name.
-*
-* @example
-* ```typescript
-* presetTheme('catppuccin-mocha')
-* presetTheme('nord')
-* ```
-*/
-function presetTheme(name) {
-	return createTheme().preset(name).build();
-}
-//#endregion
-//#region packages/theme/src/auto-generate.ts
-/**
-* Auto-generate themes — create a complete Theme from a single primary color.
-*
-* Uses OKLCH color manipulation to derive complementary and analogous colors
-* for the full palette from one input color. OKLCH preserves perceived
-* lightness and chroma across hue rotations, so accent ramps look balanced.
-*/
-init_src();
-/** Standard OKLCH hue positions for semantic accents (degrees).
-* OKLCH hues differ from HSL: red≈29, orange≈55, yellow≈90, green≈142,
-* teal≈195, blue≈240, purple≈305, pink≈350. Calibrated against Ottosson's
-* reference ramps. */
-const HUE = {
-	red: 29,
-	orangeBright: 55,
-	yellow: 90,
-	green: 142,
-	cyan: 195,
-	blue: 240,
-	magenta: 310,
-	pinkBright: 350
-};
-/**
-* Generate a complete Theme from a single primary color.
-*
-* Derives a full ColorScheme using OKLCH color manipulation:
-* - Background/foreground from lightness endpoints using the primary's hue
-* - Complementary and analogous accent colors from hue rotation
-* - Surface ramp from bg lightness offsets
-* - Status colors (error, warning, success, info) from standard hue positions
-*
-* @param primaryColor - A hex color string (e.g. "#5E81AC")
-* @param mode - "dark" or "light" theme mode
-* @returns A complete Theme with all 33 semantic tokens
-*
-* @example
-* ```typescript
-* const theme = autoGenerateTheme("#5E81AC", "dark")
-* // Generates a full dark theme with blue as the primary accent
-*
-* const light = autoGenerateTheme("#E06C75", "light")
-* // Generates a full light theme with red/rose as the primary accent
-* ```
-*/
-function autoGenerateTheme(primaryColor, mode) {
-	const o = hexToOklch(primaryColor);
-	if (!o) return deriveTheme$1(fromColors({ dark: mode === "dark" }));
-	const dark = mode === "dark";
-	const bgL = dark ? .22 : .96;
-	const fgL = dark ? .9 : .2;
-	const bgC = Math.min(o.C, .03);
-	const bg = oklchToHex({
-		L: bgL,
-		C: bgC,
-		H: o.H
-	});
-	const fg = oklchToHex({
-		L: fgL,
-		C: bgC * .5,
-		H: o.H
-	});
-	const accentL = dark ? .72 : .52;
-	const accentC = Math.max(o.C, .1);
-	const accent = (h) => oklchToHex({
-		L: accentL,
-		C: accentC,
-		H: h
-	});
-	const red = accent(HUE.red);
-	const green = accent(HUE.green);
-	const yellow = accent(HUE.yellow);
-	const blue = accent(HUE.blue);
-	const magenta = accent(HUE.magenta);
-	const cyan = accent(HUE.cyan);
-	const brightL = accentL + (dark ? .1 : -.1);
-	const brightAccent = (h) => oklchToHex({
-		L: brightL,
-		C: accentC,
-		H: h
-	});
-	const brightRed = brightAccent(HUE.orangeBright);
-	const brightGreen = brightAccent(HUE.green);
-	const brightYellow = brightAccent(HUE.yellow);
-	const brightBlue = brightAccent(HUE.blue);
-	const brightMagenta = brightAccent(HUE.pinkBright);
-	const brightCyan = brightAccent(HUE.cyan);
-	const black = oklchToHex({
-		L: dark ? bgL * .7 : bgL * .92,
-		C: bgC,
-		H: o.H
-	});
-	const white = oklchToHex({
-		L: dark ? .6 : .35,
-		C: bgC * .3,
-		H: o.H
-	});
-	const brightBlack = oklchToHex({
-		L: dark ? bgL + .1 : bgL - .08,
-		C: bgC,
-		H: o.H
-	});
-	const brightWhite = dark ? fg : oklchToHex({
-		L: fgL - .05,
-		C: bgC * .5,
-		H: o.H
-	});
-	return deriveTheme$1({
-		name: `generated-${mode}`,
-		dark,
-		primary: primaryColor,
-		black,
-		red,
-		green,
-		yellow,
-		blue,
-		magenta,
-		cyan,
-		white,
-		brightBlack,
-		brightRed,
-		brightGreen,
-		brightYellow,
-		brightBlue,
-		brightMagenta,
-		brightCyan,
-		brightWhite,
-		foreground: fg,
-		background: bg,
-		cursorColor: fg,
-		cursorText: bg,
-		selectionBackground: blend(bg, primaryColor, .3),
-		selectionForeground: fg
-	});
-}
-//#endregion
-//#region packages/theme/src/validate.ts
-/**
-* Palette validation — checks ColorScheme fields and contrast.
-*/
-init_src();
-/**
-* Validate a ColorScheme.
-*
-* Checks:
-* - All 22 color fields are present and non-empty hex strings
-* - Warns on low-contrast foreground/background combinations
-*/
-function validateColorScheme(p) {
-	const errors = [];
-	const warnings = [];
-	for (const field of COLOR_SCHEME_FIELDS) {
-		const val = p[field];
-		if (!val || typeof val !== "string") errors.push(`${field} is required and must be a non-empty string`);
-	}
-	if (p.foreground && p.background) {
-		const fgRgb = hexToRgb(p.foreground);
-		const bgRgb = hexToRgb(p.background);
-		if (fgRgb && bgRgb) {
-			const fgSum = fgRgb[0] + fgRgb[1] + fgRgb[2];
-			const bgSum = bgRgb[0] + bgRgb[1] + bgRgb[2];
-			if (fgSum > 384 === bgSum > 384) warnings.push(`Low contrast: foreground (${p.foreground}) and background (${p.background}) have similar lightness`);
-		}
-	}
-	return {
-		valid: errors.length === 0,
-		errors,
-		warnings
-	};
-}
-//#endregion
-//#region packages/theme/src/validate-theme.ts
-/**
-* Theme validation — checks that all required semantic tokens are present.
-*
-* Complements validateColorScheme() which validates the lower-level
-* ColorScheme. This validates the derived Theme object.
-*/
-/** All 33 required semantic token keys on Theme (excludes `name` and `palette`). */
-const THEME_TOKEN_KEYS = [
-	"bg",
-	"fg",
-	"muted",
-	"mutedbg",
-	"surface",
-	"surfacebg",
-	"popover",
-	"popoverbg",
-	"inverse",
-	"inversebg",
-	"cursor",
-	"cursorbg",
-	"selection",
-	"selectionbg",
-	"primary",
-	"primaryfg",
-	"secondary",
-	"secondaryfg",
-	"accent",
-	"accentfg",
-	"error",
-	"errorfg",
-	"warning",
-	"warningfg",
-	"success",
-	"successfg",
-	"info",
-	"infofg",
-	"border",
-	"inputborder",
-	"focusborder",
-	"link",
-	"disabledfg"
-];
-/** All recognized keys on Theme (tokens + metadata). */
-const ALL_KNOWN_KEYS = new Set([
-	...THEME_TOKEN_KEYS,
-	"name",
-	"palette"
-]);
-/**
-* Validate a Theme object — check that all required tokens are present.
-*
-* @param theme - The theme object to validate
-* @returns Validation result with missing and extra token lists
-*
-* @example
-* ```typescript
-* const result = validateTheme(myTheme)
-* if (!result.valid) {
-*   console.log("Missing tokens:", result.missing)
-* }
-* ```
-*/
-function validateTheme(theme) {
-	const missing = [];
-	const extra = [];
-	for (const key of THEME_TOKEN_KEYS) {
-		const val = theme[key];
-		if (val === void 0 || val === null || val === "") missing.push(key);
-	}
-	for (const key of Object.keys(theme)) if (!ALL_KNOWN_KEYS.has(key)) extra.push(key);
-	return {
-		valid: missing.length === 0,
-		missing,
-		extra
-	};
-}
-//#endregion
-//#region packages/theme/src/alias.ts
-/** Maximum depth for alias chain resolution before treating as circular. */
-const MAX_ALIAS_DEPTH = 10;
-/**
-* Resolve all token aliases in a theme.
-*
-* Token values that start with `$` are treated as references to other tokens.
-* Alias chains are followed until a concrete (non-$) value is reached.
-* Circular references are detected via a depth limit and left unresolved.
-*
-* @param theme - A theme-like object where values may reference other tokens via `$name`
-* @returns A new object with all aliases resolved to concrete values
-*
-* @example
-* ```typescript
-* const themed = resolveAliases({
-*   ...baseTheme,
-*   button: "$primary",      // resolves to the value of 'primary'
-*   buttonHover: "$button",  // chain: buttonHover -> button -> primary -> hex
-* })
-* ```
-*/
-function resolveAliases(theme) {
-	const result = {};
-	for (const key of Object.keys(theme)) result[key] = resolveAlias(key, theme, 0);
-	return result;
-}
-/**
-* Resolve a single token's alias chain.
-*
-* @param key - The token key to resolve
-* @param tokens - The full token map
-* @param depth - Current recursion depth (for loop detection)
-* @returns The resolved concrete value, or the raw alias string if unresolvable
-*/
-function resolveAlias(key, tokens, depth) {
-	if (depth >= MAX_ALIAS_DEPTH) return tokens[key] ?? "";
-	const value = tokens[key];
-	if (value === void 0) return "";
-	if (!value.startsWith("$")) return value;
-	const refKey = value.slice(1);
-	if (!(refKey in tokens)) return value;
-	return resolveAlias(refKey, tokens, depth + 1);
-}
-/**
-* Resolve a single alias value against a Theme.
-*
-* Useful for resolving individual values without processing the entire theme.
-*
-* @param value - The value to resolve (may be "$tokenName" or a concrete value)
-* @param theme - The theme to resolve against
-* @returns The resolved concrete value
-*/
-function resolveTokenAlias(value, theme) {
-	if (!value.startsWith("$")) return value;
-	const seen = /* @__PURE__ */ new Set();
-	let current = value;
-	for (let i = 0; i < MAX_ALIAS_DEPTH; i++) {
-		if (!current.startsWith("$")) return current;
-		const key = current.slice(1);
-		if (seen.has(key)) return current;
-		seen.add(key);
-		const resolved = theme[key];
-		if (typeof resolved !== "string") return current;
-		current = resolved;
-	}
-	return current;
-}
-//#endregion
-//#region packages/theme/src/sterling/flat-tokens.ts
-const STERLING_FLAT_TOKENS = [
-	"bg-surface-default",
-	"bg-surface-subtle",
-	"bg-surface-raised",
-	"bg-surface-overlay",
-	"bg-surface-hover",
-	"border-default",
-	"border-focus",
-	"border-muted",
-	"fg-cursor",
-	"bg-cursor",
-	"fg-muted",
-	"bg-muted",
-	"fg-accent",
-	"bg-accent",
-	"fg-on-accent",
-	"fg-accent-hover",
-	"bg-accent-hover",
-	"fg-accent-active",
-	"bg-accent-active",
-	"border-accent",
-	"fg-info",
-	"bg-info",
-	"fg-on-info",
-	"bg-info-hover",
-	"bg-info-active",
-	"fg-success",
-	"bg-success",
-	"fg-on-success",
-	"bg-success-hover",
-	"bg-success-active",
-	"fg-warning",
-	"bg-warning",
-	"fg-on-warning",
-	"bg-warning-hover",
-	"bg-warning-active",
-	"fg-error",
-	"bg-error",
-	"fg-on-error",
-	"bg-error-hover",
-	"bg-error-active"
-];
-//#endregion
-//#region packages/theme/src/css.ts
-/**
-* Convert a Theme to CSS custom properties.
-*
-* Token names mirror Sterling's flat grammar with a `--` prefix:
-*   - `bg-surface-default` → `--bg-surface-default`
-*   - `fg-accent` → `--fg-accent`
-*   - `border-focus` → `--border-focus`
-*   - Palette entries: `--color0` through `--color15`
-*
-* @param theme - The theme to convert (Sterling flat tokens must be populated)
-* @returns A record mapping CSS custom property names to color values
-*
-* @example
-* ```typescript
-* const vars = themeToCSSVars(myTheme)
-* // { "--bg-surface-default": "#1E1E2E", "--fg-accent": "#F9E2AF", ... }
-*
-* // Apply to an element:
-* Object.assign(element.style, vars)
-* ```
-*/
-function themeToCSSVars(theme) {
-	const vars = {};
-	const flat = theme;
-	for (const key of STERLING_FLAT_TOKENS) {
-		const value = flat[key];
-		if (typeof value === "string") vars[`--${key}`] = value;
-	}
-	if (theme.palette) for (let i = 0; i < theme.palette.length; i++) vars[`--color${i}`] = theme.palette[i];
-	return vars;
-}
-//#endregion
-//#region packages/theme/src/export/base16.ts
-/**
-* Export ColorScheme to Base16 YAML format.
-*
-* Maps ColorScheme fields to base00–base0F. For fields that
-* ColorScheme doesn't store directly (base04/base06/base07),
-* we interpolate between neighboring values.
-*
-* @see https://github.com/chriskempson/base16
-*/
-/** Strip `#` prefix from a hex color string and uppercase. */
-function stripHash(hex) {
-	return (hex.startsWith("#") ? hex.slice(1) : hex).toUpperCase();
-}
-/**
-* Export a ColorScheme to Base16 YAML format.
-*
-* Mapping:
-*   background → base00, brightBlack → base01, selectionBackground → base02,
-*   white → base03, (interpolated) → base04, foreground → base05,
-*   (interpolated) → base06, (interpolated) → base07,
-*   red → base08, brightRed → base09, yellow → base0A, green → base0B,
-*   cyan → base0C, blue → base0D, magenta → base0E, brightMagenta → base0F.
-*/
-function exportBase16(palette) {
-	const dark = palette.dark ?? true;
-	const base04 = blend(palette.white, palette.foreground, .33);
-	const base06 = dark ? blend(palette.foreground, "#FFFFFF", .15) : blend(palette.foreground, "#000000", .15);
-	const base07 = palette.black;
-	return [
-		`scheme: "${palette.name ?? "exported"}"`,
-		`author: ""`,
-		`base00: "${stripHash(palette.background)}"`,
-		`base01: "${stripHash(palette.brightBlack)}"`,
-		`base02: "${stripHash(palette.selectionBackground)}"`,
-		`base03: "${stripHash(palette.white)}"`,
-		`base04: "${stripHash(base04)}"`,
-		`base05: "${stripHash(palette.foreground)}"`,
-		`base06: "${stripHash(base06)}"`,
-		`base07: "${stripHash(base07)}"`,
-		`base08: "${stripHash(palette.red)}"`,
-		`base09: "${stripHash(palette.brightRed)}"`,
-		`base0A: "${stripHash(palette.yellow)}"`,
-		`base0B: "${stripHash(palette.green)}"`,
-		`base0C: "${stripHash(palette.cyan)}"`,
-		`base0D: "${stripHash(palette.blue)}"`,
-		`base0E: "${stripHash(palette.magenta)}"`,
-		`base0F: "${stripHash(palette.brightMagenta)}"`
-	].join("\n") + "\n";
-}
-//#endregion
-//#region packages/theme/src/detect.ts
-init_src();
-/**
-* Detect the terminal's palette and return a Sterling-aware Theme.
-*
-* Identical to `@silvery/ansi`'s `detectTheme` but every returned theme has
-* Sterling flat tokens baked in via `inlineSterlingTokens`.
-*/
-async function detectTheme(opts = {}) {
-	return inlineSterlingTokens(await detectTheme$1(opts));
-}
-//#endregion
-//#region packages/theme/src/sterling/defaults.ts
-/**
-* A hand-tuned neutral dark scheme — not a copy of any catalog palette, but
-* close to Nord/Dracula territory. Used only when the caller asks for a
-* "raw default" (no scheme at all).
-*/
-const darkBaseline = {
-	name: "sterling-dark",
-	dark: true,
-	primary: "#7FB4CA",
-	black: "#1E1E2E",
-	red: "#E06C75",
-	green: "#98C379",
-	yellow: "#E5C07B",
-	blue: "#61AFEF",
-	magenta: "#C678DD",
-	cyan: "#56B6C2",
-	white: "#ABB2BF",
-	brightBlack: "#5C6370",
-	brightRed: "#E06C75",
-	brightGreen: "#98C379",
-	brightYellow: "#E5C07B",
-	brightBlue: "#61AFEF",
-	brightMagenta: "#C678DD",
-	brightCyan: "#56B6C2",
-	brightWhite: "#FFFFFF",
-	foreground: "#E4E4E7",
-	background: "#16181D",
-	cursorColor: "#E4E4E7",
-	cursorText: "#16181D",
-	selectionBackground: "#3E4452",
-	selectionForeground: "#E4E4E7"
-};
-const lightBaseline = {
-	name: "sterling-light",
-	dark: false,
-	primary: "#1F6FEB",
-	black: "#24292F",
-	red: "#CF222E",
-	green: "#1A7F37",
-	yellow: "#9A6700",
-	blue: "#0969DA",
-	magenta: "#8250DF",
-	cyan: "#1B7C83",
-	white: "#6E7781",
-	brightBlack: "#57606A",
-	brightRed: "#A40E26",
-	brightGreen: "#2DA44E",
-	brightYellow: "#BF8700",
-	brightBlue: "#218BFF",
-	brightMagenta: "#A475F9",
-	brightCyan: "#3192AA",
-	brightWhite: "#8C959F",
-	foreground: "#1F2328",
-	background: "#FFFFFF",
-	cursorColor: "#1F2328",
-	cursorText: "#FFFFFF",
-	selectionBackground: "#DDF4FF",
-	selectionForeground: "#1F2328"
-};
-function defaultScheme(mode = "dark") {
-	return mode === "dark" ? darkBaseline : lightBaseline;
-}
-//#endregion
-//#region packages/theme/src/sterling/define.ts
-init_src();
-function resolveFlatten(flatten) {
-	if (flatten === false || flatten === void 0) return (t) => t;
-	if (typeof flatten === "function") {
-		const rule = flatten;
-		return (t) => bakeFlat(t, rule);
-	}
-	return (t) => bakeFlat(t);
-}
-/**
-* Wrap a DesignSystem so every derivation method auto-applies `bakeFlat`
-* per the `flatten` flag. Pass your raw system (one that returns nested
-* themes) and this returns a user-facing system whose outputs have flat
-* keys populated.
-*/
-function defineDesignSystem(def) {
-	const flatten = resolveFlatten(def.flatten);
-	return {
-		name: def.name,
-		shape: def.shape,
-		flatten: def.flatten,
-		defaults: (mode) => flatten(def.defaults(mode)),
-		theme: (partial, opts) => flatten(def.theme(partial, opts)),
-		deriveFromScheme: (scheme, opts) => flatten(def.deriveFromScheme(scheme, opts)),
-		deriveFromColor: (color, opts) => flatten(def.deriveFromColor(color, opts)),
-		deriveFromPair: (light, dark, opts) => {
-			const pair = def.deriveFromPair(light, dark, opts);
-			return {
-				light: flatten(pair.light),
-				dark: flatten(pair.dark)
-			};
-		},
-		deriveFromSchemeWithBrand: (scheme, brand, opts) => flatten(def.deriveFromSchemeWithBrand(scheme, brand, opts))
-	};
-}
-//#endregion
-//#region packages/theme/src/sterling/sterling.ts
-/**
-* Sterling — silvery's canonical DesignSystem.
-*
-* This is the default system shipped from `@silvery/theme`. It implements
-* the `DesignSystem` contract from `types.ts` and serves as the reference
-* for alternative systems (`@silvery/design-material`, `-primer`, etc.).
-*
-* The flat-projection (`theme["bg-accent"]` as a sibling of `theme.accent.bg`
-* on the same object) is NOT Sterling-specific — it's a framework feature.
-* Sterling opts in via `flatten: true` in {@link defineDesignSystem}, which
-* auto-applies `bakeFlat` (from `@silvery/ansi`) to every derivation's
-* output. The default rule is channel-role-state (`fg-accent`, `bg-accent-hover`,
-* `fg-on-error`, `bg-surface-subtle`, `border-focus`, …) — exactly what
-* Sterling's pre-generalization `populateFlat` produced.
-*
-* All derivation functions return a frozen Theme with both nested roles
-* AND flat hyphen keys populated — the user-facing `$fg-accent` syntax
-* resolves against the flat keys, while programmatic access uses nested.
-*/
-const STERLING_SHAPE = {
-	flatTokens: STERLING_FLAT_TOKENS,
-	roles: [
-		"accent",
-		"info",
-		"success",
-		"warning",
-		"error",
-		"muted",
-		"surface",
-		"border",
-		"cursor"
-	],
-	states: ["hover", "active"]
-};
-/**
-* Internal: build a nested Theme (no flat keys). `defineDesignSystem` applies
-* `bakeFlat` afterwards — the inner derivation stays flat-agnostic.
-*/
-function buildRawTheme(scheme, opts = {}) {
-	return deriveTheme(scheme, opts);
-}
-/**
-* Apply a brand overlay to a ColorScheme — overrides `primary` and relevant
-* ANSI hue slots with the brand color. Keeps the rest of the scheme intact.
-* Per Appendix F: brand is a theme INPUT, not a public token sibling of accent.
-*/
-function applyBrand(scheme, brand) {
-	return {
-		...scheme,
-		primary: brand
-	};
-}
-/**
-* Sterling — the user-facing DesignSystem. `defineDesignSystem` wraps
-* `rawSterling` with auto-`bakeFlat` (per `flatten: true`), so every
-* returned Theme has both nested roles AND flat hyphen keys populated.
-*/
-const sterling = defineDesignSystem({
-	name: "sterling",
-	shape: STERLING_SHAPE,
-	flatten: true,
-	defaults(mode = "dark") {
-		return buildRawTheme(defaultScheme(mode), { contrast: "auto-lift" });
-	},
-	theme(partial, opts = {}) {
-		const base = buildRawTheme(defaultScheme(opts.mode ?? "dark"), {
-			...opts,
-			contrast: opts.contrast ?? "auto-lift"
-		});
-		if (!partial) return base;
-		return mergePartial(base, partial);
-	},
-	deriveFromScheme(scheme, opts = {}) {
-		return buildRawTheme(scheme, opts);
-	},
-	deriveFromColor(color, opts = {}) {
-		return buildRawTheme({
-			...defaultScheme(opts.mode ?? "dark"),
-			name: `seed:${color}`,
-			primary: color,
-			blue: color,
-			brightBlue: blend(color, "#ffffff", .15)
-		}, opts);
-	},
-	deriveFromPair(light, dark, opts = {}) {
-		return {
-			light: buildRawTheme(light, {
-				...opts,
-				mode: "light"
-			}),
-			dark: buildRawTheme(dark, {
-				...opts,
-				mode: "dark"
-			})
-		};
-	},
-	deriveFromSchemeWithBrand(scheme, brand, opts = {}) {
-		return buildRawTheme(applyBrand(scheme, brand), opts);
-	}
-});
-//#endregion
-//#region packages/theme/src/sterling/index.ts
-init_src();
-//#endregion
-//#region packages/theme/src/theme.ts
-init_src();
-//#endregion
-export { kanagawaLotus as $, modusVivendi as A, nightfox as B, builtinPalettes as C, checkAA as Ct, getSchemeByName as D, defaultLightTheme as E, oxocarbonLight as F, materialDark as G, ayuLight as H, nightfly as I, monokai as J, materialLight as K, moonfly as L, edgeLight as M, sonokai as N, getThemeByName as O, oxocarbonDark as P, kanagawaDragon as Q, horizon as R, ansi16LightTheme as S, autoLift as St, defaultDarkTheme as T, generateTheme as Tt, ayuMirage as U, ayuDark as V, palenight as W, everforestDark as X, monokaiPro as Y, everforestLight as Z, assignPrimaryToSlot as _, catppuccinMocha as _t, exportBase16 as a, gruvboxLight as at, fromPreset as b, ContrastError as bt, resolveAliases as c, tokyoNightDay as ct, validateTheme as d, solarizedLight as dt, kanagawaWave as et, validateColorScheme as f, dracula as ft, quickTheme as g, catppuccinMacchiato as gt, presetTheme as h, catppuccinLatte as ht, detectTheme as i, gruvboxDark as it, edgeDark as j, modusOperandi as k, resolveTokenAlias as l, tokyoNightStorm as lt, createTheme as m, catppuccinFrappe as mt, defineDesignSystem as n, rosePineDawn as nt, themeToCSSVars as o, oneDark as ot, autoGenerateTheme as p, nord as pt, snazzy as q, defaultScheme as r, rosePineMoon as rt, STERLING_FLAT_TOKENS as s, tokyoNight as st, sterling as t, rosePine as tt, THEME_TOKEN_KEYS as u, solarizedDark as ut, fromBase16 as v, deriveRoles as vt, builtinThemes as w, importBase16 as wt, ansi16DarkTheme as x, WCAG_AA as xt, fromColors as y, deriveTheme as yt, dawnfox as z };
+export { everforestDark as A, oneDark as B, ayuMirage as C, snazzy as D, materialLight as E, rosePine as F, solarizedLight as G, tokyoNightDay as H, rosePineDawn as I, catppuccinFrappe as J, dracula as K, rosePineMoon as L, kanagawaDragon as M, kanagawaLotus as N, monokai as O, kanagawaWave as P, gruvboxDark as R, ayuLight as S, materialDark as T, tokyoNightStorm as U, tokyoNight as V, solarizedDark as W, catppuccinMacchiato as X, catppuccinLatte as Y, catppuccinMocha as Z, moonfly as _, defaultDarkTheme as a, nightfox as b, getThemeByName as c, edgeDark as d, edgeLight as f, nightfly as g, oxocarbonLight as h, builtinThemes as i, everforestLight as j, monokaiPro as k, modusOperandi as l, oxocarbonDark as m, ansi16LightTheme as n, defaultLightTheme as o, sonokai as p, nord as q, builtinPalettes as r, getSchemeByName as s, ansi16DarkTheme as t, modusVivendi as u, horizon as v, palenight as w, ayuDark as x, dawnfox as y, gruvboxLight as z };
 
-//# sourceMappingURL=src-B5GjfG7g.mjs.map
+//# sourceMappingURL=schemes-DYt2ushj.mjs.map