silvery 0.18.2 → 0.19.0

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

@@ -1,5 +1,6 @@
-import { i as __require, n as __esmMin } from "./chunk-BSw8zbkd.mjs";
+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).
@@ -289,7 +290,148 @@ function bgFromRgb(r, g, b, level) {
 	const idx = nearestAnsi16(r, g, b);
 	return idx < 8 ? `${40 + idx}` : `${92 + idx}`;
 }
-var MODIFIERS, FG_COLORS, BG_COLORS, ANSI_16_COLORS;
+/**
+* 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],
@@ -424,6 +566,95 @@ var init_color_maps = __esmMin((() => {
 			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
@@ -486,447 +717,123 @@ var init_terminal_control = __esmMin((() => {
 	`${ESC$3}`;
 }));
 //#endregion
-//#region packages/color/src/oklch.ts
-function parseHex(hex) {
-	if (hex[0] !== "#") return null;
-	const h = hex.slice(1);
-	if (h.length === 3) {
-		const r = parseInt(h[0] + h[0], 16);
-		const g = parseInt(h[1] + h[1], 16);
-		const b = parseInt(h[2] + h[2], 16);
-		if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) return null;
-		return [
-			r,
-			g,
-			b
-		];
-	}
-	if (h.length === 6) {
-		const r = parseInt(h.slice(0, 2), 16);
-		const g = parseInt(h.slice(2, 4), 16);
-		const b = parseInt(h.slice(4, 6), 16);
-		if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) return null;
-		return [
-			r,
-			g,
-			b
-		];
-	}
-	return null;
-}
-/** sRGB channel (0–255) → linear RGB (0–1). Inverse gamma. */
-function srgbToLinear(c) {
-	const s = c / 255;
-	return s <= .04045 ? s / 12.92 : ((s + .055) / 1.055) ** 2.4;
-}
-/** Linear RGB (0–1) → sRGB channel (0–255). Forward gamma. */
-function linearToSrgb(c) {
-	const clamped = Math.max(0, Math.min(1, c));
-	return clamped <= .0031308 ? 12.92 * clamped * 255 : (1.055 * clamped ** (1 / 2.4) - .055) * 255;
-}
-/** Linear RGB → OKLab (Ottosson 2020 matrix). */
-function linearRgbToOklab(r, g, b) {
-	const l = .4122214708 * r + .5363325363 * g + .0514459929 * b;
-	const m = .2119034982 * r + .6806995451 * g + .1073969566 * b;
-	const s = .0883024619 * r + .2817188376 * g + .6299787005 * b;
-	const lCbrt = Math.cbrt(l);
-	const mCbrt = Math.cbrt(m);
-	const sCbrt = Math.cbrt(s);
-	return [
-		.2104542553 * lCbrt + .793617785 * mCbrt - .0040720468 * sCbrt,
-		1.9779984951 * lCbrt - 2.428592205 * mCbrt + .4505937099 * sCbrt,
-		.0259040371 * lCbrt + .7827717662 * mCbrt - .808675766 * sCbrt
-	];
-}
-/** OKLab → linear RGB (inverse of the above). */
-function oklabToLinearRgb(L, a, bb) {
-	const lCbrt = L + .3963377774 * a + .2158037573 * bb;
-	const mCbrt = L - .1055613458 * a - .0638541728 * bb;
-	const sCbrt = L - .0894841775 * a - 1.291485548 * bb;
-	const l = lCbrt ** 3;
-	const m = mCbrt ** 3;
-	const s = sCbrt ** 3;
-	return [
-		4.0767416621 * l - 3.3077115913 * m + .2309699292 * s,
-		-1.2684380046 * l + 2.6097574011 * m - .3413193965 * s,
-		-.0041960863 * l - .7034186147 * m + 1.707614701 * s
-	];
-}
-/** Hex (`#RRGGBB`) → OKLCH. Returns `null` for invalid hex. */
-function hexToOklch(hex) {
-	const rgb = parseHex(hex);
-	if (!rgb) return null;
-	const [r, g, b] = rgb;
-	const [lr, lg, lb] = [
-		srgbToLinear(r),
-		srgbToLinear(g),
-		srgbToLinear(b)
-	];
-	const [L, a, bb] = linearRgbToOklab(lr, lg, lb);
-	const C = Math.sqrt(a * a + bb * bb);
-	let H = Math.atan2(bb, a) * 180 / Math.PI;
-	if (H < 0) H += 360;
-	return {
-		L,
-		C,
-		H
-	};
-}
-/** Check whether linear RGB is inside sRGB gamut (each channel in [0, 1]). */
-function inGamut(r, g, b) {
-	const e = 1e-5;
-	return r >= -e && r <= 1 + e && g >= -e && g <= 1 + e && b >= -e && b <= 1 + e;
-}
+//#region packages/ansi/src/kitty-graphics.ts
 /**
-* OKLCH → hex. Gamut-maps out-of-sRGB colors by reducing chroma until in-gamut
-* (preserves L and H — the perceptual anchors). This is the CSS Color 4
-* recommended approach for rendering OKLCH on sRGB displays.
+* Derive a stable placement ID for a given (x, y) cell. Max column = 9999,
+* which comfortably exceeds any realistic terminal width.
 */
-function oklchToHex(c) {
-	const L = Math.max(0, Math.min(1, c.L));
-	const Crad = (c.H % 360 + 360) % 360 * Math.PI / 180;
-	let lo = 0;
-	let hi = Math.max(0, c.C);
-	let [rHi, gHi, bHi] = oklabToLinearRgb(L, hi * Math.cos(Crad), hi * Math.sin(Crad));
-	if (inGamut(rHi, gHi, bHi)) return rgbToHexInternal(linearToSrgb(rHi), linearToSrgb(gHi), linearToSrgb(bHi));
-	for (let i = 0; i < 20; i++) {
-		const mid = (lo + hi) / 2;
-		const [rr, gg, bbLin] = oklabToLinearRgb(L, mid * Math.cos(Crad), mid * Math.sin(Crad));
-		if (inGamut(rr, gg, bbLin)) lo = mid;
-		else hi = mid;
-	}
-	const a = lo * Math.cos(Crad);
-	const bb = lo * Math.sin(Crad);
-	[rHi, gHi, bHi] = oklabToLinearRgb(L, a, bb);
-	return rgbToHexInternal(linearToSrgb(rHi), linearToSrgb(gHi), linearToSrgb(bHi));
-}
-function rgbToHexInternal(r, g, b) {
-	const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
-	return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`.toUpperCase();
+function backdropPlacementId(x, y) {
+	return x * BACKDROP_PLACEMENT_X_STRIDE + y + 1;
 }
 /**
-* Linear interpolate in OKLab (rectangular — a, b, L interpolated directly).
-*
-* CSS Color Module 4's default interpolation space. Avoids the hue-arc
-* weirdness of `lerpOklch` when one endpoint is near-neutral (its H is
-* effectively undefined). Produces the expected "tinted surface" when blending
-* `bg` with an accent color.
+* 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 lerpOklabHex(aHex, bHex, t) {
-	const aOk = hexToOklch(aHex);
-	const bOk = hexToOklch(bHex);
-	if (!aOk || !bOk) return null;
-	const aRad = aOk.H * Math.PI / 180;
-	const bRad = bOk.H * Math.PI / 180;
-	const aA = aOk.C * Math.cos(aRad);
-	const aB = aOk.C * Math.sin(aRad);
-	const bA = bOk.C * Math.cos(bRad);
-	const bB = bOk.C * Math.sin(bRad);
-	const L = aOk.L + (bOk.L - aOk.L) * t;
-	const A = aA + (bA - aA) * t;
-	const B = aB + (bB - aB) * t;
-	const C = Math.sqrt(A * A + B * B);
-	let H = Math.atan2(B, A) * 180 / Math.PI;
-	if (H < 0) H += 360;
-	return oklchToHex({
-		L,
-		C,
-		H
-	});
+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");
 }
 /**
-* ΔE in OKLCH (≈ ΔE₀₀ quality in practice — OKLCH was designed to make Euclidean
-* distance perceptually meaningful). Hue is weighted by chroma so near-neutral
-* colors don't produce spurious large ΔH contributions.
-*/
-function deltaE(a, b) {
-	const dL = a.L - b.L;
-	const dC = a.C - b.C;
-	const dh = ((a.H - b.H + 540) % 360 - 180) * (Math.PI / 180);
-	(a.C + b.C) / 2;
-	const dH = 2 * Math.sqrt(a.C * b.C) * Math.sin(dh / 2);
-	return Math.sqrt(dL * dL + dC * dC + dH * dH);
-}
-var init_oklch = __esmMin((() => {}));
-//#endregion
-//#region packages/color/src/color.ts
-/** Parse #rrggbb or #rgb to [r, g, b]. Returns null for invalid input. */
-function hexToRgb(hex) {
-	if (hex[0] !== "#") return null;
-	const h = hex.slice(1);
-	if (h.length === 3) return [
-		parseInt(h[0] + h[0], 16),
-		parseInt(h[1] + h[1], 16),
-		parseInt(h[2] + h[2], 16)
-	];
-	if (h.length === 6) return [
-		parseInt(h.slice(0, 2), 16),
-		parseInt(h.slice(2, 4), 16),
-		parseInt(h.slice(4, 6), 16)
-	];
-	return null;
-}
-/** Convert [r, g, b] (0-255) to hex string. */
-function rgbToHex(r, g, b) {
-	const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
-	return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`.toUpperCase();
-}
-/**
-* Blend two hex colors in OKLab space. t=0 returns a, t=1 returns b.
-* Perceptually-uniform midpoints (unlike naive RGB blending which produces
-* muddy halfway colors).
+* Build a tiny RGBA pixel grid for the scrim overlay.
 *
-* Interpolation is done in OKLab (rectangular a/b), not OKLCH (polar). This
-* matches CSS Color Module 4's default interpolation space and avoids hue-arc
-* weirdness when one endpoint is near-neutral (its hue is effectively
-* undefined). For explicit hue-rotation blending, use `lerpOklch` directly.
+* 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.
 *
-* For non-hex inputs (ANSI names), returns `a` unchanged.
-*/
-function blend(a, b, t) {
-	return lerpOklabHex(a, b, t) ?? a;
-}
-/**
-* Brighten a hex color by raising OKLCH lightness. amount=0.1 adds 0.1 to L
-* (perceptually linear — 10% brighter looks 10% brighter regardless of hue).
+* 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.
 *
-* For non-hex inputs, returns the color unchanged.
+* Width/height = 2 pixels — 16 bytes total, ~24 bytes base64. Upload is ~60
+* bytes including control chars. One-time cost per modal session.
 */
-function brighten(color, amount) {
-	const o = hexToOklch(color);
-	if (!o) return color;
-	return oklchToHex({
-		L: Math.min(1, o.L + amount),
-		C: o.C,
-		H: o.H
-	});
+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;
 }
 /**
-* Darken a hex color by lowering OKLCH lightness. amount=0.1 subtracts 0.1 from L.
+* APC wrapper: `\x1b_G<control>[;<payload>]\x1b\\`.
 *
-* For non-hex inputs, returns the color unchanged.
+* The protocol allows chunking large payloads via `m=1` but our scrim is
+* tiny — always fits in one chunk.
 */
-function darken(color, amount) {
-	const o = hexToOklch(color);
-	if (!o) return color;
-	return oklchToHex({
-		L: Math.max(0, o.L - amount),
-		C: o.C,
-		H: o.H
-	});
+function apc(control, payload) {
+	if (payload === void 0 || payload === "") return `\x1b_G${control}\x1b\\`;
+	return `\x1b_G${control};${payload}\x1b\\`;
 }
 /**
-* Desaturate a hex color by lowering OKLCH chroma. amount=0.4 reduces C by 40%
-* (relative — consistent with the original HSL-based contract). For a flat
-* subtraction, use `saturate(color, -amount)`.
+* 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.
 *
-* For non-hex inputs, returns the color unchanged.
+* `q=2` suppresses the terminal's OK/error reply — otherwise we'd see stray
+* APC sequences back on stdin.
 */
-function desaturate(color, amount) {
-	const o = hexToOklch(color);
-	if (!o) return color;
-	return oklchToHex({
-		L: o.L,
-		C: Math.max(0, o.C * (1 - amount)),
-		H: o.H
-	});
+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);
 }
 /**
-* Get the complementary color (180° hue rotation) in OKLCH. Preserves L + C,
-* so the complement has the same perceived brightness and colorfulness.
+* 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).
 *
-* For non-hex inputs, returns the color unchanged.
-*/
-function complement(color) {
-	const o = hexToOklch(color);
-	if (!o) return color;
-	return oklchToHex({
-		L: o.L,
-		C: o.C,
-		H: (o.H + 180) % 360
-	});
-}
-/** Perceptual color distance (ΔE) between two hex colors, in OKLCH. */
-function colorDistance(a, b) {
-	const oa = hexToOklch(a);
-	const ob = hexToOklch(b);
-	if (!oa || !ob) return null;
-	return deltaE(oa, ob);
-}
-/**
-* Linearize an sRGB channel value (0-255) for WCAG 2.1 luminance.
-* Kept for WCAG contrast checking — OKLCH uses its own linearization.
-*/
-function channelLuminance(c) {
-	const s = c / 255;
-	return s <= .03928 ? s / 12.92 : Math.pow((s + .055) / 1.055, 2.4);
-}
-/**
-* Compute relative luminance of a hex color per WCAG 2.1.
-* Returns a value between 0 (darkest) and 1 (lightest), or null for invalid input.
-*/
-function relativeLuminance(hex) {
-	const rgb = hexToRgb(hex);
-	if (!rgb) return null;
-	return .2126 * channelLuminance(rgb[0]) + .7152 * channelLuminance(rgb[1]) + .0722 * channelLuminance(rgb[2]);
-}
-/**
-* Pick black or white text for readability on the given background.
-* Uses WCAG 2.1 relative luminance.
+* Placement ID (`p=<pid>`) is stable per cell so incremental frames can
+* replace placements without accumulating duplicates.
 */
-function contrastFg(bg) {
-	const luminance = relativeLuminance(bg);
-	if (luminance === null) return "#FFFFFF";
-	return luminance > .179 ? "#000000" : "#FFFFFF";
-}
-function rgbToHsl(r, g, b) {
-	r /= 255;
-	g /= 255;
-	b /= 255;
-	const max = Math.max(r, g, b), min = Math.min(r, g, b);
-	const l = (max + min) / 2;
-	if (max === min) return [
-		0,
-		0,
-		l
-	];
-	const d = max - min;
-	const s = l > .5 ? d / (2 - max - min) : d / (max + min);
-	let h = 0;
-	if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-	else if (max === g) h = ((b - r) / d + 2) / 6;
-	else h = ((r - g) / d + 4) / 6;
-	return [
-		h * 360,
-		s,
-		l
-	];
-}
-function hslToHex(h, s, l) {
-	h = (h % 360 + 360) % 360;
-	const a = s * Math.min(l, 1 - l);
-	const f = (n) => {
-		const k = (n + h / 30) % 12;
-		return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
-	};
-	return rgbToHex(f(0) * 255, f(8) * 255, f(4) * 255);
-}
-function hexToHsl(hex) {
-	const rgb = hexToRgb(hex);
-	if (!rgb) return null;
-	return rgbToHsl(rgb[0], rgb[1], rgb[2]);
+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`);
 }
-var init_color = __esmMin((() => {
-	init_oklch();
-}));
-//#endregion
-//#region packages/color/src/contrast.ts
 /**
-* Check contrast ratio between foreground and background colors.
-*
-* Uses the WCAG 2.1 relative luminance formula to compute the contrast
-* ratio and check AA (>= 4.5:1) and AAA (>= 7:1) compliance for normal text.
-*
-* @param fg - Foreground hex color (e.g. "#FFFFFF")
-* @param bg - Background hex color (e.g. "#000000")
-* @returns Contrast ratio and AA/AAA pass/fail, or null if colors are not valid hex
-*
-* @example
-* ```typescript
-* const result = checkContrast("#FFFFFF", "#000000")
-* // { ratio: 21, aa: true, aaa: true }
-*
-* const poor = checkContrast("#777777", "#888888")
-* // { ratio: ~1.3, aa: false, aaa: false }
-* ```
+* 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 checkContrast(fg, bg) {
-	const fgLum = relativeLuminance(fg);
-	const bgLum = relativeLuminance(bg);
-	if (fgLum === null || bgLum === null) return null;
-	const lighter = Math.max(fgLum, bgLum);
-	const darker = Math.min(fgLum, bgLum);
-	const ratio = (lighter + .05) / (darker + .05);
-	return {
-		ratio,
-		aa: ratio >= 4.5,
-		aaa: ratio >= 7
-	};
+function kittyDeleteAllScrimPlacements(imageId = BACKDROP_SCRIM_IMAGE_ID) {
+	return apc(`a=d,d=i,i=${imageId},q=2`);
 }
 /**
-* Adjust a color's OKLCH lightness until it meets a minimum WCAG contrast ratio
-* against a reference color. Preserves hue and chroma — only lightness shifts,
-* and only as much as needed.
-*
-* Returns the original color unchanged if it already meets the target.
+* Absolute cursor position (CUP). 1-based row/col per VT100.
 *
-* For impossible targets (e.g. 21:1 against mid-gray), returns the
-* best achievable color (near-black or near-white in the same hue).
-*
-* @param color - The color to adjust (hex)
-* @param against - The reference background color (hex)
-* @param minRatio - Minimum contrast ratio to achieve (e.g. 4.5 for AA)
-* @returns Adjusted hex color meeting the target, or original if already OK
-*
-* @example
-* ```typescript
-* // Yellow on white — too low contrast, gets darkened (perceptually; same hue preserved)
-* ensureContrast("#FFAB91", "#FFFFFF", 4.5)
-*
-* // Blue on dark bg — already fine, returned unchanged
-* ensureContrast("#5C9FFF", "#1A1A2E", 4.5)  // → "#5C9FFF"
-* ```
+* 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 ensureContrast(color, against, minRatio) {
-	const current = checkContrast(color, against);
-	if (!current) return color;
-	if (current.ratio >= minRatio) return color;
-	const o = hexToOklch(color);
-	if (!o) return color;
-	const lightBg = contrastFg(against) === "#000000";
-	let lo, hi;
-	if (lightBg) {
-		lo = 0;
-		hi = o.L;
-	} else {
-		lo = o.L;
-		hi = 1;
-	}
-	for (let i = 0; i < 24; i++) {
-		const mid = (lo + hi) / 2;
-		const r = checkContrast(oklchToHex({
-			L: mid,
-			C: o.C,
-			H: o.H
-		}), against);
-		if (!r) break;
-		if (lightBg) if (r.ratio >= minRatio) lo = mid;
-		else hi = mid;
-		else if (r.ratio >= minRatio) hi = mid;
-		else lo = mid;
-	}
-	return oklchToHex({
-		L: lightBg ? lo : hi,
-		C: o.C,
-		H: o.H
-	});
+function cupTo(col, row) {
+	return `\x1b[${row + 1};${col + 1}H`;
 }
-var init_contrast = __esmMin((() => {
-	init_oklch();
-	init_color();
-}));
-//#endregion
-//#region packages/color/src/index.ts
-var init_src$1 = __esmMin((() => {
-	init_color();
-	init_oklch();
-	init_contrast();
+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_src$1();
 	init_color_maps();
 	THEME_TOKEN_DEFAULTS = {
 		primary: 33,
@@ -959,7 +866,26 @@ function resolveThemeColor(name, theme) {
 	if (!theme) return void 0;
 	return resolveToken(name, theme);
 }
-/** Internal: resolve a token name (with or without $ prefix) against a 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;
@@ -967,14 +893,13 @@ function resolveToken(name, theme) {
 		const idx = parseInt(token.slice(5), 10);
 		if (idx >= 0 && idx < 16 && theme.palette && idx < theme.palette.length) return theme.palette[idx];
 	}
-	const key = token.replace(/-/g, "");
 	const themeObj = theme;
-	const direct = themeObj[key];
+	const direct = themeObj[token];
 	if (typeof direct === "string") return direct;
-	const aliased = PRIMER_ALIASES[key];
-	if (aliased) {
-		const val = themeObj[aliased];
-		if (typeof val === "string") return val;
+	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. */
@@ -1066,7 +991,7 @@ function createChainWithRef(state, ref) {
 			const level = ref.level;
 			if (prop === "hex" || prop === "bgHex") return (color) => {
 				if (level === null) return createChainWithRef(state, ref);
-				const rgb = hexToRgb(color);
+				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";
@@ -1124,7 +1049,7 @@ function createChainWithRef(state, ref) {
 				if (level === null) return createChainWithRef(state, ref);
 				const hex = resolveToken(prop, ref.theme);
 				if (hex) {
-					const rgb = hexToRgb(hex);
+					const rgb = hexToRgb$1(hex);
 					if (rgb) {
 						const code = fgFromRgb(rgb[0], rgb[1], rgb[2], level);
 						if (prop === "link") return createChainWithRef({
@@ -1188,44 +1113,10 @@ function createChainWithRef(state, ref) {
 	proxyRef.proxy = proxy;
 	return proxy;
 }
-var PRIMER_ALIASES, ESC$2, KNOWN_METHODS, THEME_TOKENS;
+var ESC$2, KNOWN_METHODS, THEME_TOKENS;
 var init_style = __esmMin((() => {
 	init_detection();
 	init_colors();
-	PRIMER_ALIASES = {
-		fgmuted: "muted",
-		fgdisabled: "disabledfg",
-		fgcursor: "cursor",
-		fgselected: "selection",
-		fginverse: "inverse",
-		fgonsurface: "surface",
-		fgonpopover: "popover",
-		fgonprimary: "primaryfg",
-		fgonsecondary: "secondaryfg",
-		fgonaccent: "accentfg",
-		fgonerror: "errorfg",
-		fgonwarning: "warningfg",
-		fgonsuccess: "successfg",
-		fgoninfo: "infofg",
-		bgmuted: "mutedbg",
-		bgsurface: "surfacebg",
-		bgpopover: "popoverbg",
-		bginverse: "inversebg",
-		bgselected: "selectionbg",
-		bgcursor: "cursorbg",
-		borderfocus: "focusborder",
-		borderinput: "inputborder",
-		brandhover: "brandHover",
-		brandactive: "brandActive",
-		brandred: "brandRed",
-		brandorange: "brandOrange",
-		brandyellow: "brandYellow",
-		brandgreen: "brandGreen",
-		brandteal: "brandTeal",
-		brandblue: "brandBlue",
-		brandpurple: "brandPurple",
-		brandpink: "brandPink"
-	};
 	ESC$2 = "\x1B[";
 	KNOWN_METHODS = new Set([
 		"hex",
@@ -1326,6 +1217,31 @@ var init_mixed_proxy = __esmMin((() => {
 }));
 //#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;
@@ -1357,43 +1273,51 @@ function validateThemeInvariants(theme, opts = {}) {
 	const checkWcag = opts.wcag ?? false;
 	const checkVisibility = opts.visibility ?? true;
 	const violations = [];
-	if (checkWcag) for (const pair of CONTRAST_PAIRS) {
-		const fg = theme[pair.fg];
-		const bg = theme[pair.bg];
-		if (typeof fg !== "string" || typeof bg !== "string") continue;
-		const r = checkContrast(fg, bg);
-		if (r === null) continue;
-		if (r.ratio < pair.min) violations.push({
-			rule: pair.rule,
-			tokens: [String(pair.fg), String(pair.bg)],
-			actual: r.ratio,
-			required: pair.min,
-			message: `${pair.fg} (${fg}) on ${pair.bg} (${bg}) is ${r.ratio.toFixed(2)}:1, needs ${pair.min.toFixed(1)}:1`
-		});
+	if (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(theme.selectionbg);
+		const lSelBg = lightness(selectionBg);
 		if (lBg !== null && lSelBg !== null) {
 			const dL = Math.abs(lSelBg - lBg);
 			if (dL < .08) violations.push({
 				rule: "visibility:selection",
-				tokens: ["selectionbg", "bg"],
+				tokens: [selectionKey, "bg"],
 				actual: dL,
 				required: SELECTION_DELTA_L,
-				message: `selectionbg (${theme.selectionbg}) differs from bg (${theme.bg}) by ΔL=${dL.toFixed(3)}, needs ≥ ${SELECTION_DELTA_L.toFixed(2)}`
+				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(theme.cursorbg);
+		const oCursorBg = hexToOklch(cursorBg);
 		if (oBg && oCursorBg) {
 			const de = deltaE(oBg, oCursorBg);
 			if (de < .15) violations.push({
 				rule: "visibility:cursor",
-				tokens: ["cursorbg", "bg"],
+				tokens: [cursorKey, "bg"],
 				actual: de,
 				required: CURSOR_DELTA_E,
-				message: `cursorbg (${theme.cursorbg}) differs from bg (${theme.bg}) by ΔE=${de.toFixed(3)}, needs ≥ ${CURSOR_DELTA_E.toFixed(2)}`
+				message: `${cursorKey} (${cursorBg}) differs from bg (${theme.bg}) by ΔE=${de.toFixed(3)}, needs ≥ ${CURSOR_DELTA_E.toFixed(2)}`
 			});
 		}
 	}
@@ -1411,7 +1335,6 @@ function formatViolations(violations) {
 }
 var AA_RATIO, FAINT_RATIO, SELECTION_DELTA_L, CURSOR_DELTA_E, CONTRAST_PAIRS, ThemeInvariantError;
 var init_invariants = __esmMin((() => {
-	init_src$1();
 	AA_RATIO = 4.5;
 	FAINT_RATIO = 1.5;
 	SELECTION_DELTA_L = .08;
@@ -1424,152 +1347,110 @@ var init_invariants = __esmMin((() => {
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:fg/surfacebg",
+			rule: "contrast:fg/bg-surface-subtle",
 			fg: "fg",
-			bg: "surfacebg",
+			bg: "bg-surface-subtle",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:fg/popoverbg",
+			rule: "contrast:fg/bg-surface-overlay",
 			fg: "fg",
-			bg: "popoverbg",
+			bg: "bg-surface-overlay",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:muted/mutedbg",
-			fg: "muted",
-			bg: "mutedbg",
+			rule: "contrast:fg-muted/bg-muted",
+			fg: "fg-muted",
+			bg: "bg-muted",
 			min: 3
 		},
 		{
-			rule: "contrast:primary/bg",
-			fg: "primary",
+			rule: "contrast:fg-accent/bg",
+			fg: "fg-accent",
 			bg: "bg",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:secondary/bg",
-			fg: "secondary",
+			rule: "contrast:fg-error/bg",
+			fg: "fg-error",
 			bg: "bg",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:accent/bg",
-			fg: "accent",
+			rule: "contrast:fg-warning/bg",
+			fg: "fg-warning",
 			bg: "bg",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:error/bg",
-			fg: "error",
+			rule: "contrast:fg-success/bg",
+			fg: "fg-success",
 			bg: "bg",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:warning/bg",
-			fg: "warning",
+			rule: "contrast:fg-info/bg",
+			fg: "fg-info",
 			bg: "bg",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:success/bg",
-			fg: "success",
-			bg: "bg",
+			rule: "contrast:fg-on-accent/bg-accent",
+			fg: "fg-on-accent",
+			bg: "bg-accent",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:info/bg",
-			fg: "info",
-			bg: "bg",
+			rule: "contrast:fg-on-error/bg-error",
+			fg: "fg-on-error",
+			bg: "bg-error",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:link/bg",
-			fg: "link",
-			bg: "bg",
+			rule: "contrast:fg-on-warning/bg-warning",
+			fg: "fg-on-warning",
+			bg: "bg-warning",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:inverse/inversebg",
-			fg: "inverse",
-			bg: "inversebg",
+			rule: "contrast:fg-on-success/bg-success",
+			fg: "fg-on-success",
+			bg: "bg-success",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:selection/selectionbg",
-			fg: "selection",
-			bg: "selectionbg",
+			rule: "contrast:fg-on-info/bg-info",
+			fg: "fg-on-info",
+			bg: "bg-info",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:cursor/cursorbg",
-			fg: "cursor",
-			bg: "cursorbg",
+			rule: "contrast:fg-on-selected/bg-selected",
+			fg: "fg-on-selected",
+			bg: "bg-selected",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:primaryfg/primary",
-			fg: "primaryfg",
-			bg: "primary",
+			rule: "contrast:fg-cursor/bg-cursor",
+			fg: "fg-cursor",
+			bg: "bg-cursor",
 			min: AA_RATIO
 		},
 		{
-			rule: "contrast:secondaryfg/secondary",
-			fg: "secondaryfg",
-			bg: "secondary",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:accentfg/accent",
-			fg: "accentfg",
-			bg: "accent",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:errorfg/error",
-			fg: "errorfg",
-			bg: "error",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:warningfg/warning",
-			fg: "warningfg",
-			bg: "warning",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:successfg/success",
-			fg: "successfg",
-			bg: "success",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:infofg/info",
-			fg: "infofg",
-			bg: "info",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:inputborder/bg",
-			fg: "inputborder",
-			bg: "bg",
-			min: 3
-		},
-		{
-			rule: "contrast:focusborder/bg",
-			fg: "focusborder",
+			rule: "contrast:border-default/bg",
+			fg: "border-default",
 			bg: "bg",
 			min: 3
 		},
 		{
-			rule: "contrast:disabledfg/bg",
-			fg: "disabledfg",
+			rule: "contrast:border-focus/bg",
+			fg: "border-focus",
 			bg: "bg",
 			min: 3
 		},
 		{
-			rule: "contrast:border/bg",
-			fg: "border",
+			rule: "contrast:border-muted/bg",
+			fg: "border-muted",
 			bg: "bg",
 			min: FAINT_RATIO
 		}
@@ -1584,7 +1465,97 @@ var init_invariants = __esmMin((() => {
 	};
 }));
 //#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);
@@ -1652,9 +1623,6 @@ function deriveTruecolorTheme(p, adjustments) {
 	const success = ensure("success", p.green, bg, AA);
 	const info = ensure("info", blend(fg, accent, .5), bg, AA);
 	const link = ensure("link", dark ? p.brightBlue : p.blue, bg, AA);
-	const brand = primary;
-	const brandHover = dark ? brighten(primary, .04) : darken(primary, .04);
-	const brandActive = dark ? brighten(primary, .08) : darken(primary, .08);
 	const red = ensure("red", p.red, bg, AA);
 	const orange = ensure("orange", blend(p.red, p.yellow, .5), bg, AA);
 	const yellow = ensure("yellow", p.yellow, bg, AA);
@@ -1672,6 +1640,24 @@ function deriveTruecolorTheme(p, adjustments) {
 	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,
@@ -1725,30 +1711,30 @@ function deriveTruecolorTheme(p, adjustments) {
 			p.brightCyan,
 			p.brightWhite
 		],
-		brand,
-		brandHover,
-		brandActive,
-		red,
-		orange,
-		yellow,
-		green,
-		teal,
-		blue,
-		purple,
-		pink,
-		brandRed: red,
-		brandOrange: orange,
-		brandYellow: yellow,
-		brandGreen: green,
-		brandTeal: teal,
-		brandBlue: blue,
-		brandPurple: purple,
-		brandPink: pink
+		...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,
@@ -1769,7 +1755,7 @@ function deriveAnsi16Theme(p) {
 		primaryfg: p.black,
 		secondary: p.magenta,
 		secondaryfg: p.black,
-		accent: p.cyan,
+		accent: accentColor,
 		accentfg: p.black,
 		error: dark ? p.brightRed : p.red,
 		errorfg: p.black,
@@ -1802,17 +1788,7 @@ function deriveAnsi16Theme(p) {
 			p.brightCyan,
 			p.brightWhite
 		],
-		brand: primaryColor,
-		brandHover: primaryColor,
-		brandActive: primaryColor,
-		brandRed: dark ? p.brightRed : p.red,
-		brandOrange: dark ? p.brightRed : p.red,
-		brandYellow: p.yellow,
-		brandGreen: dark ? p.brightGreen : p.green,
-		brandTeal: p.cyan,
-		brandBlue: dark ? p.brightBlue : p.blue,
-		brandPurple: p.magenta,
-		brandPink: dark ? p.brightMagenta : p.magenta
+		...derived
 	};
 }
 /**
@@ -1859,8 +1835,8 @@ function repairCursorBg(cursorBg, bg) {
 }
 var AA, DIM, FAINT, CONTROL;
 var init_derive = __esmMin((() => {
-	init_src$1();
 	init_invariants();
+	init_derived();
 	AA = 4.5;
 	DIM = 3;
 	FAINT = 1.5;
@@ -1883,10 +1859,16 @@ function deriveMonochromeTheme(theme) {
 * consumed by the render pipeline.
 *
 * Accepts strings like `"$primary"`, `"$fg-muted"`, `"$border-focus"`. Strips
-* the `$` prefix and hyphens, tries direct Theme key lookup, then falls back
-* to the Primer alias table. Returns `undefined` for non-token strings (hex,
+* 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
@@ -1894,17 +1876,17 @@ function deriveMonochromeTheme(theme) {
 */
 function monoAttrsForColorString(color, theme) {
 	if (!color.startsWith("$")) return void 0;
-	const raw = color.slice(1).replace(/-/g, "");
+	const name = color.slice(1);
 	const attrs = deriveMonochromeTheme(theme);
-	const direct = attrs[raw];
+	const direct = attrs[name];
 	if (direct !== void 0) return direct;
-	const aliased = PRIMER_ALIASES_FOR_MONO[raw];
-	if (aliased) {
-		const v = attrs[aliased];
-		if (v !== void 0) return v;
+	const noHyphen = name.replace(/-/g, "");
+	if (noHyphen !== name) {
+		const stripped = attrs[noHyphen];
+		if (stripped !== void 0) return stripped;
 	}
 }
-var DEFAULT_MONO_ATTRS, PRIMER_ALIASES_FOR_MONO;
+var DEFAULT_MONO_ATTRS;
 var init_monochrome = __esmMin((() => {
 	DEFAULT_MONO_ATTRS = {
 		bg: [],
@@ -1938,31 +1920,47 @@ var init_monochrome = __esmMin((() => {
 		inputborder: [],
 		selection: [],
 		selectionbg: ["inverse"],
-		cursor: []
-	};
-	PRIMER_ALIASES_FOR_MONO = {
-		fgmuted: "muted",
-		fgdisabled: "disabledfg",
-		fgcursor: "cursor",
-		fgselected: "selection",
-		fginverse: "inverse",
-		fgonsurface: "surface",
-		fgonpopover: "popover",
-		fgonprimary: "primaryfg",
-		fgonsecondary: "secondaryfg",
-		fgonaccent: "accentfg",
-		fgonerror: "errorfg",
-		fgonwarning: "warningfg",
-		fgonsuccess: "successfg",
-		fgoninfo: "infofg",
-		bgmuted: "mutedbg",
-		bgsurface: "surfacebg",
-		bgpopover: "popoverbg",
-		bginverse: "inversebg",
-		bgselected: "selectionbg",
-		bgcursor: "cursorbg",
-		borderfocus: "focusborder",
-		borderinput: "inputborder"
+		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
@@ -2021,7 +2019,6 @@ function fingerprintMatch(probed, catalog, opts = {}) {
 }
 var FINGERPRINT_FIELDS;
 var init_fingerprint = __esmMin((() => {
-	init_src$1();
 	FINGERPRINT_FIELDS = [
 		"foreground",
 		"background",
@@ -2074,154 +2071,9 @@ var init_types = __esmMin((() => {
 }));
 //#endregion
 //#region packages/ansi/src/theme/default-schemes.ts
-var ansi16DarkTheme, ansi16LightTheme, defaultDarkScheme, defaultLightScheme;
+var defaultDarkScheme, defaultLightScheme, ansi16DarkTheme, ansi16LightTheme;
 var init_default_schemes = __esmMin((() => {
-	ansi16DarkTheme = {
-		name: "dark-ansi16",
-		bg: "",
-		fg: "whiteBright",
-		muted: "white",
-		mutedbg: "black",
-		surface: "whiteBright",
-		surfacebg: "black",
-		popover: "whiteBright",
-		popoverbg: "black",
-		inverse: "black",
-		inversebg: "whiteBright",
-		cursor: "black",
-		cursorbg: "yellow",
-		selection: "black",
-		selectionbg: "yellow",
-		primary: "yellow",
-		primaryfg: "black",
-		secondary: "white",
-		secondaryfg: "black",
-		accent: "blueBright",
-		accentfg: "black",
-		error: "redBright",
-		errorfg: "black",
-		warning: "yellow",
-		warningfg: "black",
-		success: "greenBright",
-		successfg: "black",
-		info: "cyan",
-		infofg: "black",
-		border: "gray",
-		inputborder: "gray",
-		focusborder: "blueBright",
-		link: "blueBright",
-		disabledfg: "gray",
-		palette: [
-			"black",
-			"red",
-			"green",
-			"yellow",
-			"blue",
-			"magenta",
-			"cyan",
-			"white",
-			"blackBright",
-			"redBright",
-			"greenBright",
-			"yellowBright",
-			"blueBright",
-			"magentaBright",
-			"cyanBright",
-			"whiteBright"
-		],
-		brand: "yellow",
-		brandHover: "yellow",
-		brandActive: "yellow",
-		red: "redBright",
-		orange: "redBright",
-		yellow: "yellow",
-		green: "greenBright",
-		teal: "cyan",
-		blue: "blueBright",
-		purple: "magenta",
-		pink: "magentaBright",
-		brandRed: "redBright",
-		brandOrange: "redBright",
-		brandYellow: "yellow",
-		brandGreen: "greenBright",
-		brandTeal: "cyan",
-		brandBlue: "blueBright",
-		brandPurple: "magenta",
-		brandPink: "magentaBright"
-	};
-	ansi16LightTheme = {
-		name: "light-ansi16",
-		bg: "",
-		fg: "black",
-		muted: "blackBright",
-		mutedbg: "white",
-		surface: "black",
-		surfacebg: "white",
-		popover: "black",
-		popoverbg: "white",
-		inverse: "whiteBright",
-		inversebg: "black",
-		cursor: "black",
-		cursorbg: "blue",
-		selection: "black",
-		selectionbg: "cyan",
-		primary: "blue",
-		primaryfg: "black",
-		secondary: "blue",
-		secondaryfg: "black",
-		accent: "cyan",
-		accentfg: "black",
-		error: "red",
-		errorfg: "black",
-		warning: "yellow",
-		warningfg: "black",
-		success: "green",
-		successfg: "black",
-		info: "cyan",
-		infofg: "black",
-		border: "gray",
-		inputborder: "gray",
-		focusborder: "blue",
-		link: "blueBright",
-		disabledfg: "gray",
-		palette: [
-			"black",
-			"red",
-			"green",
-			"yellow",
-			"blue",
-			"magenta",
-			"cyan",
-			"white",
-			"blackBright",
-			"redBright",
-			"greenBright",
-			"yellowBright",
-			"blueBright",
-			"magentaBright",
-			"cyanBright",
-			"whiteBright"
-		],
-		brand: "blue",
-		brandHover: "blue",
-		brandActive: "blue",
-		red: "red",
-		orange: "red",
-		yellow: "yellow",
-		green: "green",
-		teal: "cyan",
-		blue: "blue",
-		purple: "magenta",
-		pink: "magenta",
-		brandRed: "red",
-		brandOrange: "red",
-		brandYellow: "yellow",
-		brandGreen: "green",
-		brandTeal: "cyan",
-		brandBlue: "blue",
-		brandPurple: "magenta",
-		brandPink: "magenta"
-	};
+	init_derive();
 	defaultDarkScheme = {
 		name: "default-dark",
 		dark: true,
@@ -2274,6 +2126,8 @@ var init_default_schemes = __esmMin((() => {
 		selectionBackground: "#ccd0da",
 		selectionForeground: "#4c4f69"
 	};
+	ansi16DarkTheme = deriveAnsi16Theme(defaultDarkScheme);
+	ansi16LightTheme = deriveAnsi16Theme(defaultLightScheme);
 }));
 //#endregion
 //#region packages/ansi/src/osc-palette.ts
@@ -2487,6 +2341,23 @@ async function detectTerminalScheme(timeoutMs = 150) {
 		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;
@@ -2494,6 +2365,8 @@ function isDarkColor(hex) {
 	return .2126 * r + .7152 * g + .0722 * b <= .5;
 }
 var init_detect = __esmMin((() => {
+	init_derive();
+	init_default_schemes();
 	init_osc_palette();
 	init_osc_colors();
 }));
@@ -2629,6 +2502,25 @@ var init_orchestrator = __esmMin((() => {
 	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 = `[`;
@@ -2636,24 +2528,133 @@ var init_color_scheme = __esmMin((() => {
 	`${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 { detectTerminalCaps as $, brighten as A, rgbToHsl as B, createMixedStyle as C, checkContrast as D, init_src$1 as E, hexToHsl as F, enableKittyKeyboard as G, oklchToHex as H, hexToRgb as I, fgColorCode as J, enableMouse as K, hslToHex as L, contrastFg as M, darken as N, ensureContrast as O, desaturate as P, detectInput as Q, relativeLuminance as R, deriveTheme as S, resolveThemeColor as T, disableKittyKeyboard as U, hexToOklch as V, disableMouse as W, detectColor as X, defaultCaps as Y, detectCursor as Z, setPaletteColor as _, queryBackgroundColor as a, COLOR_SCHEME_FIELDS as b, resetBackgroundColor as c, setBackgroundColor as d, detectUnicode as et, setCursorColor as f, queryPaletteColor as g, queryMultiplePaletteColors as h, detectColorScheme as i, complement as j, blend as k, resetCursorColor as l, parsePaletteResponse as m, detectScheme as n, queryCursorColor as o, setForegroundColor as p, bgColorCode as q, detectTerminalScheme as r, queryForegroundColor as s, init_src as t, resetForegroundColor as u, ansi16DarkTheme as v, createStyle as w, monoAttrsForColorString as x, ansi16LightTheme as y, rgbToHex as z };
+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-D_BS-as7.mjs.map
+//# sourceMappingURL=src-NCKb8kE5.mjs.map