silvery 0.21.0 → 0.23.0

package/dist/{src-BNTToU7l.mjs → src-B8lf1kiR.mjs}

@@ -1,29 +1,40 @@
-import { i as __require, n as __esmMin } from "./chunk-BSw8zbkd.mjs";
-import { blend, brighten, checkContrast, colorDistance, complement, contrastFg, darken, deltaE, ensureContrast, hexToOklch, hexToRgb as hexToRgb$1, oklchToHex, relativeLuminance } from "@silvery/color";
+import { blend, brighten, checkContrast, colorDistance, complement, contrastFg, darken, deltaE, ensureContrast, hexToOklch, hexToRgb as hexToRgb$1, mixSrgb, oklchToHex, relativeLuminance } from "@silvery/color";
 import "string-width";
 //#region packages/ansi/src/constants.ts
 /**
+* ANSI escape code constants for extended terminal features.
+*
+* @see https://sw.kovidgoyal.net/kitty/underlines/
+* @see https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
+*/
+/**
+* Extended underline style codes.
+* Uses colon-separated parameters (ISO 8613-6): \x1b[4:Nm
+*/
+const UNDERLINE_CODES = {
+	none: "\x1B[4:0m",
+	single: "\x1B[4:1m",
+	double: "\x1B[4:2m",
+	curly: "\x1B[4:3m",
+	dotted: "\x1B[4:4m",
+	dashed: "\x1B[4:5m",
+	reset: "\x1B[4:0m"
+};
+/** Standard underline on (SGR 4) - works on all terminals */
+const UNDERLINE_STANDARD = "\x1B[4m";
+/** Standard underline off (SGR 24) */
+const UNDERLINE_RESET_STANDARD = "\x1B[24m";
+/**
+* Reset underline color to default (SGR 59)
+*/
+const UNDERLINE_COLOR_RESET = "\x1B[59m";
+/**
 * Build underline color escape code for RGB values.
 * Format: \x1b[58:2::r:g:bm (SGR 58 with RGB color space)
 */
 function buildUnderlineColorCode(r, g, b) {
 	return `\x1b[58:2::${r}:${g}:${b}m`;
 }
-var UNDERLINE_CODES, UNDERLINE_STANDARD, UNDERLINE_RESET_STANDARD, UNDERLINE_COLOR_RESET;
-var init_constants = __esmMin((() => {
-	UNDERLINE_CODES = {
-		none: "\x1B[4:0m",
-		single: "\x1B[4:1m",
-		double: "\x1B[4:2m",
-		curly: "\x1B[4:3m",
-		dotted: "\x1B[4:4m",
-		dashed: "\x1B[4:5m",
-		reset: "\x1B[4:0m"
-	};
-	UNDERLINE_STANDARD = "\x1B[4m";
-	UNDERLINE_RESET_STANDARD = "\x1B[24m";
-	UNDERLINE_COLOR_RESET = "\x1B[59m";
-}));
 //#endregion
 //#region packages/ansi/src/caps.ts
 /**
@@ -63,7 +74,6 @@ function defaultCaps() {
 		maybeWideEmojis: true
 	};
 }
-var init_caps = __esmMin((() => {}));
 //#endregion
 //#region packages/ansi/src/emulator.ts
 /**
@@ -77,7 +87,6 @@ function defaultEmulator() {
 		TERM: ""
 	};
 }
-var init_emulator = __esmMin((() => {}));
 //#endregion
 //#region packages/ansi/src/theme/invariants.ts
 /**
@@ -105,6 +114,187 @@ var init_emulator = __esmMin((() => {}));
 * bakeFlat pipeline. No concat-kebab legacy names (`primaryfg`, `mutedbg`, …)
 * — those were removed in silvery 0.19.0 (Sterling interior migration).
 */
+const AA_RATIO = 4.5;
+const FAINT_RATIO = 1.5;
+const SELECTION_DELTA_L$1 = .08;
+const CURSOR_DELTA_E$1 = .15;
+/**
+* Contrast invariant pairs — all Sterling flat-token keys.
+*
+* These keys are populated on every Theme at derivation time via `bakeFlat`;
+* bracket access (`theme["bg-accent"]`) is the canonical lookup form and is
+* what `validateThemeInvariants` uses below.
+*/
+const CONTRAST_PAIRS = [
+	{
+		rule: "contrast:fg/bg",
+		fg: "fg",
+		bg: "bg",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg/bg-surface-default",
+		fg: "fg",
+		bg: "bg-surface-default",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg/bg-surface-subtle",
+		fg: "fg",
+		bg: "bg-surface-subtle",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg/bg-surface-raised",
+		fg: "fg",
+		bg: "bg-surface-raised",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg/bg-surface-hover",
+		fg: "fg",
+		bg: "bg-surface-hover",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg/bg-surface-overlay",
+		fg: "fg",
+		bg: "bg-surface-overlay",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg/bg-muted",
+		fg: "fg",
+		bg: "bg-muted",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg-muted/bg",
+		fg: "fg-muted",
+		bg: "bg",
+		min: 3
+	},
+	{
+		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-on-inverse/bg-inverse",
+		fg: "fg-on-inverse",
+		bg: "bg-inverse",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg-on-inverse/bg-inverse-hover",
+		fg: "fg-on-inverse",
+		bg: "bg-inverse-hover",
+		min: AA_RATIO
+	},
+	{
+		rule: "contrast:fg-on-inverse-muted/bg-inverse",
+		fg: "fg-on-inverse-muted",
+		bg: "bg-inverse",
+		min: 3
+	},
+	{
+		rule: "contrast:fg-on-inverse-muted/bg-inverse-hover",
+		fg: "fg-on-inverse-muted",
+		bg: "bg-inverse-hover",
+		min: 3
+	},
+	{
+		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
+	}
+];
 function lightness(hex) {
 	const o = hexToOklch(hex);
 	return o ? o.L : null;
@@ -196,167 +386,18 @@ 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$1, CURSOR_DELTA_E$1, CONTRAST_PAIRS, ThemeInvariantError;
-var init_invariants = __esmMin((() => {
-	AA_RATIO = 4.5;
-	FAINT_RATIO = 1.5;
-	SELECTION_DELTA_L$1 = .08;
-	CURSOR_DELTA_E$1 = .15;
-	CONTRAST_PAIRS = [
-		{
-			rule: "contrast:fg/bg",
-			fg: "fg",
-			bg: "bg",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-surface-default",
-			fg: "fg",
-			bg: "bg-surface-default",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-surface-subtle",
-			fg: "fg",
-			bg: "bg-surface-subtle",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-surface-raised",
-			fg: "fg",
-			bg: "bg-surface-raised",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-surface-hover",
-			fg: "fg",
-			bg: "bg-surface-hover",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-surface-overlay",
-			fg: "fg",
-			bg: "bg-surface-overlay",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg/bg-muted",
-			fg: "fg",
-			bg: "bg-muted",
-			min: AA_RATIO
-		},
-		{
-			rule: "contrast:fg-muted/bg",
-			fg: "fg-muted",
-			bg: "bg",
-			min: 3
-		},
-		{
-			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;
-		}
-	};
-}));
+/**
+* Thrown by `loadTheme({ mode: "strict" })` when invariants fail.
+* Carries the violations array for programmatic inspection.
+*/
+var 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
 /**
@@ -372,6 +413,40 @@ var init_invariants = __esmMin((() => {
 * Canonical authority: derive.ts truecolor path. ANSI16 paths are aligned to
 * deriveAnsi16Theme output (which is itself the canonical ANSI16 reference).
 */
+/** Default typography variants — token-based, works across any theme. */
+const DEFAULT_VARIANTS$1 = {
+	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: "$fg-link",
+		underlineStyle: "single"
+	},
+	key: {
+		color: "$accent",
+		bold: true
+	},
+	code: { backgroundColor: "$mutedbg" },
+	kbd: {
+		backgroundColor: "$mutedbg",
+		color: "$accent",
+		bold: true
+	}
+};
 /**
 * Derive the shared "delta" fields common to every theme object:
 * brand tokens, categorical ring, state variants, and typography variants.
@@ -408,42 +483,6 @@ function deriveFields(input) {
 		variants: DEFAULT_VARIANTS$1
 	};
 }
-var DEFAULT_VARIANTS$1;
-var init_derived = __esmMin((() => {
-	DEFAULT_VARIANTS$1 = {
-		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: "$fg-link",
-			underlineStyle: "single"
-		},
-		key: {
-			color: "$accent",
-			bold: true
-		},
-		code: { backgroundColor: "$mutedbg" },
-		kbd: {
-			backgroundColor: "$mutedbg",
-			color: "$accent",
-			bold: true
-		}
-	};
-}));
 //#endregion
 //#region packages/ansi/src/sterling/contrast.ts
 /**
@@ -460,6 +499,18 @@ var init_derived = __esmMin((() => {
 * from auto-lift and from strict-mode enforcement — the author accepts the
 * contrast consequence of pinning.
 */
+/** WCAG AA threshold for normal text. */
+const WCAG_AA = 4.5;
+var ContrastError = class extends Error {
+	violations;
+	constructor(violations) {
+		const summary = violations.slice(0, 5).map((v) => `${v.token}: ${v.ratio.toFixed(2)} < ${v.target} (fg=${v.fg}, bg=${v.bg})`).join("; ");
+		const extra = violations.length > 5 ? ` (+${violations.length - 5} more)` : "";
+		super(`Sterling contrast: ${violations.length} violation(s): ${summary}${extra}`);
+		this.name = "ContrastError";
+		this.violations = violations;
+	}
+};
 /**
 * Verify `fg` on `bg` meets `target` ratio. Returns `null` when already
 * passing; otherwise returns a ContrastViolation.
@@ -502,20 +553,6 @@ function autoLift(fg, bg, target = WCAG_AA) {
 		lifted: adjusted !== fg
 	};
 }
-var WCAG_AA, ContrastError;
-var init_contrast = __esmMin((() => {
-	WCAG_AA = 4.5;
-	ContrastError = class extends Error {
-		violations;
-		constructor(violations) {
-			const summary = violations.slice(0, 5).map((v) => `${v.token}: ${v.ratio.toFixed(2)} < ${v.target} (fg=${v.fg}, bg=${v.bg})`).join("; ");
-			const extra = violations.length > 5 ? ` (+${violations.length - 5} more)` : "";
-			super(`Sterling contrast: ${violations.length} violation(s): ${summary}${extra}`);
-			this.name = "ContrastError";
-			this.violations = violations;
-		}
-	};
-}));
 //#endregion
 //#region packages/ansi/src/sterling/derive.ts
 /**
@@ -545,6 +582,59 @@ var init_contrast = __esmMin((() => {
 * auto-lift; they're written verbatim onto the Theme.
 */
 /**
+* Default typography variants — token-based, works across any Sterling theme.
+* Consumed by `<Text variant="h1">` via the theme's `variants` record.
+*
+* Keys use Sterling flat-token names in their color slots (`$fg-accent`,
+* `$fg-muted`, `$bg-muted`) so the defaults resolve against every Sterling-
+* derived Theme without further wiring.
+*/
+const DEFAULT_VARIANTS = {
+	h1: {
+		color: "$fg-accent",
+		bold: true
+	},
+	h2: {
+		color: "$fg-accent",
+		bold: true
+	},
+	h3: { bold: true },
+	h4: {
+		color: "$fg-muted",
+		bold: true
+	},
+	h5: {
+		color: "$fg-muted",
+		italic: true
+	},
+	h6: {
+		color: "$fg-muted",
+		dim: true
+	},
+	body: {},
+	"body-muted": { color: "$fg-muted" },
+	"fine-print": {
+		color: "$fg-muted",
+		dim: true
+	},
+	strong: { bold: true },
+	em: { italic: true },
+	link: {
+		color: "$fg-accent",
+		underlineStyle: "single"
+	},
+	key: {
+		color: "$fg-accent",
+		bold: true
+	},
+	code: { backgroundColor: "$bg-muted" },
+	kbd: {
+		backgroundColor: "$bg-muted",
+		color: "$fg-accent",
+		bold: true
+	}
+};
+/**
 * Build the 16-slot ANSI palette from a ColorScheme. Indexed `$color0` …
 * `$color15` by the framework's token resolver.
 */
@@ -734,6 +824,35 @@ function guardTarget(nestedPath, flatPath, rule, inputs, value, against, target,
 	});
 	return finalValue;
 }
+/** Whether a foreground clears `target` against every supplied surface. */
+function clearsEverySurface(value, surfaces, target) {
+	return surfaces.every((surface) => checkAA("contrast-bounded mix", value, surface, target) === null);
+}
+/**
+* Preserve an alpha-like sRGB mix as far as its readability budget allows.
+*
+* `maxMix` is the desired amount of `toward` color. When that exact mix falls
+* below the contrast floor on either surface, binary-search back toward the
+* readable foreground and return the most-deemphasized passing hex. This keeps
+* muted text on the same color line instead of allowing a generic contrast
+* repair to flip it to the opposite light/dark pole.
+*/
+function mixSrgbWithContrastFloor(foreground, toward, maxMix, surfaces, target) {
+	const desired = mixSrgb(foreground, toward, maxMix);
+	if (clearsEverySurface(desired, surfaces, target)) return desired;
+	let passingMix = 0;
+	let failingMix = maxMix;
+	let best = foreground;
+	for (let step = 0; step < 16; step++) {
+		const candidateMix = (passingMix + failingMix) / 2;
+		const candidate = mixSrgb(foreground, toward, candidateMix);
+		if (clearsEverySurface(candidate, surfaces, target)) {
+			passingMix = candidateMix;
+			best = candidate;
+		} else failingMix = candidateMix;
+	}
+	return best;
+}
 /**
 * Derive a Theme's nested roles from a ColorScheme. Guardrails applied.
 */
@@ -783,6 +902,7 @@ function deriveRoles(scheme, opts) {
 		fg: guard("muted.fg", "fg-muted", "blend(fg, bg, 0.4)", [fg, bg], blend(fg, bg, .4), mutedBg, 3),
 		bg: mutedBg
 	};
+	const faint = { fg: guard("faint.fg", "fg-faint", "blend(fg, bg, 0.55)", [fg, bg], blend(fg, bg, .55), mutedBg, 1.5) };
 	const fgForSurfaceLift = ensureContrast(fg, blend(bg, fg, .08), WCAG_AA);
 	const surfaceDefault = guard("surface.default", "bg-surface-default", "scheme.background", [bg], bg);
 	const surface = {
@@ -812,9 +932,19 @@ function deriveRoles(scheme, opts) {
 		hover: { bg: guard("selected.hover.bg", "bg-selected-hover", `OKLCH ${shiftLabel(selectedBg)} ${selectedDeltaH.hover}L on selected.bg`, [selectedBg], shiftL(selectedBg, selectedDeltaH.hover)) }
 	};
 	const inverseBg = guard("inverse.bg", "bg-inverse", "blend(fg, bg, 0.1)", [fg, bg], blend(fg, bg, .1));
+	const inverseFgOn = guard("inverse.fgOn", "fg-on-inverse", "contrast-pick(scheme.fg/bg/BW)", [inverseBg], pickFgOn(inverseBg, scheme), inverseBg);
+	const inverseHoverBg = guard("inverse.hover.bg", "bg-inverse-hover", "mixSrgb(inverse.bg, inverse.fgOn, 0.1)", [inverseBg, inverseFgOn], mixSrgb(inverseBg, inverseFgOn, .1), inverseFgOn);
+	const inverseMutedCandidate = mixSrgbWithContrastFloor(inverseFgOn, inverseBg, .35, [inverseBg, inverseHoverBg], 3);
+	const inverseMutedFgOn = guard("inverse.muted.fgOn", "fg-on-inverse-muted", "mixSrgb(inverse.fgOn, inverse.bg, ≤0.35), bounded to ≥3:1 on inverse surfaces", [
+		inverseFgOn,
+		inverseBg,
+		inverseHoverBg
+	], inverseMutedCandidate, inverseBg, 3);
 	const inverse = {
 		bg: inverseBg,
-		fgOn: guard("inverse.fgOn", "fg-on-inverse", "contrast-pick(scheme.fg/bg/BW)", [inverseBg], pickFgOn(inverseBg, scheme), inverseBg)
+		fgOn: inverseFgOn,
+		hover: { bg: inverseHoverBg },
+		muted: { fgOn: inverseMutedFgOn }
 	};
 	const link = { fg: guard("link.fg", "fg-link", mode === "dark" ? "scheme.brightBlue" : "scheme.blue", [mode === "dark" ? scheme.brightBlue : scheme.blue], mode === "dark" ? scheme.brightBlue : scheme.blue, bg) };
 	const fgDisabledRaw = blend(surfaceDefault, fg, .38);
@@ -828,6 +958,7 @@ function deriveRoles(scheme, opts) {
 			warning,
 			error,
 			muted,
+			faint,
 			surface,
 			border,
 			cursor,
@@ -845,6 +976,7 @@ function deriveRoles(scheme, opts) {
 		violations
 	};
 }
+const SELECTION_DELTA_L = .08;
 /**
 * Nudge selectionBg's OKLCH L until it differs from bg by ≥ SELECTION_DELTA_L.
 * Mirrors the legacy theme's repairSelectionBg behavior — preserves hue +
@@ -865,6 +997,7 @@ function repairSelectionBg$1(selectionBg, bg) {
 		H: oSel.H
 	});
 }
+const CURSOR_DELTA_E = .15;
 /**
 * Nudge cursorBg's OKLCH L until it differs from bg by ≥ CURSOR_DELTA_E
 * (perceptual distance, not just lightness). Preserves hue + chroma but
@@ -979,57 +1112,6 @@ function mergePartial(base, patch) {
 	}
 	return out;
 }
-var DEFAULT_VARIANTS, SELECTION_DELTA_L, CURSOR_DELTA_E;
-var init_derive$1 = __esmMin((() => {
-	init_contrast();
-	DEFAULT_VARIANTS = {
-		h1: {
-			color: "$fg-accent",
-			bold: true
-		},
-		h2: {
-			color: "$fg-accent",
-			bold: true
-		},
-		h3: { bold: true },
-		h4: {
-			color: "$fg-muted",
-			bold: true
-		},
-		h5: {
-			color: "$fg-muted",
-			italic: true
-		},
-		h6: {
-			color: "$fg-muted",
-			dim: true
-		},
-		body: {},
-		"body-muted": { color: "$fg-muted" },
-		"fine-print": {
-			color: "$fg-muted",
-			dim: true
-		},
-		strong: { bold: true },
-		em: { italic: true },
-		link: {
-			color: "$fg-accent",
-			underlineStyle: "single"
-		},
-		key: {
-			color: "$fg-accent",
-			bold: true
-		},
-		code: { backgroundColor: "$bg-muted" },
-		kbd: {
-			backgroundColor: "$bg-muted",
-			color: "$fg-accent",
-			bold: true
-		}
-	};
-	SELECTION_DELTA_L = .08;
-	CURSOR_DELTA_E = .15;
-}));
 //#endregion
 //#region packages/ansi/src/sterling/inline.ts
 /**
@@ -1191,6 +1273,8 @@ function inlineSterlingTokens(theme, scheme) {
 		setIfAbsent("fg-muted", m.fg);
 		setIfAbsent("bg-muted", m.bg);
 	}
+	const ft = roles.faint;
+	if (ft) setIfAbsent("fg-faint", ft.fg);
 	const sel = roles.selected;
 	if (sel) {
 		setIfAbsent("bg-selected", sel.bg);
@@ -1201,6 +1285,8 @@ function inlineSterlingTokens(theme, scheme) {
 	if (inv) {
 		setIfAbsent("bg-inverse", inv.bg);
 		setIfAbsent("fg-on-inverse", inv.fgOn);
+		setIfAbsent("bg-inverse-hover", inv.hover.bg);
+		setIfAbsent("fg-on-inverse-muted", inv.muted.fgOn);
 	}
 	const lnk = roles.link;
 	if (lnk) setIfAbsent("fg-link", lnk.fg);
@@ -1217,9 +1303,6 @@ function inlineSterlingTokens(theme, scheme) {
 	setIfAbsent("bg-backdrop", blend(src.background, "#000000", .4));
 	return out;
 }
-var init_inline = __esmMin((() => {
-	init_derive$1();
-}));
 //#endregion
 //#region packages/ansi/src/theme/derive.ts
 /**
@@ -1268,6 +1351,10 @@ function loadTheme(palette, opts = {}) {
 	}
 	return theme;
 }
+const AA$1 = 4.5;
+const DIM = 3;
+const FAINT$1 = 1.5;
+const CONTROL = 3;
 /**
 * Build a "raw" Theme with legacy single-hex role fields. The output is NOT a
 * complete Sterling Theme — Sterling roles + flat tokens are layered on by
@@ -1518,78 +1605,81 @@ function repairCursorBg(cursorBg, bg) {
 	if (d2 !== null && d2 >= .15) return candidate;
 	return oBg.L > .5 ? "#000000" : "#FFFFFF";
 }
-var AA$1, DIM, FAINT$1, CONTROL;
-var init_derive = __esmMin((() => {
-	init_invariants();
-	init_derived();
-	init_inline();
-	AA$1 = 4.5;
-	DIM = 3;
-	FAINT$1 = 1.5;
-	CONTROL = 3;
-}));
 //#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);
-}));
+const 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"
+};
+const 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"
+};
+/**
+* Dark ANSI 16 theme — hex-valued, derived from the default dark scheme.
+*
+* All token values are hex strings. Terminal rendering quantizes hex to
+* 4-bit ANSI codes at paint time when colorLevel === "ansi16".
+*/
+const ansi16DarkTheme = deriveAnsi16Theme(defaultDarkScheme);
+/**
+* Light ANSI 16 theme — hex-valued, derived from the default light scheme.
+*
+* All token values are hex strings. Terminal rendering quantizes hex to
+* 4-bit ANSI codes at paint time when colorLevel === "ansi16".
+*/
+const ansi16LightTheme = deriveAnsi16Theme(defaultLightScheme);
 //#endregion
 //#region packages/ansi/src/osc-palette.ts
+/**
+* OSC 4 Terminal Color Palette Query/Set — pure ANSI protocol.
+*/
+const ESC$4 = "\x1B";
+const BEL$2 = "\x07";
 function queryPaletteColor(index, write) {
 	if (index < 0 || index > 255) throw new RangeError(`Palette index must be 0-255, got ${index}`);
 	write(`${ESC$4}]4;${index};?${BEL$2}`);
@@ -1601,6 +1691,8 @@ function setPaletteColor(index, color, write) {
 	if (index < 0 || index > 255) throw new RangeError(`Palette index must be 0-255, got ${index}`);
 	write(`${ESC$4}]4;${index};${color}${BEL$2}`);
 }
+const OSC4_PREFIX = `${ESC$4}]4;`;
+const OSC4_BODY_RE = /^(\d+);rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})$/;
 function parsePaletteResponse(input) {
 	const prefixIdx = input.indexOf(OSC4_PREFIX);
 	if (prefixIdx === -1) return null;
@@ -1625,41 +1717,79 @@ function normalizeHexChannel$1(hex) {
 		default: return hex.slice(0, 2);
 	}
 }
-var ESC$4, BEL$2, OSC4_PREFIX, OSC4_BODY_RE;
-var init_osc_palette = __esmMin((() => {
-	ESC$4 = "\x1B";
-	BEL$2 = "\x07";
-	OSC4_PREFIX = `${ESC$4}]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/protocol-error.ts
+/**
+* ProtocolError — structured error for terminal protocol parse failures.
+*
+* Used by parsers to signal that input WAS identified as belonging to this
+* protocol (prefix/marker matched) but is malformed in a way the parser
+* cannot recover from (missing terminator, invalid base64, missing required
+* field, etc.).
+*
+* Distinct from a `null` return:
+*
+* - `null` = "no input matched, but input was valid" — the parser does not
+*   recognize this input as belonging to its protocol family at all (no
+*   prefix, no marker). Used by discriminator chains to mean "next parser
+*   please."
+*
+* - `throw ProtocolError` = "this WAS for us but is broken" — the parser
+*   committed to the protocol (prefix matched), then the body failed
+*   validation. Callers should log and continue, NOT crash.
+*
+* Carries structured context so callers can route, dedupe, and log
+* without re-parsing the raw bytes:
+*
+* - `parser` — name of the parser that threw (e.g. "parseClipboardResponse")
+* - `input` — raw input bytes (truncated for safety; full length retained
+*   in `inputLength`)
+* - `reason` — short human-readable description of why-invalid
+*
+* Acceptance for bead `@km/silvery/15127-custom-protocol-implementation/
+* protocol-loud-errors`: parsers must fail loudly on protocol violation
+* instead of silently dropping malformed input.
+*
+* @module
+*/
+/** Maximum chars of raw input retained on the error (rest is truncated). */
+const INPUT_TRUNCATE_LENGTH = 256;
+/**
+* Thrown by protocol parsers when input is identified as belonging to the
+* protocol but is malformed.
+*
+* Callers (dispatch boundaries in `runtime/input-owner.ts`, `renderer.ts`,
+* and similar) should catch ProtocolError, log via the appropriate logger,
+* and continue — never let a protocol parse error crash the app.
+*/
+var ProtocolError = class extends Error {
+	name = "ProtocolError";
+	parser;
+	input;
+	inputLength;
+	reason;
+	constructor(opts) {
+		const inputLength = opts.input.length;
+		const truncated = inputLength > INPUT_TRUNCATE_LENGTH ? `${opts.input.slice(0, INPUT_TRUNCATE_LENGTH)}…<${inputLength - INPUT_TRUNCATE_LENGTH} more chars>` : opts.input;
+		super(`${opts.parser}: ${opts.reason} (input=${JSON.stringify(truncated)})`);
+		this.parser = opts.parser;
+		this.input = truncated;
+		this.inputLength = inputLength;
+		this.reason = opts.reason;
+	}
+};
 /** Narrowing helper — true if `err` is a ProtocolError. */
 function isProtocolError(err) {
 	return err instanceof ProtocolError;
 }
-var INPUT_TRUNCATE_LENGTH, ProtocolError;
-var init_protocol_error = __esmMin((() => {
-	INPUT_TRUNCATE_LENGTH = 256;
-	ProtocolError = class extends Error {
-		name = "ProtocolError";
-		parser;
-		input;
-		inputLength;
-		reason;
-		constructor(opts) {
-			const inputLength = opts.input.length;
-			const truncated = inputLength > INPUT_TRUNCATE_LENGTH ? `${opts.input.slice(0, INPUT_TRUNCATE_LENGTH)}…<${inputLength - INPUT_TRUNCATE_LENGTH} more chars>` : opts.input;
-			super(`${opts.parser}: ${opts.reason} (input=${JSON.stringify(truncated)})`);
-			this.parser = opts.parser;
-			this.input = truncated;
-			this.inputLength = inputLength;
-			this.reason = opts.reason;
-		}
-	};
-}));
 //#endregion
 //#region packages/ansi/src/osc-colors.ts
+/**
+* OSC 10/11/12 Terminal Color Queries — pure ANSI protocol.
+*/
+const ESC$3 = "\x1B";
+const BEL$1 = "\x07";
+const RGB_BODY_RE$1 = /rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})/;
 function normalizeHexChannel(hex) {
 	switch (hex.length) {
 		case 1: return hex + hex;
@@ -1743,13 +1873,6 @@ async function detectColorScheme(write, read, timeoutMs = 200) {
 	const b = parseInt(bg.slice(5, 7), 16) / 255;
 	return .2126 * r + .7152 * g + .0722 * b > .5 ? "light" : "dark";
 }
-var ESC$3, BEL$1, RGB_BODY_RE$1;
-var init_osc_colors = __esmMin((() => {
-	init_protocol_error();
-	ESC$3 = "\x1B";
-	BEL$1 = "\x07";
-	RGB_BODY_RE$1 = /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
 /**
@@ -1872,6 +1995,9 @@ async function probeColors(timeoutOrOpts) {
 		if (didSetRaw) stdin.setRawMode(false);
 	}
 }
+const ESC$2 = "\x1B";
+const BEL = "\x07";
+const RGB_BODY_RE = /rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})/;
 /** OSC response parser for a specific OSC code (10 or 11). Returns the
 * first matching response in the buffer and the byte count to consume
 * (the end of that response, so leading garbage is cleared as well).
@@ -1988,6 +2114,13 @@ async function probeColorsViaOwner(input, timeoutMs) {
 		palette
 	};
 }
+/**
+* Legacy alias for {@link probeColors}. Prefer `probeColors` in new code —
+* the name says what it does (probes terminal color slots), and "detect" is
+* reserved for the full cascade (`detectScheme`, `detectTheme`). Retained
+* as a stable alias — no deprecation schedule.
+*/
+const detectTerminalScheme = probeColors;
 async function detectTheme(opts = {}) {
 	const colorLevel = opts.caps?.colorLevel;
 	if (colorLevel === "mono" || colorLevel === "ansi16") return opts.caps?.darkBackground ?? true ? ansi16DarkTheme : ansi16LightTheme;
@@ -2014,19 +2147,229 @@ function isDarkColor(hex) {
 	const b = parseInt(hex.slice(5, 7), 16) / 255;
 	return .2126 * r + .7152 * g + .0722 * b <= .5;
 }
-var ESC$2, BEL, RGB_BODY_RE, detectTerminalScheme;
-var init_detect = __esmMin((() => {
-	init_derive();
-	init_default_schemes();
-	init_osc_palette();
-	init_osc_colors();
-	ESC$2 = "\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})/;
-	detectTerminalScheme = probeColors;
-}));
+//#endregion
+//#region packages/ansi/src/kitty-graphics-probe.ts
+const APC = "\x1B_G";
+const ST = "\x1B\\";
+/**
+* The image id used for the support query. Chosen well above the runtime image
+* id range (1..255) so a probe ack can never be confused with a real image's
+* response.
+*/
+const KITTY_PROBE_ID = 7777;
+/**
+* Parse a Kitty graphics query response for {@link KITTY_PROBE_ID}.
+*
+*   - `{ result: true }`  — `\x1b_Gi=<id>;OK\x1b\` → graphics supported.
+*   - `{ result: false }` — a well-formed response for our id that is NOT `OK`
+*                           (the terminal parsed the APC but rejected the query).
+*   - `null`              — no complete response for our id yet (the probe keeps
+*                           waiting; on timeout the caller treats this as
+*                           unsupported).
+*/
+function parseKittyGraphicsResponse(acc, id) {
+	const prefix = `${APC}i=${id};`;
+	const start = acc.indexOf(prefix);
+	if (start === -1) return null;
+	const bodyStart = start + prefix.length;
+	const end = acc.indexOf(ST, bodyStart);
+	if (end === -1) return null;
+	return {
+		result: acc.slice(bodyStart, end).trim() === "OK",
+		consumed: end + 2
+	};
+}
+/**
+* Probe the terminal at runtime for Kitty graphics support. Resolves:
+*   - `true`      — the terminal acknowledged it can paint Kitty graphics.
+*   - `false`     — a non-`OK` response (the protocol is understood but refused).
+*   - `undefined` — no response within `timeoutMs` (the terminal does not speak
+*                   the protocol, or a proxy/capture that cannot paint it).
+*
+* The query is a 1×1 RGB query-only command, harmless to a terminal that ignores
+* unknown APC sequences. Routed through the session's {@link ProbeInputOwner}
+* (never `process.stdin` directly) so it is safe inside a running TUI.
+*/
+async function probeKittyGraphics(input, timeoutMs = 150) {
+	const query = `${APC}i=${KITTY_PROBE_ID},s=1,v=1,a=q,t=d,f=24;AAAA${ST}`;
+	return await input.probe({
+		query,
+		timeoutMs,
+		parse: (acc) => parseKittyGraphicsResponse(acc, 7777)
+	}) ?? void 0;
+}
 //#endregion
 //#region packages/ansi/src/color-maps.ts
+/** Modifier SGR codes: open -> close */
+const 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]
+};
+/** Foreground color name -> ANSI SGR code */
+const 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
+};
+/** Background color name -> ANSI SGR code */
+const 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
+};
+/** Standard ANSI 16 color RGB values for nearest-color matching.
+* Uses xterm-256 standard values for consistent mapping (matches chalk/ansi-styles). */
+const 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
+	]
+];
+/**
+* Canonical hex values for the 16 standard ANSI color slots.
+*
+* These are the xterm-256 reference values — the same RGB values used by
+* `nearestAnsi16` for quantization. Used to convert ANSI16 slot-name themes
+* (e.g., "yellow") into hex-valued themes (e.g., "#808000") so Theme objects
+* are pure hex across all tiers.
+*
+* Terminal-rendering behavior is unchanged: the output phase reads `colorLevel`
+* and emits 4-bit ANSI codes when `colorLevel === "basic"` — the hex value is
+* only carried in the Theme object itself, not emitted verbatim.
+*/
+const 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"
+};
 /** Find nearest ANSI 16 color index for an RGB value. */
 function nearestAnsi16(r, g, b) {
 	let bestIdx = 0;
@@ -2161,6 +2504,11 @@ function quantizeHex(hex, tier) {
 	}
 	return (.2126 * r + .7152 * g + .0722 * b) / 255 >= .5 ? "#ffffff" : "#000000";
 }
+/**
+* Hex-regex used to detect hex leaves during tier quantization walks.
+* Matches `#rgb` and `#rrggbb` (case-insensitive).
+*/
+const HEX_LEAF_RE$1 = /^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/;
 function isHexLeaf$1(value) {
 	return typeof value === "string" && HEX_LEAF_RE$1.test(value);
 }
@@ -2220,171 +2568,34 @@ function pickColorLevelWalk(obj, tier) {
 	}
 	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/profile.ts
 /**
+* Terminal profile — single source of truth for terminal detection.
+*
+* One function, one profile. Collapses the previously redundant trio of
+* `detectColor()`, `detectTerminalCaps()`, and `resolveColorTier()` into a
+* single entry point: {@link createTerminalProfile}.
+*
+* Phase 3 of `km-silvery.terminal-profile-plateau`. Phase 4 (unify entry
+* points) will thread the profile through `run()`, `createApp().run()`, and
+* `render()` so every Term instance is populated from one detection pass.
+*
+* Post km-silvery.plateau-naming-polish (2026-04-23): 2-layer shape —
+* `profile.caps` (protocol flags + `maybe*` heuristics) and `profile.emulator`
+* (program/version/TERM). The former `profile.heuristics` namespace was
+* absorbed into caps with a `maybe` prefix per-field.
+*
+* Phase 7 of `km-silvery.caps-restructure` (Pro verdict 2026-04-23) originally
+* split the flat `TerminalCaps` into three layers; the heuristics layer proved
+* too small to earn its own namespace and was collapsed in the naming polish.
+*/
+/**
 * Build a {@link TerminalProfile} from the current environment.
 *
 * Priority for the final `colorLevel` (highest wins):
-*   1. `NO_COLOR` env var → `"mono"`
-*   2. `FORCE_COLOR` env var → `0/false → mono, 1 → ansi16, 2 → 256, 3 → truecolor`
+*   1. `FORCE_COLOR` env var → `0/false → mono, 1 → ansi16, 2 → 256, 3 → truecolor`
+*   2. `NO_COLOR` env var → `"mono"`
 *   3. `options.colorLevel` (caller-supplied explicit tier)
 *   4. `options.caps.colorLevel` (base caps' pre-detected tier)
 *   5. Auto-detected tier from env (TERM, COLORTERM, TERM_PROGRAM, …)
@@ -2407,7 +2618,7 @@ var init_color_maps = __esmMin((() => {
 * const profile = createTerminalProfile()
 * console.log(profile.colorLevel) // "truecolor" on Ghostty
 *
-* // Force a tier (still honors NO_COLOR / FORCE_COLOR env precedence)
+* // Force a tier (still honors FORCE_COLOR / NO_COLOR env precedence)
 * const forced = createTerminalProfile({ colorLevel: "256" })
 *
 * // Term path — base caps already detected, just resolve color tier.
@@ -2530,6 +2741,8 @@ function freezeProfileInDev(profile) {
 async function probeTerminalProfile(options = {}) {
 	const profile = createTerminalProfile(options);
 	if (options.probeTheme === false) return profile;
+	let kittyGraphics = profile.caps.kittyGraphics;
+	if (kittyGraphics && options.input) kittyGraphics = await probeKittyGraphics(options.input, options.timeoutMs ?? 150) === true;
 	const theme = await detectTheme({
 		caps: profile.caps,
 		fallbackDark: options.fallbackDark,
@@ -2538,8 +2751,13 @@ async function probeTerminalProfile(options = {}) {
 		input: options.input
 	});
 	const resolvedTheme = profile.caps.colorForced ? pickColorLevel(theme, profile.colorLevel) : theme;
+	const caps = kittyGraphics === profile.caps.kittyGraphics ? profile.caps : {
+		...profile.caps,
+		kittyGraphics
+	};
 	return freezeProfileInDev({
 		...profile,
+		caps,
 		theme: resolvedTheme
 	});
 }
@@ -2549,15 +2767,8 @@ async function probeTerminalProfile(options = {}) {
 * `process.env` twice.
 */
 function detectColorFromEnv(env, stdout) {
-	if (env.NO_COLOR !== void 0) return "mono";
-	const forceColor = env.FORCE_COLOR;
-	if (forceColor !== void 0) {
-		if (forceColor === "0" || forceColor === "false") return "mono";
-		if (forceColor === "1") return "ansi16";
-		if (forceColor === "2") return "256";
-		if (forceColor === "3") return "truecolor";
-		return "ansi16";
-	}
+	const envTier = envColorTier(env);
+	if (envTier !== void 0) return envTier;
 	if (!stdout.isTTY) return "mono";
 	if (env.TERM === "dumb") return "mono";
 	const colorTerm = env.COLORTERM;
@@ -2580,7 +2791,6 @@ function detectColorFromEnv(env, stdout) {
 * env always beats caller-supplied overrides.
 */
 function envColorTier(env) {
-	if (env.NO_COLOR !== void 0) return "mono";
 	const force = env.FORCE_COLOR;
 	if (force !== void 0) {
 		if (force === "0" || force === "false") return "mono";
@@ -2589,6 +2799,7 @@ function envColorTier(env) {
 		if (force === "3") return "truecolor";
 		return "ansi16";
 	}
+	if (env.NO_COLOR !== void 0) return "mono";
 }
 /**
 * Deterministic env-based detection of the full two-layer profile
@@ -2604,7 +2815,7 @@ function detectTerminalProfileFromEnv(env, stdout) {
 	const TERM = env.TERM ?? "";
 	const noColor = env.NO_COLOR !== void 0;
 	const isAppleTerminal = programLower === "apple_terminal";
-	const colorLevel = noColor ? "mono" : detectColorFromEnv(env, stdout);
+	const colorLevel = detectColorFromEnv(env, stdout);
 	const isKitty = TERM === "xterm-kitty";
 	const isITerm = programLower === "iterm.app";
 	const isGhostty = programLower === "ghostty";
@@ -2664,7 +2875,7 @@ function detectTerminalProfileFromEnv(env, stdout) {
 			sixel: !isDumb && (isFoot || isWezTerm),
 			osc52: isModern || !isDumb && isAlacritty,
 			hyperlinks: isModern || !isDumb && isAlacritty,
-			notifications: isITerm || isKitty,
+			notifications: isDumb ? false : isKitty ? "osc99" : isITerm ? "osc9" : isGhostty || isWezTerm || isFoot ? "osc777" : false,
 			syncOutput: isModern || !isDumb && isAlacritty,
 			maybeDarkBackground,
 			maybeNerdFont,
@@ -2688,10 +2899,20 @@ function utf8Locale(env) {
 function termImpliesUnicode(term) {
 	return term.includes("xterm") || term.includes("rxvt") || term.includes("screen") || term.includes("tmux");
 }
+const CI_ENVS = [
+	"CI",
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"JENKINS_URL",
+	"BUILDKITE",
+	"CIRCLECI",
+	"TRAVIS"
+];
+let cachedMacOSDarkMode;
 function detectMacOSDarkMode() {
 	if (cachedMacOSDarkMode !== void 0) return cachedMacOSDarkMode;
 	try {
-		const { spawnSync } = __require("child_process");
+		const { spawnSync } = process.getBuiltinModule("node:child_process");
 		cachedMacOSDarkMode = spawnSync("defaults", [
 			"read",
 			"-g",
@@ -2705,60 +2926,76 @@ function detectMacOSDarkMode() {
 	}
 	return cachedMacOSDarkMode;
 }
-var CI_ENVS, cachedMacOSDarkMode;
-var init_profile = __esmMin((() => {
-	init_caps();
-	init_emulator();
-	init_detect();
-	init_color_maps();
-	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.
+* Marker bit for the PACKED numeric truecolor form: `0x1000000 | r<<16 | g<<8 | b`.
+* ag-term's ANSI parser (unicode.ts) tracks inline truecolor SGR in this compact
+* form, and those numbers reach fg/bgColorCode via styleToAnsiCodes when wrapped
+* text re-emits carried styles (fixSgrAcrossWrappedLines).
 */
+const PACKED_TRUECOLOR = 16777216;
+/** The palette slot for a color, or `undefined` for a genuine truecolor. */
+function paletteSlot(color) {
+	const idx = typeof color === "number" ? color : color.index;
+	return typeof idx === "number" && idx >= 0 && idx <= 255 ? idx : void 0;
+}
+/** Resolve a non-palette color to truecolor components, unpacking the packed numeric form. */
+function truecolorRgb(color) {
+	if (typeof color === "number") {
+		if (color >= PACKED_TRUECOLOR && color <= 33554431) return {
+			r: color >> 16 & 255,
+			g: color >> 8 & 255,
+			b: color & 255
+		};
+		throw new Error(`sgr-codes: number ${color} is neither a palette slot (0-255) nor a packed truecolor (0x1000000|rgb)`);
+	}
+	return 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)
+* - RGB (no palette index): 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}`;
+	const slot = paletteSlot(color);
+	if (slot !== void 0) {
+		if (slot <= 7) return `${30 + slot}`;
+		return `38;5;${slot}`;
 	}
-	return `38;2;${color.r};${color.g};${color.b}`;
+	const { r, g, b } = truecolorRgb(color);
+	return `38;2;${r};${g};${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)
+* - RGB (no palette index): 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}`;
+	const slot = paletteSlot(color);
+	if (slot !== void 0) {
+		if (slot <= 7) return `${40 + slot}`;
+		return `48;5;${slot}`;
 	}
-	return `48;2;${color.r};${color.g};${color.b}`;
+	const { r, g, b } = truecolorRgb(color);
+	return `48;2;${r};${g};${b}`;
 }
-var init_sgr_codes = __esmMin((() => {}));
 //#endregion
 //#region packages/ansi/src/utils.ts
 /**
+* Process-lifetime set of warning IDs that have already fired. Used by
+* {@link warnOnce} to avoid console spam on every re-render / every paste /
+* every parse. Shared across packages — one latch per warning ID, regardless
+* of which module emits it.
+*
+* Intentionally process-global (not scoped per {@link Term}) because the
+* warnings gated here describe developer-mistake conditions that are
+* semantically "once per process": spam is worse than missed repeats.
+*/
+const _firedWarnings = /* @__PURE__ */ new Set();
+/**
 * Emit a warning exactly once per process, keyed by `id`.
 *
 * The first call with a given `id` invokes `emit(message)`; subsequent calls
@@ -2795,12 +3032,56 @@ function warnOnce(id, emit) {
 	_firedWarnings.add(id);
 	emit();
 }
-var _firedWarnings;
-var init_utils = __esmMin((() => {
-	_firedWarnings = /* @__PURE__ */ new Set();
-}));
 //#endregion
 //#region packages/ansi/src/flatten.ts
+/**
+* Channel-role-state default rule. Matches Sterling / Primer / CSS-var
+* conventions: `{kind}-{role}[-{state}]`, with `fg-on-{role}` for `fgOn`,
+* and implicit-kind collapse for the `surface` / `border` roles.
+*
+* Mapping examples:
+* | Path                         | Flat key                    |
+* | ---------------------------- | --------------------------- |
+* | `accent.fg`                  | `fg-accent`                 |
+* | `accent.bg`                  | `bg-accent`                 |
+* | `accent.fgOn`                | `fg-on-accent`              |
+* | `inverse.muted.fgOn`         | `fg-on-inverse-muted`       |
+* | `accent.border`              | `border-accent`             |
+* | `accent.hover.bg`            | `bg-accent-hover`           |
+* | `accent.active.fg`           | `fg-accent-active`          |
+* | `info.hover.bg`              | `bg-info-hover`             |
+* | `cursor.fg`                  | `fg-cursor`                 |
+* | `muted.bg`                   | `bg-muted`                  |
+* | `surface.default`            | `bg-surface-default`        |
+* | `surface.subtle`             | `bg-surface-subtle`         |
+* | `surface.hover`              | `bg-surface-hover`          |
+* | `border.default`             | `border-default`            |
+* | `border.focus`               | `border-focus`              |
+* | `border.muted`               | `border-muted`              |
+*
+* Returns `null` for depth-1 leaves (e.g. `mode`, `name` — not role-scoped)
+* so metadata doesn't get flattened. The caller (`bakeFlat`) already filters
+* non-hex leaves, but the rule also guards paths shorter than 2 segments.
+*/
+const 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") {
+		const state = mid.length > 0 ? mid.join("-") : void 0;
+		return state ? `fg-on-${role}-${state}` : `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;
+};
+/** Matches `#rgb`, `#rrggbb`, and `#rrggbbaa` (case-insensitive). */
+const HEX_LEAF_RE = /^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?([0-9a-fA-F]{2})?$/;
 function isHexLeaf(value) {
 	return typeof value === "string" && HEX_LEAF_RE.test(value);
 }
@@ -2849,26 +3130,25 @@ function freezeDeep(o) {
 	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
+/**
+* ANSI terminal control helpers.
+*
+* Pure string-returning functions for terminal control sequences.
+* No side effects, no stdout writes -- consumers compose and write.
+*
+* Covers: screen management, cursor control, scroll regions,
+* mouse tracking, keyboard protocols, and bracketed paste.
+*
+* @see https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+* @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+*/
+/** Escape character (0x1B) */
+const ESC$1 = "\x1B";
+/** Control Sequence Introducer: ESC [ */
+const CSI$1 = `${ESC$1}[`;
+`${ESC$1}`;
 function enableMouse(options = {}) {
 	return `${CSI$1}?1003h${CSI$1}?1006h${options.pixels ? `${CSI$1}?1016h` : ""}`;
 }
@@ -2920,15 +3200,58 @@ function enableKittyKeyboard(flags = 1) {
 function disableKittyKeyboard() {
 	return `${CSI$1}<u`;
 }
-var ESC$1, CSI$1;
-var init_terminal_control = __esmMin((() => {
-	ESC$1 = "\x1B";
-	CSI$1 = `${ESC$1}[`;
-	`${ESC$1}`;
-}));
 //#endregion
 //#region packages/ansi/src/kitty-graphics.ts
 /**
+* Kitty graphics protocol — minimal encoder for cell-sized overlay placements.
+*
+* Used by the backdrop-fade pass to fade emoji/wide-char glyphs (SGR 2 "dim"
+* is a no-op on bitmap emoji in most terminals). We upload a single tiny
+* translucent RGBA image once, then emit `a=p` placements over specific cells
+* with `z=1` so the overlay sits on top of the already-rendered emoji glyph.
+*
+* ## Protocol summary
+*
+* The Kitty graphics protocol uses APC escapes: `\x1b_G<control>;<payload>\x1b\\`.
+* Control parameters are key=value pairs separated by commas. Payload is
+* base64-encoded image data (only on upload).
+*
+* Key commands we use:
+*
+* | Command     | Meaning                                                       |
+* | ----------- | ------------------------------------------------------------- |
+* | `a=t`       | Transmit (upload) image data                                  |
+* | `a=p`       | Place a previously-uploaded image                             |
+* | `a=d`       | Delete (remove placements and/or free images)                 |
+* | `f=32`      | RGBA pixel format (4 bytes per pixel)                         |
+* | `s=W,v=H`   | Source image dimensions in pixels                             |
+* | `i=<id>`    | Image ID (stable across frames)                               |
+* | `p=<id>`    | Placement ID (stable per cell)                                |
+* | `C=1`       | Disable cursor movement after placement (crucial for overlay) |
+* | `c=<cols>`  | Cell column extent                                            |
+* | `r=<rows>`  | Cell row extent                                               |
+* | `z=<zidx>`  | Z-index (0 = below text, 1 = above text)                      |
+* | `q=2`       | Quiet mode (suppress OK/error responses from terminal)        |
+*
+* Because the image is tiled into a single cell, `c=1,r=1,C=1` keeps the
+* placement local — it doesn't shift the rendered text layout.
+*
+* @see https://sw.kovidgoyal.net/kitty/graphics-protocol/
+*/
+/**
+* Stable image ID for the backdrop scrim overlay. Uploaded once per terminal
+* session; placements reuse this ID. Value is arbitrary — just needs to be
+* unique within the process. 0xBEEF picked for grep-ability.
+*/
+const BACKDROP_SCRIM_IMAGE_ID = 48879;
+/**
+* Placement ID base for backdrop scrim placements. Each cell gets a unique
+* placement ID derived from `x * OFFSET + y`. This lets us target individual
+* placements for deletion while leaving others alive. `i=<id>,p=<pid>` refers
+* to a single placement.
+*/
+const BACKDROP_PLACEMENT_X_STRIDE = 1e4;
+/**
 * Derive a stable placement ID for a given (x, y) cell. Max column = 9999,
 * which comfortably exceeds any realistic terminal width.
 */
@@ -3035,33 +3358,41 @@ function kittyDeleteAllScrimPlacements(imageId = BACKDROP_SCRIM_IMAGE_ID) {
 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
-	};
-}));
+/** Default ANSI codes for theme tokens when no theme object is given. */
+const 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
 /**
+* createStyle() — theme-aware chalk replacement.
+*
+* Returns a chainable Proxy-based style object. Access properties to
+* accumulate styles, call with a string to apply them.
+*
+* @example
+* ```ts
+* const s = createStyle()
+* s.bold.red("error")           // "\x1b[1;31merror\x1b[22;39m"
+* s.hex("#ff0000")("text")      // truecolor foreground
+*
+* const s = createStyle({ theme })
+* s.primary("deploy")           // resolves $primary from theme
+* ```
+*/
+/**
 * Resolve a color value against a theme — the canonical token resolver.
 *
 * If the color starts with `$`, looks up the token in the theme.
@@ -3112,6 +3443,35 @@ function resolveToken(name, theme) {
 		if (typeof stripped === "string") return stripped;
 	}
 }
+const ESC = "\x1B[";
+const KNOWN_METHODS = new Set([
+	"hex",
+	"rgb",
+	"bgHex",
+	"bgRgb",
+	"ansi256",
+	"bgAnsi256",
+	"resolve",
+	"curlyUnderline",
+	"dottedUnderline",
+	"dashedUnderline",
+	"doubleUnderline",
+	"underlineColor",
+	"styledUnderline"
+]);
+const THEME_TOKENS = new Set([
+	"primary",
+	"secondary",
+	"accent",
+	"error",
+	"warning",
+	"success",
+	"info",
+	"muted",
+	"link",
+	"border",
+	"surface"
+]);
 /** Convert chalk numeric level (0-3) to {@link ColorLevel}. */
 function fromChalkLevel(n) {
 	if (n <= 0) return "mono";
@@ -3177,6 +3537,7 @@ function createStyle(options) {
 		closes: []
 	}, ref);
 }
+createStyle();
 /**
 * Create a chain that reads level from a mutable ref.
 * This allows `style.level = 3` to affect all subsequent calls.
@@ -3344,6 +3705,8 @@ function createChainWithRef(state, ref) {
 	proxyRef.proxy = proxy;
 	return proxy;
 }
+const UNDERLINE_OPEN = "\x1B[4m";
+const UNDERLINE_CLOSE = "\x1B[24m";
 /** `style.curlyUnderline(text)` / `.dotted` / `.dashed` / `.double`. */
 function applyExtendedUnderline(text, name, ref) {
 	if (ref.level === "mono") return text;
@@ -3365,46 +3728,17 @@ function applyStyledUnderline(text, name, rgb, ref) {
 	if (!ref.caps.underlineColor) return `${styleCode}${text}${UNDERLINE_CODES.reset}`;
 	return `${styleCode}${buildUnderlineColorCode(r, g, b)}${text}${UNDERLINE_CODES.reset}${UNDERLINE_COLOR_RESET}`;
 }
-var ESC, KNOWN_METHODS, THEME_TOKENS, UNDERLINE_OPEN, UNDERLINE_CLOSE;
-var init_style = __esmMin((() => {
-	init_profile();
-	init_constants();
-	init_colors();
-	ESC = "\x1B[";
-	KNOWN_METHODS = new Set([
-		"hex",
-		"rgb",
-		"bgHex",
-		"bgRgb",
-		"ansi256",
-		"bgAnsi256",
-		"resolve",
-		"curlyUnderline",
-		"dottedUnderline",
-		"dashedUnderline",
-		"doubleUnderline",
-		"underlineColor",
-		"styledUnderline"
-	]);
-	THEME_TOKENS = new Set([
-		"primary",
-		"secondary",
-		"accent",
-		"error",
-		"warning",
-		"success",
-		"info",
-		"muted",
-		"link",
-		"border",
-		"surface"
-	]);
-	createStyle();
-	UNDERLINE_OPEN = "\x1B[4m";
-	UNDERLINE_CLOSE = "\x1B[24m";
-}));
 //#endregion
 //#region packages/ansi/src/style/mixed-proxy.ts
+/** Methods on Style that take arguments and return a new Style chain. */
+const STYLE_METHODS = new Set([
+	"hex",
+	"bgHex",
+	"rgb",
+	"bgRgb",
+	"ansi256",
+	"bgAnsi256"
+]);
 /**
 * Create a proxy that wraps a style instance with additional properties.
 *
@@ -3462,20 +3796,99 @@ function createChainProxy(currentStyle, extra) {
 	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/monochrome.ts
 /**
+* Default monochrome attrs — Polaris-aligned mapping from the design spec.
+*
+* The philosophy: every *semantic* token that would normally carry color gets an
+* attrs set that preserves its hierarchy rank and state semantics. Example:
+* error (danger) is bold+inverse so it *grabs* attention even without red;
+* warning is bold to stand out but not as aggressively; info is italic to
+* indicate auxiliary information.
+*
+* Structural surfaces (bg/mutedbg/surfacebg/popoverbg) have no attrs — they
+* represent background planes that monochrome terminals can't vary anyway.
+*/
+const DEFAULT_MONO_ATTRS = {
+	bg: [],
+	mutedbg: [],
+	surfacebg: [],
+	popoverbg: [],
+	border: [],
+	cursorbg: [],
+	fg: [],
+	muted: ["dim"],
+	disabledfg: ["dim"],
+	surface: [],
+	popover: [],
+	primary: ["bold"],
+	secondary: ["bold"],
+	accent: ["italic", "bold"],
+	error: ["bold", "inverse"],
+	warning: ["bold"],
+	success: ["bold"],
+	info: ["italic"],
+	primaryfg: [],
+	secondaryfg: [],
+	accentfg: [],
+	errorfg: ["inverse"],
+	warningfg: [],
+	successfg: [],
+	infofg: [],
+	focusborder: ["bold"],
+	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": [],
+	"bg-selected": ["inverse"],
+	"fg-on-selected": [],
+	"bg-selected-hover": ["inverse"],
+	"bg-inverse": ["inverse"],
+	"fg-on-inverse": [],
+	"bg-inverse-hover": ["inverse"],
+	"fg-on-inverse-muted": ["dim"],
+	"fg-link": ["underline"]
+};
+/**
 * Produce per-token monochrome attrs from a base Theme.
 *
 * Currently returns `DEFAULT_MONO_ATTRS` — a canonical mapping. Passed the
@@ -3517,87 +3930,29 @@ function monoAttrsForColorString(color, theme) {
 		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: [],
-		primary: ["bold"],
-		secondary: ["bold"],
-		accent: ["italic", "bold"],
-		error: ["bold", "inverse"],
-		warning: ["bold"],
-		success: ["bold"],
-		info: ["italic"],
-		primaryfg: [],
-		secondaryfg: [],
-		accentfg: [],
-		errorfg: ["inverse"],
-		warningfg: [],
-		successfg: [],
-		infofg: [],
-		focusborder: ["bold"],
-		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": [],
-		"bg-selected": ["inverse"],
-		"fg-on-selected": [],
-		"bg-selected-hover": ["inverse"],
-		"bg-inverse": ["inverse"],
-		"fg-on-inverse": [],
-		"fg-link": ["underline"]
-	};
-}));
 //#endregion
 //#region packages/ansi/src/theme/fingerprint.ts
+/** Fields that are always probed and used for fingerprinting. */
+const FINGERPRINT_FIELDS = [
+	"foreground",
+	"background",
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"cyan",
+	"white",
+	"brightBlack",
+	"brightRed",
+	"brightGreen",
+	"brightYellow",
+	"brightBlue",
+	"brightMagenta",
+	"brightCyan",
+	"brightWhite"
+];
 /**
 * Map ΔE thresholds into a 0–1 confidence.
 *
@@ -3650,58 +4005,32 @@ function fingerprintMatch(probed, catalog, opts = {}) {
 	}
 	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"
-	];
-}));
+const 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/orchestrator.ts
 function envOverride() {
@@ -3855,46 +4184,138 @@ async function detectSchemeTheme(opts = {}) {
 	const { theme } = await detectScheme(opts);
 	return theme;
 }
-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}`;
-}));
+//#region packages/ansi/src/sterling/flat-tokens.ts
+const STERLING_FLAT_TOKENS = [
+	"bg-surface-default",
+	"bg-surface-subtle",
+	"bg-surface-raised",
+	"bg-surface-overlay",
+	"bg-surface-hover",
+	"border-default",
+	"border-focus",
+	"border-muted",
+	"fg-cursor",
+	"bg-cursor",
+	"fg-muted",
+	"bg-muted",
+	"fg-faint",
+	"fg-accent",
+	"bg-accent",
+	"fg-on-accent",
+	"fg-accent-hover",
+	"bg-accent-hover",
+	"fg-accent-active",
+	"bg-accent-active",
+	"border-accent",
+	"fg-info",
+	"bg-info",
+	"fg-on-info",
+	"bg-info-hover",
+	"bg-info-active",
+	"fg-success",
+	"bg-success",
+	"fg-on-success",
+	"bg-success-hover",
+	"bg-success-active",
+	"fg-warning",
+	"bg-warning",
+	"fg-on-warning",
+	"bg-warning-hover",
+	"bg-warning-active",
+	"fg-error",
+	"bg-error",
+	"fg-on-error",
+	"bg-error-hover",
+	"bg-error-active",
+	"bg-selected",
+	"fg-on-selected",
+	"bg-selected-hover",
+	"bg-inverse",
+	"fg-on-inverse",
+	"bg-inverse-hover",
+	"fg-on-inverse-muted",
+	"fg-link",
+	"fg-disabled",
+	"bg-disabled",
+	"border-disabled",
+	"bg-backdrop",
+	"fg-default",
+	"bg-default"
+];
+new Set([
+	"bg",
+	"fg",
+	"muted",
+	"mutedbg",
+	"surface",
+	"surfacebg",
+	"popover",
+	"popoverbg",
+	"cursor",
+	"cursorbg",
+	"primary",
+	"primaryfg",
+	"secondary",
+	"secondaryfg",
+	"accent",
+	"accentfg",
+	"error",
+	"errorfg",
+	"warning",
+	"warningfg",
+	"success",
+	"successfg",
+	"info",
+	"infofg",
+	"border",
+	"inputborder",
+	"focusborder",
+	"disabledfg",
+	"palette",
+	"name",
+	"brand",
+	"brand-hover",
+	"brand-active",
+	"primary-hover",
+	"primary-active",
+	"accent-hover",
+	"accent-active",
+	"fg-hover",
+	"fg-active",
+	...STERLING_FLAT_TOKENS
+]);
 //#endregion
-//#region packages/ansi/src/theme/generators.ts
-var init_generators = __esmMin((() => {}));
+//#region packages/ansi/src/theme/tokens.ts
+/**
+* Runtime constant — the 12 built-in variant names shipped by silvery.
+*
+* Used in dev warnings when an unknown variant is looked up in Text.tsx:
+* ```
+* Warning: Unknown variant "h11". Known variants: h1, h2, h3, …
+* ```
+*
+* Mirrors `VariantName` exactly — update both when variants change.
+*/
+const KNOWN_VARIANTS = [
+	"h1",
+	"h2",
+	"h3",
+	"body",
+	"body-muted",
+	"fine-print",
+	"strong",
+	"em",
+	"link",
+	"key",
+	"code",
+	"kbd"
+];
 //#endregion
-//#region packages/ansi/src/theme/auto-generate.ts
-var init_auto_generate = __esmMin((() => {
-	init_generators();
-	init_derive();
-}));
+//#region packages/ansi/src/color-scheme.ts
+const CSI = `[`;
+`${CSI}`;
+`${CSI}`;
 //#endregion
 //#region packages/ansi/src/theme/generate.ts
 /**
@@ -3980,132 +4401,104 @@ function generateTheme(primary, dark) {
 		...derived
 	};
 }
-var init_generate = __esmMin((() => {
-	init_derived();
-}));
-//#endregion
-//#region packages/ansi/src/sterling/flat-tokens.ts
-var STERLING_FLAT_TOKENS;
-var init_flat_tokens = __esmMin((() => {
-	STERLING_FLAT_TOKENS = [
-		"bg-surface-default",
-		"bg-surface-subtle",
-		"bg-surface-raised",
-		"bg-surface-overlay",
-		"bg-surface-hover",
-		"border-default",
-		"border-focus",
-		"border-muted",
-		"fg-cursor",
-		"bg-cursor",
-		"fg-muted",
-		"bg-muted",
-		"fg-accent",
-		"bg-accent",
-		"fg-on-accent",
-		"fg-accent-hover",
-		"bg-accent-hover",
-		"fg-accent-active",
-		"bg-accent-active",
-		"border-accent",
-		"fg-info",
-		"bg-info",
-		"fg-on-info",
-		"bg-info-hover",
-		"bg-info-active",
-		"fg-success",
-		"bg-success",
-		"fg-on-success",
-		"bg-success-hover",
-		"bg-success-active",
-		"fg-warning",
-		"bg-warning",
-		"fg-on-warning",
-		"bg-warning-hover",
-		"bg-warning-active",
-		"fg-error",
-		"bg-error",
-		"fg-on-error",
-		"bg-error-hover",
-		"bg-error-active",
-		"bg-selected",
-		"fg-on-selected",
-		"bg-selected-hover",
-		"bg-inverse",
-		"fg-on-inverse",
-		"fg-link",
-		"fg-disabled",
-		"bg-disabled",
-		"border-disabled",
-		"bg-backdrop",
-		"fg-default",
-		"bg-default"
-	];
-}));
 //#endregion
 //#region packages/ansi/src/sterling/defaults.ts
+/**
+* A hand-tuned neutral dark scheme — not a copy of any catalog palette, but
+* close to Nord/Dracula territory. Used only when the caller asks for a
+* "raw default" (no scheme at all).
+*/
+const darkBaseline = {
+	name: "sterling-dark",
+	dark: true,
+	primary: "#7FB4CA",
+	black: "#1E1E2E",
+	red: "#E06C75",
+	green: "#98C379",
+	yellow: "#E5C07B",
+	blue: "#61AFEF",
+	magenta: "#C678DD",
+	cyan: "#56B6C2",
+	white: "#ABB2BF",
+	brightBlack: "#5C6370",
+	brightRed: "#E06C75",
+	brightGreen: "#98C379",
+	brightYellow: "#E5C07B",
+	brightBlue: "#61AFEF",
+	brightMagenta: "#C678DD",
+	brightCyan: "#56B6C2",
+	brightWhite: "#FFFFFF",
+	foreground: "#E4E4E7",
+	background: "#16181D",
+	cursorColor: "#E4E4E7",
+	cursorText: "#16181D",
+	selectionBackground: "#3E4452",
+	selectionForeground: "#E4E4E7"
+};
+const lightBaseline = {
+	name: "sterling-light",
+	dark: false,
+	primary: "#1F6FEB",
+	black: "#24292F",
+	red: "#CF222E",
+	green: "#1A7F37",
+	yellow: "#9A6700",
+	blue: "#0969DA",
+	magenta: "#8250DF",
+	cyan: "#1B7C83",
+	white: "#6E7781",
+	brightBlack: "#57606A",
+	brightRed: "#A40E26",
+	brightGreen: "#2DA44E",
+	brightYellow: "#BF8700",
+	brightBlue: "#218BFF",
+	brightMagenta: "#A475F9",
+	brightCyan: "#3192AA",
+	brightWhite: "#8C959F",
+	foreground: "#1F2328",
+	background: "#FFFFFF",
+	cursorColor: "#1F2328",
+	cursorText: "#FFFFFF",
+	selectionBackground: "#DDF4FF",
+	selectionForeground: "#1F2328"
+};
 function defaultScheme(mode = "dark") {
 	return mode === "dark" ? darkBaseline : lightBaseline;
 }
-var darkBaseline, lightBaseline;
-var init_defaults = __esmMin((() => {
-	darkBaseline = {
-		name: "sterling-dark",
-		dark: true,
-		primary: "#7FB4CA",
-		black: "#1E1E2E",
-		red: "#E06C75",
-		green: "#98C379",
-		yellow: "#E5C07B",
-		blue: "#61AFEF",
-		magenta: "#C678DD",
-		cyan: "#56B6C2",
-		white: "#ABB2BF",
-		brightBlack: "#5C6370",
-		brightRed: "#E06C75",
-		brightGreen: "#98C379",
-		brightYellow: "#E5C07B",
-		brightBlue: "#61AFEF",
-		brightMagenta: "#C678DD",
-		brightCyan: "#56B6C2",
-		brightWhite: "#FFFFFF",
-		foreground: "#E4E4E7",
-		background: "#16181D",
-		cursorColor: "#E4E4E7",
-		cursorText: "#16181D",
-		selectionBackground: "#3E4452",
-		selectionForeground: "#E4E4E7"
-	};
-	lightBaseline = {
-		name: "sterling-light",
-		dark: false,
-		primary: "#1F6FEB",
-		black: "#24292F",
-		red: "#CF222E",
-		green: "#1A7F37",
-		yellow: "#9A6700",
-		blue: "#0969DA",
-		magenta: "#8250DF",
-		cyan: "#1B7C83",
-		white: "#6E7781",
-		brightBlack: "#57606A",
-		brightRed: "#A40E26",
-		brightGreen: "#2DA44E",
-		brightYellow: "#BF8700",
-		brightBlue: "#218BFF",
-		brightMagenta: "#A475F9",
-		brightCyan: "#3192AA",
-		brightWhite: "#8C959F",
-		foreground: "#1F2328",
-		background: "#FFFFFF",
-		cursorColor: "#1F2328",
-		cursorText: "#FFFFFF",
-		selectionBackground: "#DDF4FF",
-		selectionForeground: "#1F2328"
-	};
-}));
 //#endregion
 //#region packages/ansi/src/sterling/define.ts
+/**
+* `defineDesignSystem` — wrap a DesignSystem so its derivations auto-apply
+* `bakeFlat` per the `flatten` flag.
+*
+* This makes flat-projection-on-same-object a FRAMEWORK feature, not a
+* Sterling-specific one. Any `DesignSystem` whose Theme is a nested POJO of
+* hex-string leaves gets `theme.accent.bg` AND `theme["bg-accent"]` access
+* without reimplementing the walk.
+*
+* ```ts
+* export const sterling = defineDesignSystem({
+*   name: "sterling",
+*   shape: STERLING_SHAPE,
+*   flatten: true,                      // ← opt in to default channel-role-state rule
+*   defaults(mode) { return derive(...) },
+*   theme(partial) { return derive(...) },
+*   deriveFromScheme(scheme) { return derive(...) },
+*   // … etc. Return VALUES without flat keys; defineDesignSystem bakes them.
+* })
+* ```
+*
+* Contract:
+* - `flatten: true` → apply `bakeFlat(theme)` with `defaultFlattenRule`
+* - `flatten: <fn>` → apply `bakeFlat(theme, <fn>)`
+* - `flatten: false` / omitted → pass-through (identity)
+*
+* All derivation methods (`defaults`, `theme`, `deriveFromScheme`,
+* `deriveFromColor`, `deriveFromPair`, `deriveFromSchemeWithBrand`) are
+* wrapped; their return values go through the flatten filter before
+* reaching the caller. `deriveFromPair` returns `{ light, dark }` —
+* both are flattened.
+*/
 function resolveFlatten(flatten) {
 	if (flatten === false || flatten === void 0) return (t) => t;
 	if (typeof flatten === "function") {
@@ -4140,9 +4533,6 @@ function defineDesignSystem(def) {
 		deriveFromSchemeWithBrand: (scheme, brand, opts) => flatten(def.deriveFromSchemeWithBrand(scheme, brand, opts))
 	};
 }
-var init_define = __esmMin((() => {
-	init_flatten();
-}));
 //#endregion
 //#region packages/ansi/src/sterling/sterling.ts
 /**
@@ -4164,6 +4554,26 @@ var init_define = __esmMin((() => {
 * AND flat hyphen keys populated — the user-facing `$fg-accent` syntax
 * resolves against the flat keys, while programmatic access uses nested.
 */
+const STERLING_SHAPE = {
+	flatTokens: STERLING_FLAT_TOKENS,
+	roles: [
+		"accent",
+		"info",
+		"success",
+		"warning",
+		"error",
+		"muted",
+		"faint",
+		"surface",
+		"border",
+		"cursor",
+		"selected",
+		"inverse",
+		"link",
+		"disabled"
+	],
+	states: ["hover", "active"]
+};
 /**
 * Internal: build a nested Theme (no flat keys). `defineDesignSystem` applies
 * `bakeFlat` afterwards — the inner derivation stays flat-agnostic.
@@ -4192,78 +4602,115 @@ function applyBrand(scheme, brand) {
 		primary: brand
 	};
 }
-var STERLING_SHAPE, rawSterling, sterling;
-var init_sterling$1 = __esmMin((() => {
-	init_derive$1();
-	init_flat_tokens();
-	init_defaults();
-	init_define();
-	STERLING_SHAPE = {
-		flatTokens: STERLING_FLAT_TOKENS,
-		roles: [
-			"accent",
-			"info",
-			"success",
-			"warning",
-			"error",
-			"muted",
-			"surface",
-			"border",
-			"cursor",
-			"selected",
-			"inverse",
-			"link",
-			"disabled"
-		],
-		states: ["hover", "active"]
-	};
-	rawSterling = {
-		name: "sterling",
-		shape: STERLING_SHAPE,
-		flatten: true,
-		defaults(mode = "dark") {
-			return buildRawTheme(defaultScheme(mode), { contrast: "auto-lift" });
-		},
-		theme(partial, opts = {}) {
-			const base = buildRawTheme(defaultScheme(opts.mode ?? "dark"), {
+/**
+* Sterling — the user-facing DesignSystem. `defineDesignSystem` wraps
+* `rawSterling` with auto-`bakeFlat` (per `flatten: true`), so every
+* returned Theme has both nested roles AND flat hyphen keys populated.
+*/
+const sterling = defineDesignSystem({
+	name: "sterling",
+	shape: STERLING_SHAPE,
+	flatten: true,
+	defaults(mode = "dark") {
+		return buildRawTheme(defaultScheme(mode), { contrast: "auto-lift" });
+	},
+	theme(partial, opts = {}) {
+		const base = buildRawTheme(defaultScheme(opts.mode ?? "dark"), {
+			...opts,
+			contrast: opts.contrast ?? "auto-lift"
+		});
+		if (!partial) return base;
+		return mergePartial(base, partial);
+	},
+	deriveFromScheme(scheme, opts = {}) {
+		return buildRawTheme(scheme, opts);
+	},
+	deriveFromColor(color, opts = {}) {
+		return buildRawTheme({
+			...defaultScheme(opts.mode ?? "dark"),
+			name: `seed:${color}`,
+			primary: color,
+			blue: color,
+			brightBlue: blend(color, "#ffffff", .15)
+		}, opts);
+	},
+	deriveFromPair(light, dark, opts = {}) {
+		return {
+			light: buildRawTheme(light, {
 				...opts,
-				contrast: opts.contrast ?? "auto-lift"
-			});
-			if (!partial) return base;
-			return mergePartial(base, partial);
-		},
-		deriveFromScheme(scheme, opts = {}) {
-			return buildRawTheme(scheme, opts);
-		},
-		deriveFromColor(color, opts = {}) {
-			return buildRawTheme({
-				...defaultScheme(opts.mode ?? "dark"),
-				name: `seed:${color}`,
-				primary: color,
-				blue: color,
-				brightBlue: blend(color, "#ffffff", .15)
-			}, opts);
-		},
-		deriveFromPair(light, dark, opts = {}) {
-			return {
-				light: buildRawTheme(light, {
-					...opts,
-					mode: "light"
-				}),
-				dark: buildRawTheme(dark, {
-					...opts,
-					mode: "dark"
-				})
-			};
-		},
-		deriveFromSchemeWithBrand(scheme, brand, opts = {}) {
-			return buildRawTheme(applyBrand(scheme, brand), opts);
-		}
-	};
-	sterling = defineDesignSystem(rawSterling);
-}));
+				mode: "light"
+			}),
+			dark: buildRawTheme(dark, {
+				...opts,
+				mode: "dark"
+			})
+		};
+	},
+	deriveFromSchemeWithBrand(scheme, brand, opts = {}) {
+		return buildRawTheme(applyBrand(scheme, brand), opts);
+	}
+});
 //#endregion
 //#region packages/ansi/src/sterling/token-manifest.ts
+const AA = "AA 4.5:1";
+const NA = "—";
+[...[
+	"info",
+	"success",
+	"warning",
+	"error"
+].flatMap((role) => [
+	{
+		flat: `fg-${role}`,
+		path: `${role}.fg`,
+		family: role,
+		axis: "fg",
+		purpose: `${capitalize(role)} status text.`,
+		derivation: seedRule(role),
+		contrast: AA,
+		tierNotes: "Seeds from the matching ANSI palette slot."
+	},
+	{
+		flat: `bg-${role}`,
+		path: `${role}.bg`,
+		family: role,
+		axis: "bg",
+		purpose: `${capitalize(role)} fill — alerts, badges.`,
+		derivation: seedRule(role),
+		contrast: NA,
+		tierNotes: "Distinct from siblings in ALL 84 palettes (collision test)."
+	},
+	{
+		flat: `fg-on-${role}`,
+		path: `${role}.fgOn`,
+		family: role,
+		axis: "fg-on",
+		purpose: `Foreground when drawing text ON \`bg-${role}\`.`,
+		derivation: "contrast-pick(scheme.fg / scheme.bg / black / white) for AA on bg.",
+		contrast: AA,
+		tierNotes: "Pre-quantization pick."
+	},
+	{
+		flat: `bg-${role}-hover`,
+		path: `${role}.hover.bg`,
+		family: role,
+		axis: "bg-hover",
+		purpose: `Hover fill for ${role} surfaces.`,
+		derivation: `OKLCH ±0.04L on bg-${role}.`,
+		contrast: NA,
+		tierNotes: "Often collapses with bg in ansi16."
+	},
+	{
+		flat: `bg-${role}-active`,
+		path: `${role}.active.bg`,
+		family: role,
+		axis: "bg-active",
+		purpose: `Pressed/active fill for ${role} surfaces.`,
+		derivation: `OKLCH ±0.08L on bg-${role}.`,
+		contrast: NA,
+		tierNotes: "Collapses to bg in low tiers."
+	}
+])];
 function capitalize(s) {
 	return s.charAt(0).toUpperCase() + s.slice(1);
 }
@@ -4275,113 +4722,7 @@ function seedRule(role) {
 		case "error": return "scheme.red.";
 	}
 }
-var AA, NA;
-var init_token_manifest = __esmMin((() => {
-	AA = "AA 4.5:1";
-	NA = "—";
-	[...[
-		"info",
-		"success",
-		"warning",
-		"error"
-	].flatMap((role) => [
-		{
-			flat: `fg-${role}`,
-			path: `${role}.fg`,
-			family: role,
-			axis: "fg",
-			purpose: `${capitalize(role)} status text.`,
-			derivation: seedRule(role),
-			contrast: AA,
-			tierNotes: "Seeds from the matching ANSI palette slot."
-		},
-		{
-			flat: `bg-${role}`,
-			path: `${role}.bg`,
-			family: role,
-			axis: "bg",
-			purpose: `${capitalize(role)} fill — alerts, badges.`,
-			derivation: seedRule(role),
-			contrast: NA,
-			tierNotes: "Distinct from siblings in ALL 84 palettes (collision test)."
-		},
-		{
-			flat: `fg-on-${role}`,
-			path: `${role}.fgOn`,
-			family: role,
-			axis: "fg-on",
-			purpose: `Foreground when drawing text ON \`bg-${role}\`.`,
-			derivation: "contrast-pick(scheme.fg / scheme.bg / black / white) for AA on bg.",
-			contrast: AA,
-			tierNotes: "Pre-quantization pick."
-		},
-		{
-			flat: `bg-${role}-hover`,
-			path: `${role}.hover.bg`,
-			family: role,
-			axis: "bg-hover",
-			purpose: `Hover fill for ${role} surfaces.`,
-			derivation: `OKLCH ±0.04L on bg-${role}.`,
-			contrast: NA,
-			tierNotes: "Often collapses with bg in ansi16."
-		},
-		{
-			flat: `bg-${role}-active`,
-			path: `${role}.active.bg`,
-			family: role,
-			axis: "bg-active",
-			purpose: `Pressed/active fill for ${role} surfaces.`,
-			derivation: `OKLCH ±0.08L on bg-${role}.`,
-			contrast: NA,
-			tierNotes: "Collapses to bg in low tiers."
-		}
-	])];
-}));
-//#endregion
-//#region packages/ansi/src/sterling/index.ts
-var init_sterling = __esmMin((() => {
-	init_sterling$1();
-	init_define();
-	init_derive$1();
-	init_inline();
-	init_flat_tokens();
-	init_token_manifest();
-	init_defaults();
-	init_contrast();
-}));
-//#endregion
-//#region packages/ansi/src/index.ts
-var init_src = __esmMin((() => {
-	init_caps();
-	init_profile();
-	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_protocol_error();
-	init_osc_palette();
-	init_color_scheme();
-	init_generators();
-	init_auto_generate();
-	init_generate();
-	init_sterling();
-}));
 //#endregion
-export { queryMultiplePaletteColors as $, bgColorCode as A, detectColorScheme as B, disableMouse as C, bakeFlat as D, enableMouse as E, pickColorLevel as F, resetCursorColor as G, queryCursorColor as H, quantizeHex as I, setCursorColor as J, resetForegroundColor as K, detectTerminalScheme as L, createTerminalProfile as M, probeTerminalProfile as N, defaultFlattenRule as O, ANSI16_SLOT_HEX as P, parsePaletteResponse as Q, detectTheme as R, disableKittyKeyboard as S, enableKittyKeyboard as T, queryForegroundColor as U, queryBackgroundColor as V, resetBackgroundColor as W, ProtocolError as X, setForegroundColor as Y, isProtocolError as Z, cupTo as _, STERLING_FLAT_TOKENS as a, deriveRoles as at, kittyUploadScrimImage as b, detectScheme as c, WCAG_AA as ct, monoAttrsForColorString as d, deriveFields as dt, queryPaletteColor as et, createMixedStyle as f, defaultCaps as ft, buildScrimPixels as g, backdropPlacementId as h, defaultScheme as i, deriveTheme as it, fgColorCode as j, warnOnce as k, detectSchemeTheme as l, autoLift as lt, resolveThemeColor as m, sterling as n, ansi16DarkTheme as nt, generateTheme as o, deriveTheme$1 as ot, createStyle as p, setBackgroundColor as q, defineDesignSystem as r, ansi16LightTheme as rt, KNOWN_VARIANTS as s, ContrastError as st, init_src as t, setPaletteColor as tt, COLOR_SCHEME_FIELDS as u, checkAA as ut, kittyDeleteAllScrimPlacements as v, enableBracketedPaste as w, disableBracketedPaste as x, kittyPlaceAt as y, probeColors as z };
+export { setForegroundColor as $, fgColorCode as A, rgbToAnsi256 as B, enableBracketedPaste as C, defaultFlattenRule as D, bakeFlat as E, bgFromRgb as F, queryBackgroundColor as G, detectTheme as H, fgFromRgb as I, resetBackgroundColor as J, queryCursorColor as K, nearestAnsi16 as L, detectColorFromEnv as M, probeTerminalProfile as N, warnOnce as O, ANSI16_SLOT_HEX as P, setCursorColor as Q, pickColorLevel as R, disableMouse as S, enableMouse as T, probeColors as U, detectTerminalScheme as V, detectColorScheme as W, resetForegroundColor as X, resetCursorColor as Y, setBackgroundColor as Z, kittyDeleteAllScrimPlacements as _, KNOWN_VARIANTS as a, setPaletteColor as at, disableBracketedPaste as b, detectSchemeTheme as c, deriveTheme as ct, createMixedStyle as d, ContrastError as dt, ProtocolError as et, createStyle as f, WCAG_AA as ft, cupTo as g, defaultCaps as gt, buildScrimPixels as h, deriveFields as ht, generateTheme as i, queryPaletteColor as it, createTerminalProfile as j, bgColorCode as k, COLOR_SCHEME_FIELDS as l, deriveRoles as lt, backdropPlacementId as m, checkAA as mt, defineDesignSystem as n, parsePaletteResponse as nt, STERLING_FLAT_TOKENS as o, ansi16DarkTheme as ot, resolveThemeColor as p, autoLift as pt, queryForegroundColor as q, defaultScheme as r, queryMultiplePaletteColors as rt, detectScheme as s, ansi16LightTheme as st, sterling as t, isProtocolError as tt, monoAttrsForColorString as u, deriveTheme$1 as ut, kittyPlaceAt as v, enableKittyKeyboard as w, disableKittyKeyboard as x, kittyUploadScrimImage as y, quantizeHex as z };
 
-//# sourceMappingURL=src-BNTToU7l.mjs.map
+//# sourceMappingURL=src-B8lf1kiR.mjs.map