silvery 0.19.1 → 0.21.0

package/dist/src-NCKb8kE5.mjs

@@ -1,2660 +0,0 @@
-import { i as __require, n as __esmMin } from "./chunk-Vs_PY4HZ.mjs";
-import "string-width";
-import { blend, brighten, checkContrast, colorDistance, complement, contrastFg, darken, deltaE, ensureContrast, hexToOklch, hexToRgb as hexToRgb$1, oklchToHex } from "@silvery/color";
-//#region packages/ansi/src/detection.ts
-/**
-* Detect if terminal supports cursor control (repositioning).
-* Returns false for dumb terminals and piped output.
-*/
-function detectCursor(stdout) {
-	if (!stdout.isTTY) return false;
-	if (process.env.TERM === "dumb") return false;
-	return true;
-}
-/**
-* Detect if terminal can read raw keystrokes.
-* Requires stdin to be a TTY with raw mode support.
-*/
-function detectInput(stdin) {
-	if (!stdin.isTTY) return false;
-	return typeof stdin.setRawMode === "function";
-}
-/**
-* Detect color level supported by terminal.
-* Returns null if no color support.
-*
-* Checks (in order):
-* 1. NO_COLOR env var - forces no color
-* 2. FORCE_COLOR env var - forces color level
-* 3. COLORTERM=truecolor - truecolor support
-* 4. TERM patterns - detect from terminal type
-* 5. CI detection - basic colors in CI
-*/
-function detectColor(stdout) {
-	if (process.env.NO_COLOR !== void 0) return null;
-	const forceColor = process.env.FORCE_COLOR;
-	if (forceColor !== void 0) {
-		if (forceColor === "0" || forceColor === "false") return null;
-		if (forceColor === "1") return "basic";
-		if (forceColor === "2") return "256";
-		if (forceColor === "3") return "truecolor";
-		return "basic";
-	}
-	if (!stdout.isTTY) return null;
-	if (process.env.TERM === "dumb") return null;
-	const colorTerm = process.env.COLORTERM;
-	if (colorTerm === "truecolor" || colorTerm === "24bit") return "truecolor";
-	const term = process.env.TERM ?? "";
-	if (term.includes("truecolor") || term.includes("24bit") || term.includes("xterm-ghostty") || term.includes("xterm-kitty") || term.includes("wezterm")) return "truecolor";
-	if (term.includes("256color") || term.includes("256")) return "256";
-	const termProgram = process.env.TERM_PROGRAM;
-	if (termProgram === "iTerm.app" || termProgram === "Apple_Terminal") return termProgram === "iTerm.app" ? "truecolor" : "256";
-	if (termProgram === "Ghostty" || termProgram === "WezTerm") return "truecolor";
-	if (process.env.KITTY_WINDOW_ID) return "truecolor";
-	if (term.includes("xterm") || term.includes("color") || term.includes("ansi")) return "basic";
-	if (CI_ENVS.some((env) => process.env[env] !== void 0)) return "basic";
-	if (process.env.WT_SESSION) return "truecolor";
-	return "basic";
-}
-/**
-* Detect if terminal can render unicode symbols.
-* Based on TERM, locale, and known terminal apps.
-*/
-function detectUnicode() {
-	if (process.env.CI) {
-		if (process.env.GITHUB_ACTIONS) return true;
-	}
-	const lang = process.env.LANG ?? process.env.LC_ALL ?? process.env.LC_CTYPE ?? "";
-	if (lang.toLowerCase().includes("utf-8") || lang.toLowerCase().includes("utf8")) return true;
-	if (process.env.WT_SESSION) return true;
-	const termProgram = process.env.TERM_PROGRAM ?? "";
-	if ([
-		"iTerm.app",
-		"Ghostty",
-		"WezTerm",
-		"Apple_Terminal"
-	].includes(termProgram)) return true;
-	if (process.env.KITTY_WINDOW_ID) return true;
-	const term = process.env.TERM ?? "";
-	if (term.includes("xterm") || term.includes("rxvt") || term.includes("screen") || term.includes("tmux")) return true;
-	return false;
-}
-/**
-* Default capabilities (assumes modern terminal with full support).
-*/
-function defaultCaps() {
-	return {
-		program: "",
-		term: "",
-		colorLevel: "truecolor",
-		kittyKeyboard: false,
-		kittyGraphics: false,
-		sixel: false,
-		osc52: false,
-		hyperlinks: false,
-		notifications: false,
-		bracketedPaste: true,
-		mouse: true,
-		syncOutput: false,
-		unicode: true,
-		underlineStyles: true,
-		underlineColor: true,
-		textEmojiWide: true,
-		textSizingSupported: false,
-		darkBackground: true,
-		nerdfont: false
-	};
-}
-/**
-* Check if macOS is in dark mode by reading the system appearance preference.
-* Uses `defaults read -g AppleInterfaceStyle` — returns "Dark" when dark mode
-* is active, exits non-zero when light mode. ~2ms via spawnSync.
-*
-* Result is cached after first call to avoid repeated process spawns.
-*/
-function detectMacOSDarkMode() {
-	if (cachedMacOSDarkMode !== void 0) return cachedMacOSDarkMode;
-	try {
-		const { spawnSync } = __require("child_process");
-		cachedMacOSDarkMode = spawnSync("defaults", [
-			"read",
-			"-g",
-			"AppleInterfaceStyle"
-		], {
-			encoding: "utf-8",
-			timeout: 500
-		}).stdout?.trim() === "Dark";
-	} catch {
-		cachedMacOSDarkMode = false;
-	}
-	return cachedMacOSDarkMode;
-}
-/** Detect terminal capabilities from environment variables.
-* Synchronous. Minimal I/O: may run `defaults` on macOS for Apple_Terminal.
-*/
-function detectTerminalCaps() {
-	const program = process.env.TERM_PROGRAM ?? "";
-	const term = process.env.TERM ?? "";
-	const colorTerm = process.env.COLORTERM ?? "";
-	const noColor = process.env.NO_COLOR !== void 0;
-	const isAppleTerminal = program === "Apple_Terminal";
-	let colorLevel = "none";
-	if (!noColor) {
-		if (isAppleTerminal) colorLevel = "256";
-		else if (colorTerm === "truecolor" || colorTerm === "24bit") colorLevel = "truecolor";
-		else if (term.includes("256color")) colorLevel = "256";
-		else if (process.stdout?.isTTY) colorLevel = "basic";
-	}
-	const isKitty = term === "xterm-kitty";
-	const isITerm = program === "iTerm.app";
-	const isGhostty = program === "ghostty";
-	const isWezTerm = program === "WezTerm";
-	const isAlacritty = program === "Alacritty";
-	const isFoot = term === "foot" || term === "foot-extra";
-	const isModern = isKitty || isITerm || isGhostty || isWezTerm || isFoot;
-	let isKittyWithTextSizing = false;
-	if (isKitty) {
-		const parts = (process.env.TERM_PROGRAM_VERSION ?? "").split(".");
-		const major = Number(parts[0]) || 0;
-		const minor = Number(parts[1]) || 0;
-		isKittyWithTextSizing = major > 0 || major === 0 && minor >= 40;
-	}
-	let darkBackground = !isAppleTerminal;
-	const colorFgBg = process.env.COLORFGBG;
-	if (colorFgBg) {
-		const parts = colorFgBg.split(";");
-		const bg = parseInt(parts[parts.length - 1] ?? "", 10);
-		if (!isNaN(bg)) darkBackground = bg < 7;
-	} else if (isAppleTerminal) darkBackground = detectMacOSDarkMode();
-	let nerdfont = isModern || isAlacritty;
-	const nfEnv = process.env.NERDFONT;
-	if (nfEnv === "0" || nfEnv === "false") nerdfont = false;
-	else if (nfEnv === "1" || nfEnv === "true") nerdfont = true;
-	const underlineExtensions = isModern || isAlacritty;
-	return {
-		program,
-		term,
-		colorLevel,
-		kittyKeyboard: isKitty || isGhostty || isWezTerm || isFoot,
-		kittyGraphics: isKitty || isGhostty,
-		sixel: isFoot || isWezTerm,
-		osc52: isModern || isAlacritty,
-		hyperlinks: isModern || isAlacritty,
-		notifications: isITerm || isKitty,
-		bracketedPaste: true,
-		mouse: true,
-		syncOutput: isModern || isAlacritty,
-		unicode: true,
-		underlineStyles: underlineExtensions,
-		underlineColor: underlineExtensions,
-		textEmojiWide: !isAppleTerminal,
-		textSizingSupported: isKittyWithTextSizing,
-		darkBackground,
-		nerdfont
-	};
-}
-var CI_ENVS, cachedMacOSDarkMode;
-var init_detection = __esmMin((() => {
-	CI_ENVS = [
-		"CI",
-		"GITHUB_ACTIONS",
-		"GITLAB_CI",
-		"JENKINS_URL",
-		"BUILDKITE",
-		"CIRCLECI",
-		"TRAVIS"
-	];
-}));
-//#endregion
-//#region packages/ansi/src/sgr-codes.ts
-/**
-* SGR (Select Graphic Rendition) color code helpers.
-*
-* Shared by buffer.ts (styleToAnsiCodes) and output-phase.ts (styleTransition).
-* Emits the shortest possible SGR code string for a given color.
-*/
-/**
-* Emit the shortest SGR code string for a foreground color.
-* - Basic 0-7: 4-bit code (30+N)
-* - Extended 8-255: 256-color (38;5;N)
-* - RGB: true color (38;2;R;G;B)
-*/
-function fgColorCode(color) {
-	if (typeof color === "number") {
-		if (color >= 0 && color <= 7) return `${30 + color}`;
-		return `38;5;${color}`;
-	}
-	return `38;2;${color.r};${color.g};${color.b}`;
-}
-/**
-* Emit the shortest SGR code string for a background color.
-* - Basic 0-7: 4-bit code (40+N)
-* - Extended 8-255: 256-color (48;5;N)
-* - RGB: true color (48;2;R;G;B)
-*/
-function bgColorCode(color) {
-	if (typeof color === "number") {
-		if (color >= 0 && color <= 7) return `${40 + color}`;
-		return `48;5;${color}`;
-	}
-	return `48;2;${color.r};${color.g};${color.b}`;
-}
-var init_sgr_codes = __esmMin((() => {}));
-//#endregion
-//#region packages/ansi/src/utils.ts
-var init_utils = __esmMin((() => {}));
-//#endregion
-//#region packages/ansi/src/color-maps.ts
-/** Find nearest ANSI 16 color index for an RGB value. */
-function nearestAnsi16(r, g, b) {
-	let bestIdx = 0;
-	let bestDist = Infinity;
-	for (let i = 0; i < 16; i++) {
-		const [cr, cg, cb] = ANSI_16_COLORS[i];
-		const dist = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
-		if (dist < bestDist) {
-			bestDist = dist;
-			bestIdx = i;
-		}
-	}
-	return bestIdx;
-}
-/** Convert RGB to 256-color index (using the 6x6x6 color cube). */
-function rgbToAnsi256(r, g, b) {
-	if (r === g && g === b) {
-		if (r < 8) return 16;
-		if (r > 248) return 231;
-		return Math.round((r - 8) / 247 * 24) + 232;
-	}
-	const ri = Math.round(r / 255 * 5);
-	const gi = Math.round(g / 255 * 5);
-	const bi = Math.round(b / 255 * 5);
-	return 16 + 36 * ri + 6 * gi + bi;
-}
-/**
-* Generate SGR foreground code for an RGB color at the given color level.
-* Returns the SGR parameter string (e.g., "31" or "38;5;196" or "38;2;255;0;0").
-*/
-function fgFromRgb(r, g, b, level) {
-	if (level === "truecolor") return `38;2;${r};${g};${b}`;
-	if (level === "256") return `38;5;${rgbToAnsi256(r, g, b)}`;
-	const idx = nearestAnsi16(r, g, b);
-	return idx < 8 ? `${30 + idx}` : `${82 + idx}`;
-}
-/**
-* Generate SGR background code for an RGB color at the given color level.
-*/
-function bgFromRgb(r, g, b, level) {
-	if (level === "truecolor") return `48;2;${r};${g};${b}`;
-	if (level === "256") return `48;5;${rgbToAnsi256(r, g, b)}`;
-	const idx = nearestAnsi16(r, g, b);
-	return idx < 8 ? `${40 + idx}` : `${92 + idx}`;
-}
-/**
-* Convert a 256-palette index back to its canonical xterm hex value.
-*
-* Mirrors `rgbToAnsi256`:
-*   - 16–231: 6×6×6 color cube. Index = 16 + 36·r + 6·g + b (each channel 0..5).
-*   - 232–255: 24-step grayscale ramp.
-*   - 0–15: ANSI 16 slots (reuses ANSI16_SLOT_HEX for exact parity with
-*     `nearestAnsi16`).
-*/
-function ansi256ToHex(idx) {
-	if (idx < 0 || idx > 255 || !Number.isInteger(idx)) return "#000000";
-	if (idx < 16) {
-		const [r, g, b] = ANSI_16_COLORS[idx];
-		return rgbToHexHash(r, g, b);
-	}
-	if (idx < 232) {
-		const levels = [
-			0,
-			95,
-			135,
-			175,
-			215,
-			255
-		];
-		const i = idx - 16;
-		const r = levels[Math.floor(i / 36)];
-		const g = levels[Math.floor(i % 36 / 6)];
-		const b = levels[i % 6];
-		return rgbToHexHash(r, g, b);
-	}
-	const gray = 8 + (idx - 232) * 10;
-	return rgbToHexHash(gray, gray, gray);
-}
-function rgbToHexHash(r, g, b) {
-	const h = (n) => n.toString(16).padStart(2, "0");
-	return `#${h(r)}${h(g)}${h(b)}`;
-}
-function parseHexLocal(hex) {
-	if (typeof hex !== "string") return null;
-	let s = hex.trim();
-	if (s.startsWith("#")) s = s.slice(1);
-	if (s.length === 3) s = s.split("").map((c) => c + c).join("");
-	if (s.length !== 6) return null;
-	const r = parseInt(s.slice(0, 2), 16);
-	const g = parseInt(s.slice(2, 4), 16);
-	const b = parseInt(s.slice(4, 6), 16);
-	if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) return null;
-	return [
-		r,
-		g,
-		b
-	];
-}
-/**
-* Hex-in / hex-out quantization for previews.
-*
-* Takes any hex color and returns the hex a real terminal at that tier would
-* actually emit. Used by the Sterling storybook to make the `1/2/3/4` tier
-* toggle visibly different in-process — the output phase already does this
-* when writing to a real TTY, but preview surfaces (theme swatches, rendered
-* components inside a storybook app) bypass output-phase quantization. Apply
-* `quantizeHex` at render time to mimic tier-specific terminal output.
-*
-*   - `truecolor`: returns the input unchanged (normalized to `#rrggbb`).
-*   - `256`: snaps to the nearest xterm-256 slot, then returns that slot's hex.
-*   - `ansi16`: snaps to one of the 16 standard slots (canonical xterm RGB).
-*   - `mono`: luminance threshold (>= 0.5 → `#ffffff`, else `#000000`).
-*
-* Returns the input unchanged if it cannot be parsed as a hex color.
-*/
-function quantizeHex(hex, tier) {
-	const rgb = parseHexLocal(hex);
-	if (!rgb) return hex;
-	const [r, g, b] = rgb;
-	if (tier === "truecolor") return rgbToHexHash(r, g, b);
-	if (tier === "256") return ansi256ToHex(rgbToAnsi256(r, g, b));
-	if (tier === "ansi16") {
-		const [cr, cg, cb] = ANSI_16_COLORS[nearestAnsi16(r, g, b)];
-		return rgbToHexHash(cr, cg, cb);
-	}
-	return (.2126 * r + .7152 * g + .0722 * b) / 255 >= .5 ? "#ffffff" : "#000000";
-}
-function isHexLeaf$1(value) {
-	return typeof value === "string" && HEX_LEAF_RE$1.test(value);
-}
-/**
-* Pre-quantize every hex leaf in a Theme (or any object tree) to the
-* requested color tier.
-*
-* Walks the input recursively — each string leaf matching `#rgb` / `#rrggbb`
-* is passed through {@link quantizeHex}; all other values (numbers, booleans,
-* non-hex strings like `"Nord"`, null/undefined, arrays of non-hex values)
-* pass through unchanged. Arrays and nested objects are rebuilt with
-* quantized leaves.
-*
-* Works on both the legacy ANSI Theme (flat hex tokens + `palette` array)
-* and the Sterling Theme (nested roles + flat tokens) — the structural rule
-* "any leaf that looks like a hex is a color value" holds for both.
-*
-* @example Pre-cache tier variants
-* ```ts
-* import { pickColorLevel } from "silvery"
-*
-* const themes = {
-*   truecolor: theme,
-*   ansi16: pickColorLevel(theme, "ansi16"),
-*   mono: pickColorLevel(theme, "mono"),
-* }
-* ```
-*
-* @example Storybook — show multiple tiers simultaneously
-* ```tsx
-* <ThemeProvider theme={pickColorLevel(theme, "ansi16")}>
-*   <AlertPreview />
-* </ThemeProvider>
-* ```
-*
-* Notes:
-* - `truecolor` is a no-op — returns the input unchanged (identity).
-* - The result is structurally identical to the input (same keys, same
-*   nesting); only hex leaves are remapped.
-* - Idempotent per tier: `pickColorLevel(pickColorLevel(t, "ansi16"), "ansi16")`
-*   yields the same hex values as `pickColorLevel(t, "ansi16")`.
-* - Does not freeze the returned object. Callers that want immutability
-*   should `Object.freeze()` (or deep-freeze) the result themselves.
-*/
-function pickColorLevel(theme, tier) {
-	if (tier === "truecolor") return theme;
-	return pickColorLevelWalk(theme, tier);
-}
-function pickColorLevelWalk(obj, tier) {
-	if (obj == null) return obj;
-	if (isHexLeaf$1(obj)) return quantizeHex(obj, tier);
-	if (Array.isArray(obj)) return obj.map((v) => pickColorLevelWalk(v, tier));
-	if (typeof obj === "object") {
-		const out = {};
-		for (const [k, v] of Object.entries(obj)) out[k] = pickColorLevelWalk(v, tier);
-		return out;
-	}
-	return obj;
-}
-var MODIFIERS, FG_COLORS, BG_COLORS, ANSI_16_COLORS, ANSI16_SLOT_HEX, HEX_LEAF_RE$1;
-var init_color_maps = __esmMin((() => {
-	MODIFIERS = {
-		reset: [0, 0],
-		bold: [1, 22],
-		dim: [2, 22],
-		italic: [3, 23],
-		underline: [4, 24],
-		inverse: [7, 27],
-		hidden: [8, 28],
-		strikethrough: [9, 29],
-		overline: [53, 55]
-	};
-	FG_COLORS = {
-		black: 30,
-		red: 31,
-		green: 32,
-		yellow: 33,
-		blue: 34,
-		magenta: 35,
-		cyan: 36,
-		white: 37,
-		blackBright: 90,
-		gray: 90,
-		grey: 90,
-		redBright: 91,
-		greenBright: 92,
-		yellowBright: 93,
-		blueBright: 94,
-		magentaBright: 95,
-		cyanBright: 96,
-		whiteBright: 97
-	};
-	BG_COLORS = {
-		bgBlack: 40,
-		bgRed: 41,
-		bgGreen: 42,
-		bgYellow: 43,
-		bgBlue: 44,
-		bgMagenta: 45,
-		bgCyan: 46,
-		bgWhite: 47,
-		bgBlackBright: 100,
-		bgGray: 100,
-		bgGrey: 100,
-		bgRedBright: 101,
-		bgGreenBright: 102,
-		bgYellowBright: 103,
-		bgBlueBright: 104,
-		bgMagentaBright: 105,
-		bgCyanBright: 106,
-		bgWhiteBright: 107
-	};
-	ANSI_16_COLORS = [
-		[
-			0,
-			0,
-			0
-		],
-		[
-			128,
-			0,
-			0
-		],
-		[
-			0,
-			128,
-			0
-		],
-		[
-			128,
-			128,
-			0
-		],
-		[
-			0,
-			0,
-			128
-		],
-		[
-			128,
-			0,
-			128
-		],
-		[
-			0,
-			128,
-			128
-		],
-		[
-			192,
-			192,
-			192
-		],
-		[
-			128,
-			128,
-			128
-		],
-		[
-			255,
-			0,
-			0
-		],
-		[
-			0,
-			255,
-			0
-		],
-		[
-			255,
-			255,
-			0
-		],
-		[
-			0,
-			0,
-			255
-		],
-		[
-			255,
-			0,
-			255
-		],
-		[
-			0,
-			255,
-			255
-		],
-		[
-			255,
-			255,
-			255
-		]
-	];
-	ANSI16_SLOT_HEX = {
-		black: "#000000",
-		red: "#800000",
-		green: "#008000",
-		yellow: "#808000",
-		blue: "#000080",
-		magenta: "#800080",
-		cyan: "#008080",
-		white: "#c0c0c0",
-		blackBright: "#808080",
-		gray: "#808080",
-		grey: "#808080",
-		redBright: "#ff0000",
-		greenBright: "#00ff00",
-		yellowBright: "#ffff00",
-		blueBright: "#0000ff",
-		magentaBright: "#ff00ff",
-		cyanBright: "#00ffff",
-		whiteBright: "#ffffff"
-	};
-	HEX_LEAF_RE$1 = /^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/;
-}));
-//#endregion
-//#region packages/ansi/src/flatten.ts
-function isHexLeaf(value) {
-	return typeof value === "string" && HEX_LEAF_RE.test(value);
-}
-/**
-* Populate flat hyphen-keys onto `theme` in-place by walking hex leaves and
-* asking `rule` where each leaf should also live at the root.
-*
-* Both the nested and flat forms reference the SAME string (not copies) —
-* `bakeFlat({...}).accent.bg === bakeFlat({...})["bg-accent"]`.
-*
-* `rule` defaults to {@link defaultFlattenRule} (channel-role-state).
-* Rules returning `null` for a path skip that leaf — useful for suppressing
-* metadata or implementing partial projections.
-*
-* The returned object is deep-frozen. The input object is mutated in place
-* and returned; callers that want an unfrozen copy should `structuredClone`
-* before calling.
-*
-* @param theme  nested POJO of hex-string leaves (plus optional metadata)
-* @param rule   how to compute flat keys from nested paths
-* @returns      the same object, with flat keys added and frozen
-*/
-function bakeFlat(theme, rule = defaultFlattenRule) {
-	const root = theme;
-	if (Object.isFrozen(root)) return theme;
-	walk(root, [], root, rule);
-	freezeDeep(root);
-	return theme;
-}
-function walk(node, path, root, rule) {
-	for (const key of Object.keys(node)) {
-		if (node === root && key.includes("-")) continue;
-		const value = node[key];
-		const subpath = [...path, key];
-		if (isHexLeaf(value)) {
-			const flatKey = rule(subpath);
-			if (flatKey !== null) root[flatKey] = value;
-			continue;
-		}
-		if (value && typeof value === "object" && !Array.isArray(value)) walk(value, subpath, root, rule);
-	}
-}
-function freezeDeep(o) {
-	if (o === null || typeof o !== "object") return;
-	if (Object.isFrozen(o)) return;
-	Object.freeze(o);
-	for (const k of Object.keys(o)) freezeDeep(o[k]);
-}
-var defaultFlattenRule, HEX_LEAF_RE;
-var init_flatten = __esmMin((() => {
-	defaultFlattenRule = (path) => {
-		if (path.length < 2) return null;
-		const role = path[0];
-		const last = path[path.length - 1];
-		const mid = path.slice(1, -1);
-		if (last === "fgOn") return `fg-on-${role}`;
-		if (last === "fg" || last === "bg" || last === "border") {
-			const state = mid.length > 0 ? mid.join("-") : void 0;
-			return state ? `${last}-${role}-${state}` : `${last}-${role}`;
-		}
-		if (role === "surface") return `bg-surface-${last}`;
-		if (role === "border") return `border-${last}`;
-		return null;
-	};
-	HEX_LEAF_RE = /^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?([0-9a-fA-F]{2})?$/;
-}));
-//#endregion
-//#region packages/ansi/src/terminal-control.ts
-/**
-* Enable mouse tracking with full hover support.
-*
-* Uses two modes:
-* - **1003** (any-event tracking): Reports ALL mouse motion — clicks, drags, AND hover.
-*   This is what makes onMouseEnter/onMouseLeave work. Without it, only clicks are reported.
-* - **1006** (SGR encoding): Decimal coordinates with no 223-column limit.
-*
-* WARNING: Do NOT replace 1003 with 1000+1002. The xterm mouse modes form a hierarchy:
-*   1000 = clicks only
-*   1002 = clicks + drag (motion while button held)
-*   1003 = clicks + drag + hover (ALL motion, even without button)
-* Mode 1003 supersedes 1000 and 1002. Using 1000+1002 instead of 1003 silently
-* disables hover — onMouseEnter/onMouseLeave stop firing with no error.
-*/
-function enableMouse() {
-	return `${CSI$1}?1003h${CSI$1}?1006h`;
-}
-/**
-* Disable mouse tracking. Disables in reverse order of enabling.
-*/
-function disableMouse() {
-	return `${CSI$1}?1006l${CSI$1}?1003l`;
-}
-/**
-* Enable the Kitty keyboard protocol (push mode).
-*
-* Sends CSI > flags u to opt into the specified modes.
-* Supported by: Ghostty, Kitty, WezTerm, foot. Ignored by unsupported terminals.
-*
-* Flags are a bitfield:
-*
-* | Flag | Bit | Description                               |
-* | ---- | --- | ----------------------------------------- |
-* | 1    | 0   | Disambiguate escape codes                 |
-* | 2    | 1   | Report event types (press/repeat/release)  |
-* | 4    | 2   | Report alternate keys                     |
-* | 8    | 3   | Report all keys as escape codes           |
-* | 16   | 4   | Report associated text                    |
-*
-* @param flags Bitfield of Kitty keyboard flags
-*/
-function enableKittyKeyboard(flags = 1) {
-	return `${CSI$1}>${flags}u`;
-}
-/**
-* Disable the Kitty keyboard protocol (pop mode stack).
-* Sends CSI < u to restore the previous keyboard mode.
-*/
-function disableKittyKeyboard() {
-	return `${CSI$1}<u`;
-}
-var ESC$3, CSI$1;
-var init_terminal_control = __esmMin((() => {
-	ESC$3 = "\x1B";
-	CSI$1 = `${ESC$3}[`;
-	`${ESC$3}`;
-}));
-//#endregion
-//#region packages/ansi/src/kitty-graphics.ts
-/**
-* Derive a stable placement ID for a given (x, y) cell. Max column = 9999,
-* which comfortably exceeds any realistic terminal width.
-*/
-function backdropPlacementId(x, y) {
-	return x * BACKDROP_PLACEMENT_X_STRIDE + y + 1;
-}
-/**
-* Encode a Uint8Array as base64. Kitty expects standard base64 (with `+`/`/`
-* and `=` padding). We use Buffer when available (Node/Bun), fall back to
-* btoa for browser/canvas adapters (the canvas target may never actually
-* need to emit Kitty escapes — this is just defensive).
-*/
-function base64Encode(bytes) {
-	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
-	let binary = "";
-	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-	const g = globalThis;
-	if (typeof g.btoa === "function") return g.btoa(binary);
-	throw new Error("base64 encoding unavailable in this environment");
-}
-/**
-* Build a tiny RGBA pixel grid for the scrim overlay.
-*
-* Kitty's graphics protocol paints images at native pixel resolution scaled
-* to `c` x `r` cells. A 2x2 RGBA image scaled to a single cell (~10x20 px
-* depending on font) gives us a smooth fill. We intentionally keep the
-* image tiny to minimize base64 payload size on the upload frame.
-*
-* Pixel color: `(r, g, b, a)` where `r/g/b` is the scrim tint and `a` is the
-* alpha (0-255). For a dark backdrop we use near-black at ~50% alpha, which
-* darkens the emoji underneath without completely hiding it.
-*
-* Width/height = 2 pixels — 16 bytes total, ~24 bytes base64. Upload is ~60
-* bytes including control chars. One-time cost per modal session.
-*/
-function buildScrimPixels(tint, alpha) {
-	const a = Math.max(0, Math.min(255, Math.round(alpha)));
-	const r = Math.max(0, Math.min(255, Math.round(tint.r)));
-	const g = Math.max(0, Math.min(255, Math.round(tint.g)));
-	const b = Math.max(0, Math.min(255, Math.round(tint.b)));
-	const bytes = new Uint8Array(16);
-	for (let i = 0; i < 4; i++) {
-		bytes[i * 4 + 0] = r;
-		bytes[i * 4 + 1] = g;
-		bytes[i * 4 + 2] = b;
-		bytes[i * 4 + 3] = a;
-	}
-	return bytes;
-}
-/**
-* APC wrapper: `\x1b_G<control>[;<payload>]\x1b\\`.
-*
-* The protocol allows chunking large payloads via `m=1` but our scrim is
-* tiny — always fits in one chunk.
-*/
-function apc(control, payload) {
-	if (payload === void 0 || payload === "") return `\x1b_G${control}\x1b\\`;
-	return `\x1b_G${control};${payload}\x1b\\`;
-}
-/**
-* Emit a one-shot image upload. Terminal stores the RGBA pixels under
-* `i=<imageId>` and keeps them until explicitly freed. Subsequent placements
-* reference the image by ID without re-sending pixel data.
-*
-* `q=2` suppresses the terminal's OK/error reply — otherwise we'd see stray
-* APC sequences back on stdin.
-*/
-function kittyUploadScrimImage(pixels, width, height, imageId = BACKDROP_SCRIM_IMAGE_ID) {
-	const payload = base64Encode(pixels);
-	return apc(`a=t,f=32,s=${width},v=${height},i=${imageId},q=2`, payload);
-}
-/**
-* Emit a cell placement. Places `imageId` at the current cursor position
-* covering `c` cols and `r` rows with z-index `z`. `C=1` prevents the cursor
-* from advancing after placement (critical — otherwise every placement
-* shifts the cursor, breaking the caller's positioning).
-*
-* Placement ID (`p=<pid>`) is stable per cell so incremental frames can
-* replace placements without accumulating duplicates.
-*/
-function kittyPlaceAt(opts) {
-	const imageId = opts.imageId ?? 48879;
-	const cols = opts.cols ?? 1;
-	const rows = opts.rows ?? 1;
-	const z = opts.z ?? 1;
-	return apc(`a=p,i=${imageId},p=${opts.placementId},c=${cols},r=${rows},z=${z},C=1,q=2`);
-}
-/**
-* Delete ALL placements of our scrim image without freeing the image.
-* Used when the modal closes — we leave the image cached in case another
-* modal opens, but remove every overlay cell at once.
-*/
-function kittyDeleteAllScrimPlacements(imageId = BACKDROP_SCRIM_IMAGE_ID) {
-	return apc(`a=d,d=i,i=${imageId},q=2`);
-}
-/**
-* Absolute cursor position (CUP). 1-based row/col per VT100.
-*
-* Used to position the cursor before emitting a placement so the placement
-* lands in the right cell. Kept small and local — the rest of the pipeline
-* uses more elaborate cursor tracking, but for out-of-band overlay emission
-* we just want a deterministic "jump here, place, done."
-*/
-function cupTo(col, row) {
-	return `\x1b[${row + 1};${col + 1}H`;
-}
-var BACKDROP_SCRIM_IMAGE_ID, BACKDROP_PLACEMENT_X_STRIDE;
-var init_kitty_graphics = __esmMin((() => {
-	BACKDROP_SCRIM_IMAGE_ID = 48879;
-	BACKDROP_PLACEMENT_X_STRIDE = 1e4;
-}));
-//#endregion
-//#region packages/ansi/src/style/colors.ts
-var THEME_TOKEN_DEFAULTS;
-var init_colors = __esmMin((() => {
-	init_color_maps();
-	THEME_TOKEN_DEFAULTS = {
-		primary: 33,
-		secondary: 36,
-		accent: 35,
-		error: 31,
-		warning: 33,
-		success: 32,
-		info: 36,
-		muted: 2,
-		link: 34,
-		border: 90,
-		surface: 37
-	};
-}));
-//#endregion
-//#region packages/ansi/src/style/style.ts
-/**
-* Resolve a color value against a theme — the canonical token resolver.
-*
-* If the color starts with `$`, looks up the token in the theme.
-* Supports `$primary`, `$surface-bg` (hyphens stripped), `$color0`–`$color15` (palette).
-* Non-`$` strings pass through unchanged. Returns undefined if no theme or unknown token.
-*
-* Compatible with @silvery/theme's Theme type (or any object with string properties).
-*/
-function resolveThemeColor(name, theme) {
-	if (!name) return void 0;
-	if (!name.startsWith("$")) return name;
-	if (!theme) return void 0;
-	return resolveToken(name, theme);
-}
-/** Internal: resolve a token name (with or without $ prefix) against a theme.
-*
-* Resolution order:
-*   1. Direct key lookup — finds Sterling flat keys (`bg-accent`,
-*      `fg-on-error`, `border-focus`, …) and legacy kebab keys
-*      (`primary-hover`, `fg-hover`, `bg-surface-hover`) and plain names
-*      (`bg`, `primary`, `muted`).
-*   2. No-hyphen fallback — `$surface-bg` → `theme.surfacebg`,
-*      `$focus-border` → `theme.focusborder`.
-*
-* The old `LEGACY_ALIASES` table (e.g. `fgmuted` → `muted`, `bgsurface` →
-* `surfacebg`) was removed in 0.18.1 once every shipped default Theme ships
-* with Sterling flat tokens baked in — `theme["fg-muted"]` and
-* `theme["bg-surface-subtle"]` are direct fields now, so no alias fallback
-* is required for canonical Sterling tokens. Tokens that existed only as
-* aliases (e.g. `$bg-surface`, `$fg-on-primary`, `$border-input`,
-* `$fg-disabled`) no longer resolve — callers should use the canonical
-* Sterling equivalents (`$bg-surface-default`, `$fg-on-accent`,
-* `$border-default`, `$fg-muted`).
-*/
-function resolveToken(name, theme) {
-	if (!theme) return void 0;
-	const token = name.startsWith("$") ? name.slice(1) : name;
-	if (token.startsWith("color")) {
-		const idx = parseInt(token.slice(5), 10);
-		if (idx >= 0 && idx < 16 && theme.palette && idx < theme.palette.length) return theme.palette[idx];
-	}
-	const themeObj = theme;
-	const direct = themeObj[token];
-	if (typeof direct === "string") return direct;
-	const noHyphen = token.replace(/-/g, "");
-	if (noHyphen !== token) {
-		const stripped = themeObj[noHyphen];
-		if (typeof stripped === "string") return stripped;
-	}
-}
-/** Convert chalk numeric level (0-3) to ColorLevel. */
-function fromChalkLevel(n) {
-	if (n <= 0) return null;
-	if (n === 1) return "basic";
-	if (n === 2) return "256";
-	return "truecolor";
-}
-/** Convert ColorLevel to chalk numeric level (0-3). */
-function toChalkLevel(cl) {
-	if (cl === null) return 0;
-	if (cl === "basic") return 1;
-	if (cl === "256") return 2;
-	return 3;
-}
-/**
-* Create a style object for terminal output.
-*
-* @param options - Color level and optional theme
-* @returns A chainable style object (chalk-compatible API)
-*
-* @example
-* ```ts
-* import { createStyle } from "@silvery/ansi"
-*
-* const s = createStyle()
-* console.log(s.bold.red("Error!"))
-* console.log(s.hex("#818cf8")("Indigo"))
-*
-* // With theme
-* const s = createStyle({ theme })
-* console.log(s.primary("Deploy"))
-* console.log(s.success("Done"))
-* ```
-*/
-function createStyle(options) {
-	const ref = {
-		level: null,
-		theme: options?.theme
-	};
-	if (options?.level !== void 0) ref.level = options.level;
-	else try {
-		ref.level = detectColor(process.stdout);
-	} catch {
-		ref.level = null;
-	}
-	return createChainWithRef({
-		opens: [],
-		closes: []
-	}, ref);
-}
-/**
-* Create a chain that reads level from a mutable ref.
-* This allows `style.level = 3` to affect all subsequent calls.
-*/
-function createChainWithRef(state, ref) {
-	const proxyRef = { proxy: null };
-	const handler = {
-		apply(_target, _thisArg, args) {
-			const level = ref.level;
-			if (state.visible && level === null) return "";
-			let text;
-			if (args.length === 0) text = "";
-			else if (Array.isArray(args[0]) && "raw" in args[0]) text = String.raw(args[0], ...args.slice(1));
-			else if (args.length > 1) text = args.map((a) => String(a ?? "")).join(" ");
-			else text = String(args[0] ?? "");
-			if (text === "") return "";
-			if (level === null || state.opens.length === 0) return text;
-			const open = `${ESC$2}${state.opens.join(";")}m`;
-			const close = `${ESC$2}${state.closes.join(";")}m`;
-			for (const closeCode of state.closes) {
-				const closeSeq = `${ESC$2}${closeCode}m`;
-				const parts = text.split(closeSeq);
-				if (parts.length > 1) text = parts.join(`${closeSeq}${open}`);
-			}
-			if (text.includes("\n")) text = text.replace(/\r?\n/g, `${close}$&${open}`);
-			return `${open}${text}${close}`;
-		},
-		get(_target, prop) {
-			if (typeof prop === "symbol") return void 0;
-			if (prop === "level") return toChalkLevel(ref.level);
-			if (prop === "resolve") return (token) => resolveToken(token, ref.theme);
-			if (prop === "visible") return createChainWithRef({
-				...state,
-				visible: true
-			}, ref);
-			if (prop === "call" || prop === "apply" || prop === "bind") return Function.prototype[prop].bind(proxyRef.proxy);
-			const level = ref.level;
-			if (prop === "hex" || prop === "bgHex") return (color) => {
-				if (level === null) return createChainWithRef(state, ref);
-				const rgb = hexToRgb$1(color);
-				if (!rgb) return createChainWithRef(state, ref);
-				const code = prop === "hex" ? fgFromRgb(rgb[0], rgb[1], rgb[2], level) : bgFromRgb(rgb[0], rgb[1], rgb[2], level);
-				const close = prop === "hex" ? "39" : "49";
-				return createChainWithRef({
-					opens: [...state.opens, code],
-					closes: [...state.closes, close]
-				}, ref);
-			};
-			if (prop === "rgb" || prop === "bgRgb") return (r, g, b) => {
-				if (level === null) return createChainWithRef(state, ref);
-				const code = prop === "rgb" ? fgFromRgb(r, g, b, level) : bgFromRgb(r, g, b, level);
-				const close = prop === "rgb" ? "39" : "49";
-				return createChainWithRef({
-					opens: [...state.opens, code],
-					closes: [...state.closes, close]
-				}, ref);
-			};
-			if (prop === "ansi256") return (code) => {
-				if (level === null) return createChainWithRef(state, ref);
-				return createChainWithRef({
-					opens: [...state.opens, `38;5;${code}`],
-					closes: [...state.closes, "39"]
-				}, ref);
-			};
-			if (prop === "bgAnsi256") return (code) => {
-				if (level === null) return createChainWithRef(state, ref);
-				return createChainWithRef({
-					opens: [...state.opens, `48;5;${code}`],
-					closes: [...state.closes, "49"]
-				}, ref);
-			};
-			if (prop in MODIFIERS) {
-				if (level === null) return createChainWithRef(state, ref);
-				const [open, close] = MODIFIERS[prop];
-				return createChainWithRef({
-					opens: [...state.opens, String(open)],
-					closes: [...state.closes, String(close)]
-				}, ref);
-			}
-			if (prop in FG_COLORS) {
-				if (level === null) return createChainWithRef(state, ref);
-				return createChainWithRef({
-					opens: [...state.opens, String(FG_COLORS[prop])],
-					closes: [...state.closes, "39"]
-				}, ref);
-			}
-			if (prop in BG_COLORS) {
-				if (level === null) return createChainWithRef(state, ref);
-				return createChainWithRef({
-					opens: [...state.opens, String(BG_COLORS[prop])],
-					closes: [...state.closes, "49"]
-				}, ref);
-			}
-			if (THEME_TOKENS.has(prop)) {
-				if (level === null) return createChainWithRef(state, ref);
-				const hex = resolveToken(prop, ref.theme);
-				if (hex) {
-					const rgb = hexToRgb$1(hex);
-					if (rgb) {
-						const code = fgFromRgb(rgb[0], rgb[1], rgb[2], level);
-						if (prop === "link") return createChainWithRef({
-							opens: [
-								...state.opens,
-								code,
-								"4"
-							],
-							closes: [
-								...state.closes,
-								"39",
-								"24"
-							]
-						}, ref);
-						return createChainWithRef({
-							opens: [...state.opens, code],
-							closes: [...state.closes, "39"]
-						}, ref);
-					}
-				}
-				const fallback = THEME_TOKEN_DEFAULTS[prop];
-				if (fallback !== void 0) {
-					if (prop === "muted") return createChainWithRef({
-						opens: [...state.opens, String(fallback)],
-						closes: [...state.closes, "22"]
-					}, ref);
-					if (prop === "link") return createChainWithRef({
-						opens: [
-							...state.opens,
-							String(fallback),
-							"4"
-						],
-						closes: [
-							...state.closes,
-							"39",
-							"24"
-						]
-					}, ref);
-					return createChainWithRef({
-						opens: [...state.opens, String(fallback)],
-						closes: [...state.closes, "39"]
-					}, ref);
-				}
-			}
-		},
-		set(_target, prop, value) {
-			if (prop === "level") {
-				ref.level = fromChalkLevel(value);
-				return true;
-			}
-			return false;
-		},
-		has(_target, prop) {
-			if (prop === "level") return true;
-			if (typeof prop === "symbol") return false;
-			return prop in MODIFIERS || prop in FG_COLORS || prop in BG_COLORS || THEME_TOKENS.has(prop) || KNOWN_METHODS.has(prop);
-		}
-	};
-	const target = function() {};
-	const proxy = new Proxy(target, handler);
-	proxyRef.proxy = proxy;
-	return proxy;
-}
-var ESC$2, KNOWN_METHODS, THEME_TOKENS;
-var init_style = __esmMin((() => {
-	init_detection();
-	init_colors();
-	ESC$2 = "\x1B[";
-	KNOWN_METHODS = new Set([
-		"hex",
-		"rgb",
-		"bgHex",
-		"bgRgb",
-		"ansi256",
-		"bgAnsi256",
-		"resolve"
-	]);
-	THEME_TOKENS = new Set([
-		"primary",
-		"secondary",
-		"accent",
-		"error",
-		"warning",
-		"success",
-		"info",
-		"muted",
-		"link",
-		"border",
-		"surface"
-	]);
-	createStyle();
-}));
-//#endregion
-//#region packages/ansi/src/style/mixed-proxy.ts
-/**
-* Create a proxy that wraps a style instance with additional properties.
-*
-* The proxy makes the result:
-* - Callable: result('text') applies current styles
-* - Chainable: result.bold.red('text') chains styles
-* - Extended: result.anyExtraProp accesses extra properties
-*
-* Extra properties take priority over style properties on name collision.
-*/
-function createMixedStyle(style, extra) {
-	return createChainProxy(style, extra);
-}
-/**
-* Internal recursive proxy builder for style chain + extra properties.
-*/
-function createChainProxy(currentStyle, extra) {
-	const handler = {
-		apply(_target, _thisArg, args) {
-			return currentStyle(...args);
-		},
-		get(_target, prop) {
-			if (prop in extra) {
-				const value = extra[prop];
-				if (typeof value === "function") return value;
-				return value;
-			}
-			if (typeof prop === "symbol") {
-				if (prop === Symbol.dispose) return extra[Symbol.dispose];
-				return;
-			}
-			if (STYLE_METHODS.has(prop)) {
-				const method = currentStyle[prop];
-				if (typeof method === "function") return (...args) => {
-					return createChainProxy(method.apply(currentStyle, args), extra);
-				};
-			}
-			const styleProp = currentStyle[prop];
-			if (styleProp !== void 0) {
-				if (typeof styleProp === "function" || typeof styleProp === "object") return createChainProxy(styleProp, extra);
-				return styleProp;
-			}
-		},
-		set(_target, prop, value) {
-			extra[prop] = value;
-			return true;
-		},
-		defineProperty(_target, prop, descriptor) {
-			Object.defineProperty(extra, prop, descriptor);
-			return true;
-		},
-		has(_target, prop) {
-			if (prop in extra) return true;
-			if (typeof prop === "string" && prop in currentStyle) return true;
-			return false;
-		}
-	};
-	const proxyTarget = function() {};
-	return new Proxy(proxyTarget, handler);
-}
-var STYLE_METHODS;
-var init_mixed_proxy = __esmMin((() => {
-	STYLE_METHODS = new Set([
-		"hex",
-		"bgHex",
-		"rgb",
-		"bgRgb",
-		"ansi256",
-		"bgAnsi256"
-	]);
-}));
-//#endregion
-//#region packages/ansi/src/theme/invariants.ts
-/**
-* Theme invariants — post-derivation visibility + optional WCAG checks.
-*
-* Two independent invariant groups:
-*
-* 1. **Visibility (always checked)** — selection and cursor must be
-*    distinguishable from bg. These fail silently because ensureContrast
-*    doesn't touch `bg-selected`/`bg-cursor`; you get "invisible selection"
-*    bugs that only surface via user complaints.
-*
-* 2. **WCAG contrast (opt-in)** — `deriveTheme()` already runs `ensureContrast`
-*    on every text/bg pair as it builds the Theme (lenient auto-adjust). A
-*    second validation pass is redundant for normal use. Enable it explicitly
-*    at build time to *verify* that shipped themes meet the targets, or when
-*    loading a hand-authored Theme object that skipped `deriveTheme`.
-*
-* This is why `validateThemeInvariants` defaults to `{ wcag: false }` — the
-* existing derivation already handles contrast. Callers opt in via
-* `validateThemeInvariants(theme, { wcag: true })` for strict pre-ship audits.
-*
-* All token access is Sterling-shaped — flat hyphen keys (`bg-accent`,
-* `fg-on-error`, `border-focus`) exist on every Theme via the derive +
-* bakeFlat pipeline. No concat-kebab legacy names (`primaryfg`, `mutedbg`, …)
-* — those were removed in silvery 0.19.0 (Sterling interior migration).
-*/
-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) {
-		const themeRecord = theme;
-		for (const pair of CONTRAST_PAIRS) {
-			const fg = themeRecord[pair.fg];
-			const bg = themeRecord[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: [pair.fg, 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 themeAny = theme;
-		const selectionBg = themeAny["bg-selected"] ?? themeAny["selectionbg"] ?? "";
-		const cursorBg = themeAny["bg-cursor"] ?? themeAny["cursorbg"] ?? "";
-		const selectionKey = themeAny["bg-selected"] !== void 0 ? "bg-selected" : "selectionbg";
-		const cursorKey = themeAny["bg-cursor"] !== void 0 ? "bg-cursor" : "cursorbg";
-		const lBg = lightness(theme.bg);
-		const lSelBg = lightness(selectionBg);
-		if (lBg !== null && lSelBg !== null) {
-			const dL = Math.abs(lSelBg - lBg);
-			if (dL < .08) violations.push({
-				rule: "visibility:selection",
-				tokens: [selectionKey, "bg"],
-				actual: dL,
-				required: SELECTION_DELTA_L,
-				message: `${selectionKey} (${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(cursorBg);
-		if (oBg && oCursorBg) {
-			const de = deltaE(oBg, oCursorBg);
-			if (de < .15) violations.push({
-				rule: "visibility:cursor",
-				tokens: [cursorKey, "bg"],
-				actual: de,
-				required: CURSOR_DELTA_E,
-				message: `${cursorKey} (${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((() => {
-	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/bg-surface-subtle",
-			fg: "fg",
-			bg: "bg-surface-subtle",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-surface-overlay",
-			fg: "fg",
-			bg: "bg-surface-overlay",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-muted/bg-muted",
-			fg: "fg-muted",
-			bg: "bg-muted",
-			min: 3
-		},
-		{
-			rule: "contrast:fg-accent/bg",
-			fg: "fg-accent",
-			bg: "bg",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-error/bg",
-			fg: "fg-error",
-			bg: "bg",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-warning/bg",
-			fg: "fg-warning",
-			bg: "bg",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-success/bg",
-			fg: "fg-success",
-			bg: "bg",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-info/bg",
-			fg: "fg-info",
-			bg: "bg",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-on-accent/bg-accent",
-			fg: "fg-on-accent",
-			bg: "bg-accent",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-on-error/bg-error",
-			fg: "fg-on-error",
-			bg: "bg-error",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-on-warning/bg-warning",
-			fg: "fg-on-warning",
-			bg: "bg-warning",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-on-success/bg-success",
-			fg: "fg-on-success",
-			bg: "bg-success",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-on-info/bg-info",
-			fg: "fg-on-info",
-			bg: "bg-info",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-on-selected/bg-selected",
-			fg: "fg-on-selected",
-			bg: "bg-selected",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-cursor/bg-cursor",
-			fg: "fg-cursor",
-			bg: "bg-cursor",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:border-default/bg",
-			fg: "border-default",
-			bg: "bg",
-			min: 3
-		},
-		{
-			rule: "contrast:border-focus/bg",
-			fg: "border-focus",
-			bg: "bg",
-			min: 3
-		},
-		{
-			rule: "contrast:border-muted/bg",
-			fg: "border-muted",
-			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/derived.ts
-/**
-* deriveFields — single helper that fills all derived theme sections.
-*
-* Eliminates 4-way duplication of brand, categorical ring, state-variant, and
-* variants population across:
-*   - derive.ts   (deriveTruecolorTheme + deriveAnsi16Theme)
-*   - default-schemes.ts (ansi16DarkTheme + ansi16LightTheme)
-*   - @silvery/theme/generate.ts   (generateTheme)
-*   - @silvery/theme/schemes/index.ts (ansi16DarkTheme + ansi16LightTheme)
-*
-* Canonical authority: derive.ts truecolor path. ANSI16 paths are aligned to
-* deriveAnsi16Theme output (which is itself the canonical ANSI16 reference).
-*/
-/**
-* Derive the shared "delta" fields common to every theme object:
-* brand tokens, categorical ring, state variants, and typography variants.
-*
-* Pass a `shift` function for truecolor hover/active derivation (OKLCH
-* brighten/darken). Omit `shift` for ANSI16 — hover/active fall back to the
-* base color (no intermediate intensities available on 16-color terminals).
-*
-* @example
-* // Truecolor (dark theme)
-* import { brighten, darken } from "@silvery/color"
-* deriveFields({ shift: (hex, a) => brighten(hex, a), primary, ... })
-*
-* @example
-* // ANSI16 — no shift function
-* deriveFields({ primary, accent, fg, selectionbg, surfacebg, ring })
-*/
-function deriveFields(input) {
-	const { dark, shift, primary, accent, fg, selectionbg, surfacebg, ring } = input;
-	const applyShift = dark !== void 0 ? (color, amount) => dark ? brighten(color, amount) : darken(color, amount) : shift ?? ((color, _amount) => color);
-	return {
-		brand: primary,
-		"brand-hover": applyShift(primary, .04),
-		"brand-active": applyShift(primary, .08),
-		...ring,
-		"primary-hover": applyShift(primary, .04),
-		"primary-active": applyShift(primary, .08),
-		"accent-hover": applyShift(accent, .04),
-		"accent-active": applyShift(accent, .08),
-		"fg-hover": applyShift(fg, .04),
-		"fg-active": applyShift(fg, .08),
-		"bg-selected-hover": applyShift(selectionbg, .04),
-		"bg-surface-hover": applyShift(surfacebg, .04),
-		variants: DEFAULT_VARIANTS
-	};
-}
-var DEFAULT_VARIANTS;
-var init_derived = __esmMin((() => {
-	DEFAULT_VARIANTS = {
-		h1: {
-			color: "$primary",
-			bold: true
-		},
-		h2: {
-			color: "$accent",
-			bold: true
-		},
-		h3: { bold: true },
-		body: {},
-		"body-muted": { color: "$muted" },
-		"fine-print": {
-			color: "$muted",
-			dim: true
-		},
-		strong: { bold: true },
-		em: { italic: true },
-		link: {
-			color: "$link",
-			underlineStyle: "single"
-		},
-		key: {
-			color: "$accent",
-			bold: true
-		},
-		code: { backgroundColor: "$mutedbg" },
-		kbd: {
-			backgroundColor: "$mutedbg",
-			color: "$accent",
-			bold: true
-		}
-	};
-}));
-//#endregion
-//#region packages/ansi/src/theme/derive.ts
-/**
-* Theme derivation — transforms a ColorScheme into a Theme.
-*/
-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;
-	function ensure(token, color, against, target) {
-		const result = ensureContrast(color, against, target);
-		if (adjustments && result !== color) {
-			const before = checkContrast(color, against);
-			const after = checkContrast(result, against);
-			adjustments.push({
-				token,
-				from: color,
-				to: result,
-				against,
-				target,
-				ratioBefore: before?.ratio ?? 0,
-				ratioAfter: after?.ratio ?? 0
-			});
-		}
-		return result;
-	}
-	const surfacebg = blend(bg, p.foreground, .05);
-	const popoverbg = blend(bg, p.foreground, .08);
-	const fg = ensure("fg", p.foreground, popoverbg, AA);
-	const primary = ensure("primary", p.primary ?? (dark ? p.yellow : p.blue), bg, AA);
-	const accent = ensure("accent", complement(primary), bg, AA);
-	const secondary = ensure("secondary", blend(primary, accent, .35), bg, AA);
-	const error = ensure("error", p.red, bg, AA);
-	const warning = ensure("warning", p.yellow, bg, AA);
-	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 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 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);
-	const derived = deriveFields({
-		dark,
-		primary,
-		accent,
-		fg,
-		selectionbg: selectionBg,
-		surfacebg,
-		ring: {
-			red,
-			orange,
-			yellow,
-			green,
-			teal,
-			blue,
-			purple,
-			pink
-		}
-	});
-	return {
-		name: p.name ?? (dark ? "derived-dark" : "derived-light"),
-		bg,
-		fg,
-		muted,
-		mutedbg,
-		surface: fg,
-		surfacebg,
-		popover: fg,
-		popoverbg,
-		inverse: contrastFg(blend(fg, bg, .1)),
-		inversebg: blend(fg, bg, .1),
-		cursor,
-		cursorbg: cursorBgRepaired,
-		selection,
-		selectionbg: selectionBg,
-		primary,
-		primaryfg: contrastFg(primary),
-		secondary,
-		secondaryfg: contrastFg(secondary),
-		accent,
-		accentfg: contrastFg(accent),
-		error,
-		errorfg: contrastFg(error),
-		warning,
-		warningfg: contrastFg(warning),
-		success,
-		successfg: contrastFg(success),
-		info,
-		infofg: contrastFg(info),
-		border,
-		inputborder,
-		focusborder: link,
-		link,
-		disabledfg,
-		palette: [
-			p.black,
-			p.red,
-			p.green,
-			p.yellow,
-			p.blue,
-			p.magenta,
-			p.cyan,
-			p.white,
-			p.brightBlack,
-			p.brightRed,
-			p.brightGreen,
-			p.brightYellow,
-			p.brightBlue,
-			p.brightMagenta,
-			p.brightCyan,
-			p.brightWhite
-		],
-		...derived
-	};
-}
-function deriveAnsi16Theme(p) {
-	const dark = p.dark ?? true;
-	const primaryColor = dark ? p.yellow : p.blue;
-	const accentColor = p.cyan;
-	const derived = deriveFields({
-		primary: primaryColor,
-		accent: accentColor,
-		fg: p.foreground,
-		selectionbg: p.selectionBackground,
-		surfacebg: p.black,
-		ring: {
-			red: dark ? p.brightRed : p.red,
-			orange: dark ? p.brightRed : p.red,
-			yellow: p.yellow,
-			green: dark ? p.brightGreen : p.green,
-			teal: p.cyan,
-			blue: dark ? p.brightBlue : p.blue,
-			purple: p.magenta,
-			pink: dark ? p.brightMagenta : p.magenta
-		}
-	});
-	return {
-		name: p.name ?? (dark ? "derived-ansi16-dark" : "derived-ansi16-light"),
-		bg: p.background,
-		fg: p.foreground,
-		muted: p.white,
-		mutedbg: p.black,
-		surface: p.foreground,
-		surfacebg: p.black,
-		popover: p.foreground,
-		popoverbg: p.black,
-		inverse: p.black,
-		inversebg: p.brightWhite,
-		cursor: p.cursorText,
-		cursorbg: p.cursorColor,
-		selection: p.selectionForeground,
-		selectionbg: p.selectionBackground,
-		primary: primaryColor,
-		primaryfg: p.black,
-		secondary: p.magenta,
-		secondaryfg: p.black,
-		accent: accentColor,
-		accentfg: p.black,
-		error: dark ? p.brightRed : p.red,
-		errorfg: p.black,
-		warning: p.yellow,
-		warningfg: p.black,
-		success: dark ? p.brightGreen : p.green,
-		successfg: p.black,
-		info: p.cyan,
-		infofg: p.black,
-		border: p.brightBlack,
-		inputborder: p.brightBlack,
-		focusborder: dark ? p.brightBlue : p.blue,
-		link: dark ? p.brightBlue : p.blue,
-		disabledfg: p.brightBlack,
-		palette: [
-			p.black,
-			p.red,
-			p.green,
-			p.yellow,
-			p.blue,
-			p.magenta,
-			p.cyan,
-			p.white,
-			p.brightBlack,
-			p.brightRed,
-			p.brightGreen,
-			p.brightYellow,
-			p.brightBlue,
-			p.brightMagenta,
-			p.brightCyan,
-			p.brightWhite
-		],
-		...derived
-	};
-}
-/**
-* 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_invariants();
-	init_derived();
-	AA = 4.5;
-	DIM = 3;
-	FAINT = 1.5;
-	CONTROL = 3;
-}));
-//#endregion
-//#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 looks the name up directly against `DEFAULT_MONO_ATTRS`,
-* which carries both legacy keys (`muted`, `surfacebg`, `focusborder`, …) AND
-* Sterling flat tokens (`fg-muted`, `bg-surface-default`, `border-focus`, …)
-* as first-class entries. Returns `undefined` for non-token strings (hex,
-* rgb(), named ANSI colors) — callers should treat this as "no attrs".
-*
-* A secondary no-hyphen fallback (`$surface-bg` → `surfacebg`) keeps the
-* legacy hyphenated-compound form working for callers that still emit that
-* shape.
-*
-* @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 name = color.slice(1);
-	const attrs = deriveMonochromeTheme(theme);
-	const direct = attrs[name];
-	if (direct !== void 0) return direct;
-	const noHyphen = name.replace(/-/g, "");
-	if (noHyphen !== name) {
-		const stripped = attrs[noHyphen];
-		if (stripped !== void 0) return stripped;
-	}
-}
-var DEFAULT_MONO_ATTRS;
-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: [],
-		"fg-muted": ["dim"],
-		"bg-muted": [],
-		"fg-accent": ["italic", "bold"],
-		"bg-accent": [],
-		"fg-on-accent": [],
-		"border-accent": [],
-		"fg-accent-hover": ["italic", "bold"],
-		"bg-accent-hover": [],
-		"fg-accent-active": ["italic", "bold"],
-		"bg-accent-active": [],
-		"fg-info": ["italic"],
-		"bg-info": [],
-		"fg-on-info": [],
-		"bg-info-hover": [],
-		"bg-info-active": [],
-		"fg-success": ["bold"],
-		"bg-success": [],
-		"fg-on-success": [],
-		"bg-success-hover": [],
-		"bg-success-active": [],
-		"fg-warning": ["bold"],
-		"bg-warning": [],
-		"fg-on-warning": [],
-		"bg-warning-hover": [],
-		"bg-warning-active": [],
-		"fg-error": ["bold", "inverse"],
-		"bg-error": [],
-		"fg-on-error": ["inverse"],
-		"bg-error-hover": [],
-		"bg-error-active": [],
-		"bg-surface-default": [],
-		"bg-surface-subtle": [],
-		"bg-surface-raised": [],
-		"bg-surface-overlay": [],
-		"bg-surface-hover": [],
-		"border-default": [],
-		"border-focus": ["bold"],
-		"border-muted": [],
-		"fg-cursor": [],
-		"bg-cursor": []
-	};
-}));
-//#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((() => {
-	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 defaultDarkScheme, defaultLightScheme, ansi16DarkTheme, ansi16LightTheme;
-var init_default_schemes = __esmMin((() => {
-	init_derive();
-	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"
-	};
-	ansi16DarkTheme = deriveAnsi16Theme(defaultDarkScheme);
-	ansi16LightTheme = deriveAnsi16Theme(defaultLightScheme);
-}));
-//#endregion
-//#region packages/ansi/src/osc-palette.ts
-function queryPaletteColor(index, write) {
-	if (index < 0 || index > 255) throw new RangeError(`Palette index must be 0-255, got ${index}`);
-	write(`${ESC$1}]4;${index};?${BEL$1}`);
-}
-function queryMultiplePaletteColors(indices, write) {
-	for (const index of indices) queryPaletteColor(index, write);
-}
-function setPaletteColor(index, color, write) {
-	if (index < 0 || index > 255) throw new RangeError(`Palette index must be 0-255, got ${index}`);
-	write(`${ESC$1}]4;${index};${color}${BEL$1}`);
-}
-function parsePaletteResponse(input) {
-	const prefixIdx = input.indexOf(OSC4_PREFIX);
-	if (prefixIdx === -1) return null;
-	const bodyStart = prefixIdx + OSC4_PREFIX.length;
-	let bodyEnd = input.indexOf(BEL$1, bodyStart);
-	if (bodyEnd === -1) bodyEnd = input.indexOf(`${ESC$1}\\`, bodyStart);
-	if (bodyEnd === -1) return null;
-	const body = input.slice(bodyStart, bodyEnd);
-	const match = OSC4_BODY_RE.exec(body);
-	if (!match) return null;
-	const index = Number.parseInt(match[1], 10);
-	if (index < 0 || index > 255) return null;
-	return {
-		index,
-		color: `#${normalizeHexChannel$1(match[2])}${normalizeHexChannel$1(match[3])}${normalizeHexChannel$1(match[4])}`
-	};
-}
-function normalizeHexChannel$1(hex) {
-	switch (hex.length) {
-		case 1: return hex + hex;
-		case 2: return hex;
-		default: return hex.slice(0, 2);
-	}
-}
-var ESC$1, BEL$1, OSC4_PREFIX, OSC4_BODY_RE;
-var init_osc_palette = __esmMin((() => {
-	ESC$1 = "\x1B";
-	BEL$1 = "\x07";
-	OSC4_PREFIX = `${ESC$1}]4;`;
-	OSC4_BODY_RE = /^(\d+);rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})$/;
-}));
-//#endregion
-//#region packages/ansi/src/osc-colors.ts
-function normalizeHexChannel(hex) {
-	switch (hex.length) {
-		case 1: return hex + hex;
-		case 2: return hex;
-		default: return hex.slice(0, 2);
-	}
-}
-function parseOscColorResponse(input, oscCode) {
-	const prefix = `${ESC}]${oscCode};`;
-	const prefixIdx = input.indexOf(prefix);
-	if (prefixIdx === -1) return null;
-	const bodyStart = prefixIdx + prefix.length;
-	let bodyEnd = input.indexOf(BEL, bodyStart);
-	if (bodyEnd === -1) bodyEnd = input.indexOf(`${ESC}\\`, bodyStart);
-	if (bodyEnd === -1) return null;
-	const body = input.slice(bodyStart, bodyEnd);
-	const match = RGB_BODY_RE.exec(body);
-	if (!match) return null;
-	return `#${normalizeHexChannel(match[1])}${normalizeHexChannel(match[2])}${normalizeHexChannel(match[3])}`;
-}
-async function queryOscColor(write, read, oscCode, timeoutMs) {
-	write(`${ESC}]${oscCode};?${BEL}`);
-	const data = await read(timeoutMs);
-	if (data == null) return null;
-	return parseOscColorResponse(data, oscCode);
-}
-async function queryForegroundColor(write, read, timeoutMs = 200) {
-	return queryOscColor(write, read, 10, timeoutMs);
-}
-async function queryBackgroundColor(write, read, timeoutMs = 200) {
-	return queryOscColor(write, read, 11, timeoutMs);
-}
-async function queryCursorColor(write, read, timeoutMs = 200) {
-	return queryOscColor(write, read, 12, timeoutMs);
-}
-function setForegroundColor(write, color) {
-	write(`${ESC}]10;${color}${BEL}`);
-}
-function setBackgroundColor(write, color) {
-	write(`${ESC}]11;${color}${BEL}`);
-}
-function setCursorColor(write, color) {
-	write(`${ESC}]12;${color}${BEL}`);
-}
-function resetForegroundColor(write) {
-	write(`${ESC}]110${BEL}`);
-}
-function resetBackgroundColor(write) {
-	write(`${ESC}]111${BEL}`);
-}
-function resetCursorColor(write) {
-	write(`${ESC}]112${BEL}`);
-}
-async function detectColorScheme(write, read, timeoutMs = 200) {
-	const bg = await queryBackgroundColor(write, read, timeoutMs);
-	if (bg == null) return null;
-	const r = parseInt(bg.slice(1, 3), 16) / 255;
-	const g = parseInt(bg.slice(3, 5), 16) / 255;
-	const b = parseInt(bg.slice(5, 7), 16) / 255;
-	return .2126 * r + .7152 * g + .0722 * b > .5 ? "light" : "dark";
-}
-var ESC, BEL, RGB_BODY_RE;
-var init_osc_colors = __esmMin((() => {
-	ESC = "\x1B";
-	BEL = "\x07";
-	RGB_BODY_RE = /rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})/;
-}));
-//#endregion
-//#region packages/ansi/src/theme/detect.ts
-async function detectTerminalScheme(timeoutMs = 150) {
-	const stdin = process.stdin;
-	const stdout = process.stdout;
-	if (!stdin.isTTY || !stdout.isTTY) return null;
-	const wasRaw = stdin.isRaw;
-	if (!wasRaw) stdin.setRawMode(true);
-	let buffer = "";
-	const onData = (chunk) => {
-		buffer += chunk.toString();
-	};
-	stdin.on("data", onData);
-	try {
-		const write = (s) => {
-			stdout.write(s);
-		};
-		const read = (ms) => new Promise((resolve) => {
-			if (buffer.length > 0) {
-				const result = buffer;
-				buffer = "";
-				resolve(result);
-				return;
-			}
-			const timer = setTimeout(() => {
-				resolve(buffer.length > 0 ? buffer : null);
-				buffer = "";
-			}, ms);
-			const check = (_chunk) => {
-				clearTimeout(timer);
-				stdin.removeListener("data", check);
-				const result = buffer;
-				buffer = "";
-				resolve(result);
-			};
-			stdin.on("data", check);
-		});
-		const bg = await queryBackgroundColor(write, read, timeoutMs);
-		const fg = await queryForegroundColor(write, read, timeoutMs);
-		const ansi = new Array(16).fill(null);
-		queryMultiplePaletteColors(Array.from({ length: 16 }, (_, i) => i), write);
-		await new Promise((resolve) => setTimeout(resolve, timeoutMs));
-		const remaining = buffer;
-		buffer = "";
-		if (remaining) {
-			const oscPrefix = "\x1B]4;";
-			let pos = 0;
-			while (pos < remaining.length) {
-				const nextOsc = remaining.indexOf(oscPrefix, pos);
-				if (nextOsc === -1) break;
-				let end = remaining.indexOf("\x07", nextOsc);
-				if (end === -1) end = remaining.indexOf("\x1B\\", nextOsc);
-				if (end === -1) break;
-				const parsed = parsePaletteResponse(remaining.slice(nextOsc, end + 1));
-				if (parsed && parsed.index >= 0 && parsed.index < 16) ansi[parsed.index] = parsed.color;
-				pos = end + 1;
-			}
-		}
-		const dark = bg ? isDarkColor(bg) : true;
-		const palette = { dark };
-		if (bg) palette.background = bg;
-		if (fg) palette.foreground = fg;
-		const ansiFields = [
-			"black",
-			"red",
-			"green",
-			"yellow",
-			"blue",
-			"magenta",
-			"cyan",
-			"white",
-			"brightBlack",
-			"brightRed",
-			"brightGreen",
-			"brightYellow",
-			"brightBlue",
-			"brightMagenta",
-			"brightCyan",
-			"brightWhite"
-		];
-		for (let i = 0; i < 16; i++) if (ansi[i]) palette[ansiFields[i]] = ansi[i];
-		if (fg) {
-			palette.cursorColor = fg;
-			palette.selectionForeground = fg;
-		}
-		if (bg) palette.cursorText = bg;
-		if (ansi[4]) palette.selectionBackground = ansi[4];
-		return {
-			fg,
-			bg,
-			ansi,
-			dark,
-			palette
-		};
-	} finally {
-		stdin.removeListener("data", onData);
-		if (!wasRaw) stdin.setRawMode(false);
-	}
-}
-async function detectTheme(opts = {}) {
-	const colorLevel = opts.caps?.colorLevel;
-	if (colorLevel === "none" || colorLevel === "basic") return opts.caps?.darkBackground ?? true ? ansi16DarkTheme : ansi16LightTheme;
-	const detected = await detectTerminalScheme(opts.timeoutMs);
-	const isDark = detected?.dark ?? opts.caps?.darkBackground ?? true;
-	const fallback = opts.fallback ?? (isDark ? opts.fallbackDark ?? defaultDarkScheme : opts.fallbackLight ?? defaultLightScheme);
-	if (!detected) return deriveTheme(fallback);
-	return deriveTheme({
-		...fallback,
-		...stripNulls$1(detected.palette)
-	});
-}
-function stripNulls$1(partial) {
-	const result = {};
-	for (const [k, v] of Object.entries(partial)) if (v != null) result[k] = v;
-	return result;
-}
-function isDarkColor(hex) {
-	const r = parseInt(hex.slice(1, 3), 16) / 255;
-	const g = parseInt(hex.slice(3, 5), 16) / 255;
-	const b = parseInt(hex.slice(5, 7), 16) / 255;
-	return .2126 * r + .7152 * g + .0722 * b <= .5;
-}
-var init_detect = __esmMin((() => {
-	init_derive();
-	init_default_schemes();
-	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();
-}));
-//#endregion
-//#region packages/ansi/src/theme/tokens.ts
-var KNOWN_VARIANTS;
-var init_tokens = __esmMin((() => {
-	KNOWN_VARIANTS = [
-		"h1",
-		"h2",
-		"h3",
-		"body",
-		"body-muted",
-		"fine-print",
-		"strong",
-		"em",
-		"link",
-		"key",
-		"code",
-		"kbd"
-	];
-})), CSI;
-var init_color_scheme = __esmMin((() => {
-	CSI = `[`;
-	`${CSI}`;
-	`${CSI}`;
-}));
-//#endregion
-//#region packages/ansi/src/theme/generators.ts
-var init_generators = __esmMin((() => {}));
-//#endregion
-//#region packages/ansi/src/theme/auto-generate.ts
-var init_auto_generate = __esmMin((() => {
-	init_generators();
-	init_derive();
-}));
-//#endregion
-//#region packages/ansi/src/theme/generate.ts
-/**
-* Generate a complete ANSI 16 theme from a primary color + dark/light preference.
-*
-* All token values are ANSI color names (e.g. "yellow", "blueBright").
-*/
-function generateTheme(primary, dark) {
-	const fg = dark ? "whiteBright" : "black";
-	const accent = primary;
-	const selectionbg = primary;
-	const surfacebg = dark ? "black" : "white";
-	const derived = deriveFields({
-		primary,
-		accent,
-		fg,
-		selectionbg,
-		surfacebg,
-		ring: {
-			red: dark ? "redBright" : "red",
-			orange: dark ? "redBright" : "red",
-			yellow: "yellow",
-			green: dark ? "greenBright" : "green",
-			teal: "cyan",
-			blue: dark ? "blueBright" : "blue",
-			purple: "magenta",
-			pink: dark ? "magentaBright" : "magenta"
-		}
-	});
-	return {
-		name: `${dark ? "dark" : "light"}-${primary}`,
-		bg: "",
-		fg,
-		muted: dark ? "white" : "blackBright",
-		mutedbg: dark ? "black" : "white",
-		surface: dark ? "whiteBright" : "black",
-		surfacebg,
-		popover: dark ? "whiteBright" : "black",
-		popoverbg: dark ? "blackBright" : "white",
-		inverse: dark ? "black" : "whiteBright",
-		inversebg: dark ? "whiteBright" : "black",
-		cursor: "black",
-		cursorbg: primary,
-		selection: "black",
-		selectionbg: primary,
-		primary,
-		primaryfg: "black",
-		secondary: primary,
-		secondaryfg: "black",
-		accent: primary,
-		accentfg: "black",
-		error: dark ? "redBright" : "red",
-		errorfg: "black",
-		warning: primary,
-		warningfg: "black",
-		success: dark ? "greenBright" : "green",
-		successfg: "black",
-		info: dark ? "cyanBright" : "cyan",
-		infofg: "black",
-		border: "gray",
-		inputborder: "gray",
-		focusborder: dark ? "blueBright" : "blue",
-		link: "blueBright",
-		disabledfg: "gray",
-		palette: [
-			"black",
-			"red",
-			"green",
-			"yellow",
-			"blue",
-			"magenta",
-			"cyan",
-			"white",
-			"blackBright",
-			"redBright",
-			"greenBright",
-			"yellowBright",
-			"blueBright",
-			"magentaBright",
-			"cyanBright",
-			"whiteBright"
-		],
-		...derived
-	};
-}
-var init_generate = __esmMin((() => {
-	init_derived();
-}));
-//#endregion
-//#region packages/ansi/src/index.ts
-var init_src = __esmMin((() => {
-	init_detection();
-	init_sgr_codes();
-	init_utils();
-	init_color_maps();
-	init_flatten();
-	init_terminal_control();
-	init_kitty_graphics();
-	init_style();
-	init_mixed_proxy();
-	init_colors();
-	init_derive();
-	init_derived();
-	init_monochrome();
-	init_fingerprint();
-	init_orchestrator();
-	init_invariants();
-	init_default_schemes();
-	init_types();
-	init_tokens();
-	init_detect();
-	init_osc_palette();
-	init_osc_colors();
-	init_color_scheme();
-	init_generators();
-	init_auto_generate();
-	init_generate();
-}));
-//#endregion
-export { backdropPlacementId as A, bakeFlat as B, COLOR_SCHEME_FIELDS as C, createMixedStyle as D, deriveFields as E, kittyUploadScrimImage as F, bgColorCode as G, ANSI16_SLOT_HEX as H, disableKittyKeyboard as I, detectColor as J, fgColorCode as K, disableMouse as L, cupTo as M, kittyDeleteAllScrimPlacements as N, createStyle as O, kittyPlaceAt as P, detectUnicode as Q, enableKittyKeyboard as R, ansi16LightTheme as S, deriveTheme as T, pickColorLevel as U, defaultFlattenRule as V, quantizeHex as W, detectInput as X, detectCursor as Y, detectTerminalCaps as Z, parsePaletteResponse as _, detectTerminalScheme as a, setPaletteColor as b, queryBackgroundColor as c, resetBackgroundColor as d, resetCursorColor as f, setForegroundColor as g, setCursorColor as h, detectScheme as i, buildScrimPixels as j, resolveThemeColor as k, queryCursorColor as l, setBackgroundColor as m, generateTheme as n, detectTheme as o, resetForegroundColor as p, defaultCaps as q, KNOWN_VARIANTS as r, detectColorScheme as s, init_src as t, queryForegroundColor as u, queryMultiplePaletteColors as v, monoAttrsForColorString as w, ansi16DarkTheme as x, queryPaletteColor as y, enableMouse as z };
-
-//# sourceMappingURL=src-NCKb8kE5.mjs.map